1126 lines
40 KiB
C#
1126 lines
40 KiB
C#
// Copyright HTC Corporation All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using UnityEditor;
|
|
using UnityEngine.XR.OpenXR;
|
|
using UnityEngine.XR.OpenXR.Features;
|
|
using UnityEngine;
|
|
using UnityEngine.XR;
|
|
using AOT;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor.XR.OpenXR.Features;
|
|
#endif
|
|
|
|
namespace VIVE.OpenXR.Passthrough
|
|
{
|
|
#if UNITY_EDITOR
|
|
[OpenXRFeature(UiName = "VIVE XR Passthrough",
|
|
Desc = "Enable this feature to use the VIVE OpenXR Passthrough feature.",
|
|
Company = "HTC",
|
|
DocumentationLink = "..\\Documentation",
|
|
OpenxrExtensionStrings = kOpenxrExtensionStrings,
|
|
Version = "1.0.0",
|
|
BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
|
|
FeatureId = featureId
|
|
)]
|
|
#endif
|
|
public class VivePassthrough : OpenXRFeature
|
|
{
|
|
#region LOG
|
|
const string LOG_TAG = "VIVE.OpenXR.Passthrough.VivePassthrough";
|
|
StringBuilder m_sb = null;
|
|
StringBuilder sb {
|
|
get {
|
|
if (m_sb == null) { m_sb = new StringBuilder(); }
|
|
return m_sb;
|
|
}
|
|
}
|
|
static void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
|
|
static void DEBUG(StringBuilder msg) { Debug.LogFormat("{0} {1}", LOG_TAG, msg); }
|
|
static void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
|
|
static void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// The feature id string. This is used to give the feature a well known id for reference.
|
|
/// </summary>
|
|
public const string featureId = "vive.openxr.feature.passthrough";
|
|
|
|
/// <summary>
|
|
/// The extension string.
|
|
/// </summary>
|
|
public const string kOpenxrExtensionStrings = "XR_HTC_passthrough XR_HTC_passthrough_configuration";
|
|
|
|
#if UNITY_STANDALONE
|
|
private static IntPtr xrGetInstanceProcAddr_prev;
|
|
private static IntPtr XrEndFrame_prev;
|
|
private static IntPtr XrWaitFrame_prev;
|
|
private static List<IntPtr> layerListOrigin = new List<IntPtr>();
|
|
private static List<IntPtr> layerListModified = new List<IntPtr>();
|
|
private static IntPtr layersModified = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(IntPtr)) * 30)); //Preallocate a layer buffer with sufficient size and reuse it for each frame.
|
|
protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
|
|
{
|
|
UnityEngine.Debug.Log("EXT: registering our own xrGetInstanceProcAddr");
|
|
xrGetInstanceProcAddr_prev = func;
|
|
return Marshal.GetFunctionPointerForDelegate(Intercept_xrGetInstanceProcAddr);
|
|
}
|
|
[MonoPInvokeCallback(typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate))]
|
|
private static XrResult InterceptXrEndFrame_xrGetInstanceProcAddr(XrInstance instance, string name, out IntPtr function)
|
|
{
|
|
if (xrGetInstanceProcAddr_prev == null || xrGetInstanceProcAddr_prev == IntPtr.Zero)
|
|
{
|
|
UnityEngine.Debug.LogError("xrGetInstanceProcAddr_prev is null");
|
|
function = IntPtr.Zero;
|
|
return XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
}
|
|
|
|
// Get delegate of old xrGetInstanceProcAddr.
|
|
var xrGetProc = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrGetInstanceProcAddrDelegate>(xrGetInstanceProcAddr_prev);
|
|
XrResult result = xrGetProc(instance, name, out function);
|
|
if (name == "xrEndFrame")
|
|
{
|
|
XrEndFrame_prev = function;
|
|
m_intercept_xrEndFrame = intercepted_xrEndFrame;
|
|
function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrEndFrame); ;
|
|
UnityEngine.Debug.Log("Getting xrEndFrame func");
|
|
}
|
|
if (name == "xrWaitFrame")
|
|
{
|
|
XrWaitFrame_prev = function;
|
|
m_intercept_xrWaitFrame = intercepted_xrWaitFrame;
|
|
function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame); ;
|
|
UnityEngine.Debug.Log("Getting xrWaitFrame func");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
[MonoPInvokeCallback(typeof(OpenXRHelper.xrEndFrameDelegate))]
|
|
private static XrResult intercepted_xrEndFrame(XrSession session, ref XrFrameEndInfo frameEndInfo)
|
|
{
|
|
XrResult res;
|
|
// Get delegate of prev xrEndFrame.
|
|
var xrEndFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrEndFrameDelegate>(XrEndFrame_prev);
|
|
|
|
layerListOrigin.Clear();
|
|
uint layerCount = frameEndInfo.layerCount;
|
|
IntPtr layers = frameEndInfo.layers;
|
|
for (int i = 0; i < layerCount; i++)
|
|
{
|
|
IntPtr ptr = Marshal.ReadIntPtr(layers, i * Marshal.SizeOf(typeof(IntPtr)));
|
|
XrCompositionLayerBaseHeader header = (XrCompositionLayerBaseHeader)Marshal.PtrToStructure(ptr, typeof(XrCompositionLayerBaseHeader));
|
|
layerListOrigin.Add(ptr);
|
|
}
|
|
List<IntPtr> layerListNew;
|
|
if (layerListModified.Count != 0)
|
|
{
|
|
layerListNew = new List<IntPtr>(layerListModified);
|
|
}
|
|
else
|
|
{
|
|
layerListNew = new List<IntPtr>(layerListOrigin);
|
|
}
|
|
for (int i = 0; i < layerListNew.Count; i++)
|
|
{
|
|
Marshal.WriteIntPtr(layersModified, i * Marshal.SizeOf(typeof(IntPtr)), layerListNew[i]);
|
|
}
|
|
frameEndInfo.layers = layersModified;
|
|
frameEndInfo.layerCount = (uint)layerListNew.Count;
|
|
|
|
res = xrEndFrame(session, ref frameEndInfo);
|
|
return res;
|
|
}
|
|
private static XrFrameWaitInfo m_frameWaitInfo;
|
|
private static XrFrameState m_frameState;
|
|
[MonoPInvokeCallback(typeof(OpenXRHelper.xrWaitFrameDelegate))]
|
|
private static int intercepted_xrWaitFrame(ulong session, ref XrFrameWaitInfo frameWaitInfo, ref XrFrameState frameState)
|
|
{
|
|
var xrWaitFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrWaitFrameDelegate>(XrWaitFrame_prev);
|
|
int res = xrWaitFrame(session, ref frameWaitInfo, ref frameState);
|
|
m_frameWaitInfo = frameWaitInfo;
|
|
m_frameState = frameState;
|
|
return res;
|
|
}
|
|
public void GetOriginEndFrameLayerList(out List<IntPtr> layers)
|
|
{
|
|
layers = new List<IntPtr>(layerListOrigin);
|
|
}
|
|
|
|
public void SubmitLayers(List<IntPtr> layers)
|
|
{
|
|
layerListModified = new List<IntPtr>(layers);
|
|
//UnityEngine.Debug.Log("####Update submit end " + layerListModified.Count);
|
|
}
|
|
public XrFrameState GetFrameState()
|
|
{
|
|
return m_frameState;
|
|
}
|
|
#endif
|
|
#if UNITY_ANDROID
|
|
protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
|
|
{
|
|
ViveInterceptors.Instance.AddRequiredFunction("xrPollEvent");
|
|
return ViveInterceptors.Instance.HookGetInstanceProcAddr(func);
|
|
}
|
|
#endif
|
|
|
|
#region OpenXR Life Cycle
|
|
private bool m_XrInstanceCreated = false;
|
|
/// <summary>
|
|
/// The XR instance is created or not.
|
|
/// </summary>
|
|
public bool XrInstanceCreated
|
|
{
|
|
get { return m_XrInstanceCreated; }
|
|
}
|
|
private XrInstance m_XrInstance = 0;
|
|
protected override bool OnInstanceCreate(ulong xrInstance)
|
|
{
|
|
foreach (string kOpenxrExtensionString in kOpenxrExtensionStrings.Split(' '))
|
|
{
|
|
if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
|
|
{
|
|
WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
|
|
}
|
|
else
|
|
{
|
|
DEBUG("OnInstanceCreate() " + kOpenxrExtensionString + " is enabled.");
|
|
}
|
|
}
|
|
|
|
m_XrInstanceCreated = true;
|
|
m_XrInstance = xrInstance;
|
|
DEBUG("OnInstanceCreate() " + m_XrInstance);
|
|
|
|
return GetXrFunctionDelegates(m_XrInstance);
|
|
}
|
|
protected override void OnInstanceDestroy(ulong xrInstance)
|
|
{
|
|
m_XrInstanceCreated = false;
|
|
DEBUG("OnInstanceDestroy() " + m_XrInstance);
|
|
}
|
|
|
|
private XrSystemId m_XrSystemId = 0;
|
|
protected override void OnSystemChange(ulong xrSystem)
|
|
{
|
|
m_XrSystemId = xrSystem;
|
|
DEBUG("OnSystemChange() " + m_XrSystemId);
|
|
}
|
|
|
|
private bool m_XrSessionCreated = false;
|
|
/// <summary>
|
|
/// The XR session is created or not.
|
|
/// </summary>
|
|
public bool XrSessionCreated
|
|
{
|
|
get { return m_XrSessionCreated; }
|
|
}
|
|
private XrSession m_XrSession = 0;
|
|
protected override void OnSessionCreate(ulong xrSession)
|
|
{
|
|
m_XrSession = xrSession;
|
|
m_XrSessionCreated = true;
|
|
DEBUG("OnSessionCreate() " + m_XrSession);
|
|
CheckConfigurationSupport();
|
|
}
|
|
|
|
private XrSpace m_WorldLockSpaceOriginOnHead = 0, m_WorldLockSpaceOriginOnFloor = 0, m_HeadLockSpace = 0;
|
|
private XrSpace WorldLockSpaceOriginOnHead
|
|
{
|
|
get { return m_WorldLockSpaceOriginOnHead; }
|
|
}
|
|
private XrSpace WorldLockSpaceOriginOnFloor
|
|
{
|
|
get { return m_WorldLockSpaceOriginOnFloor; }
|
|
}
|
|
private XrSpace HeadLockSpace
|
|
{
|
|
get { return m_HeadLockSpace; }
|
|
}
|
|
|
|
private bool m_XrSessionEnding = false;
|
|
/// <summary>
|
|
/// The XR session is ending or not.
|
|
/// </summary>
|
|
public bool XrSessionEnding
|
|
{
|
|
get { return m_XrSessionEnding; }
|
|
}
|
|
protected override void OnSessionBegin(ulong xrSession)
|
|
{
|
|
m_XrSessionEnding = false;
|
|
DEBUG("OnSessionBegin() " + m_XrSession);
|
|
|
|
// Enumerate supported reference space types and create the XrSpace.
|
|
XrReferenceSpaceType[] spaces = new XrReferenceSpaceType[Enum.GetNames(typeof(XrReferenceSpaceType)).Count()];
|
|
UInt32 spaceCountOutput;
|
|
if (EnumerateReferenceSpaces(
|
|
spaceCapacityInput: 0,
|
|
spaceCountOutput: out spaceCountOutput,
|
|
spaces: out spaces[0]) == XrResult.XR_SUCCESS)
|
|
{
|
|
//DEBUG("spaceCountOutput: " + spaceCountOutput);
|
|
|
|
Array.Resize(ref spaces, (int)spaceCountOutput);
|
|
if (EnumerateReferenceSpaces(
|
|
spaceCapacityInput: spaceCountOutput,
|
|
spaceCountOutput: out spaceCountOutput,
|
|
spaces: out spaces[0]) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL))
|
|
{
|
|
XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
|
|
referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
|
|
referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
|
|
referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_LOCAL;
|
|
referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
|
|
referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
|
|
|
|
if (CreateReferenceSpace(
|
|
createInfo: ref referenceSpaceCreateInfoWorldLock,
|
|
space: out m_WorldLockSpaceOriginOnHead) == XrResult.XR_SUCCESS)
|
|
{
|
|
//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnHead);
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace for world lock layers on head failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace no space type for world lock on head layers.");
|
|
}
|
|
|
|
if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE))
|
|
{
|
|
XrReferenceSpaceCreateInfo referenceSpaceCreateInfoWorldLock;
|
|
referenceSpaceCreateInfoWorldLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
|
|
referenceSpaceCreateInfoWorldLock.next = IntPtr.Zero;
|
|
referenceSpaceCreateInfoWorldLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_STAGE;
|
|
referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
|
|
referenceSpaceCreateInfoWorldLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
|
|
|
|
if (CreateReferenceSpace(
|
|
createInfo: ref referenceSpaceCreateInfoWorldLock,
|
|
space: out m_WorldLockSpaceOriginOnFloor) == XrResult.XR_SUCCESS)
|
|
{
|
|
//DEBUG("CreateReferenceSpace: " + m_WorldLockSpaceOriginOnFloor);
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace for world lock layers on floor failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace no space type for world lock on floor layers.");
|
|
}
|
|
|
|
if (spaces.Contains(XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW))
|
|
{
|
|
XrReferenceSpaceCreateInfo referenceSpaceCreateInfoHeadLock;
|
|
referenceSpaceCreateInfoHeadLock.type = XrStructureType.XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
|
|
referenceSpaceCreateInfoHeadLock.next = IntPtr.Zero;
|
|
referenceSpaceCreateInfoHeadLock.referenceSpaceType = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_VIEW;
|
|
referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.orientation = new XrQuaternionf(0, 0, 0, 1);
|
|
referenceSpaceCreateInfoHeadLock.poseInReferenceSpace.position = new XrVector3f(0, 0, 0);
|
|
|
|
if (CreateReferenceSpace(
|
|
createInfo: ref referenceSpaceCreateInfoHeadLock,
|
|
space: out m_HeadLockSpace) == XrResult.XR_SUCCESS)
|
|
{
|
|
//DEBUG("CreateReferenceSpace: " + m_HeadLockSpace);
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace for head lock layers failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("CreateReferenceSpace no space type for head lock layers.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("EnumerateReferenceSpaces(" + spaceCountOutput + ") failed.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("EnumerateReferenceSpaces(0) failed.");
|
|
}
|
|
}
|
|
protected override void OnSessionEnd(ulong xrSession)
|
|
{
|
|
m_XrSessionEnding = true;
|
|
DEBUG("OnSessionEnd() " + m_XrSession);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The delegate of Passthrough Session Destroy.
|
|
/// </summary>
|
|
public delegate void OnPassthroughSessionDestroyDelegate(XrPassthroughHTC passthroughID);
|
|
private Dictionary<XrPassthroughHTC, OnPassthroughSessionDestroyDelegate> OnPassthroughSessionDestroyHandlerDictionary = new Dictionary<XrPassthroughHTC, OnPassthroughSessionDestroyDelegate>();
|
|
protected override void OnSessionDestroy(ulong xrSession)
|
|
{
|
|
if (!m_XrSessionCreated || m_XrSession != xrSession) { return; }
|
|
|
|
sb.Clear().Append("OnSessionDestroy() " + xrSession); DEBUG(sb);
|
|
m_XrSessionCreated = false;
|
|
m_XrSession = 0;
|
|
|
|
List<XrPassthroughHTC> passthroughs = PassthroughList;
|
|
for (int i = 0; i < passthroughs.Count; i++)
|
|
{
|
|
XrPassthroughHTC currentpassthrough = passthroughs[i];
|
|
DestroyPassthroughHTC(currentpassthrough);
|
|
if (OnPassthroughSessionDestroyHandlerDictionary.ContainsKey(currentpassthrough) && OnPassthroughSessionDestroyHandlerDictionary[currentpassthrough] != null)
|
|
{
|
|
sb.Clear().Append("OnSessionDestroy() Call back ").Append(passthroughs[i]); DEBUG(sb);
|
|
OnPassthroughSessionDestroyHandlerDictionary[passthroughs[i]].Invoke(passthroughs[i]);
|
|
}
|
|
}
|
|
|
|
if (m_HeadLockSpace != 0)
|
|
{
|
|
DestroySpace(m_HeadLockSpace);
|
|
m_HeadLockSpace = 0;
|
|
}
|
|
if (m_WorldLockSpaceOriginOnFloor != 0)
|
|
{
|
|
DestroySpace(m_WorldLockSpaceOriginOnFloor);
|
|
m_WorldLockSpaceOriginOnFloor = 0;
|
|
}
|
|
if (m_WorldLockSpaceOriginOnHead != 0)
|
|
{
|
|
DestroySpace(m_WorldLockSpaceOriginOnHead);
|
|
m_WorldLockSpaceOriginOnHead = 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The current XR session state.
|
|
/// </summary>
|
|
public XrSessionState XrSessionCurrentState
|
|
{
|
|
get { return m_XrSessionNewState; }
|
|
}
|
|
private XrSessionState m_XrSessionNewState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
|
|
private XrSessionState m_XrSessionOldState = XrSessionState.XR_SESSION_STATE_UNKNOWN;
|
|
protected override void OnSessionStateChange(int oldState, int newState)
|
|
{
|
|
DEBUG("OnSessionStateChange() oldState: " + oldState + " newState:" + newState);
|
|
|
|
if (Enum.IsDefined(typeof(XrSessionState), oldState))
|
|
{
|
|
m_XrSessionOldState = (XrSessionState)oldState;
|
|
}
|
|
else
|
|
{
|
|
DEBUG("OnSessionStateChange() oldState undefined");
|
|
}
|
|
|
|
if (Enum.IsDefined(typeof(XrSessionState), newState))
|
|
{
|
|
m_XrSessionNewState = (XrSessionState)newState;
|
|
}
|
|
else
|
|
{
|
|
DEBUG("OnSessionStateChange() newState undefined");
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region OpenXR function delegates
|
|
/// xrGetInstanceProcAddr
|
|
OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
|
|
|
|
/// xrGetSystemProperties
|
|
OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
|
|
/// <summary>
|
|
/// Helper function to get this feature' properties.
|
|
/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystemProperties">xrGetSystemProperties</see>
|
|
/// </summary>
|
|
public XrResult GetSystemProperties(ref XrSystemProperties properties)
|
|
{
|
|
if (m_XrInstanceCreated)
|
|
{
|
|
return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
|
|
}
|
|
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
#if UNITY_STANDALONE
|
|
OpenXRHelper.xrGetInstanceProcAddrDelegate Intercept_xrGetInstanceProcAddr =
|
|
new OpenXRHelper.xrGetInstanceProcAddrDelegate(InterceptXrEndFrame_xrGetInstanceProcAddr);
|
|
|
|
private static OpenXRHelper.xrEndFrameDelegate m_intercept_xrEndFrame;
|
|
private static OpenXRHelper.xrWaitFrameDelegate m_intercept_xrWaitFrame;
|
|
|
|
VivePassthroughHelper.xrCreatePassthroughHTCDelegate xrCreatePassthroughHTC;
|
|
VivePassthroughHelper.xrDestroyPassthroughHTCDelegate xrDestroyPassthroughHTC;
|
|
#endif
|
|
|
|
/// xrEnumerateReferenceSpaces
|
|
OpenXRHelper.xrEnumerateReferenceSpacesDelegate xrEnumerateReferenceSpaces;
|
|
private XrResult EnumerateReferenceSpaces(UInt32 spaceCapacityInput, out UInt32 spaceCountOutput, out XrReferenceSpaceType spaces)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
spaceCountOutput = 0;
|
|
spaces = XrReferenceSpaceType.XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT;
|
|
return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
|
|
}
|
|
|
|
return xrEnumerateReferenceSpaces(m_XrSession, spaceCapacityInput, out spaceCountOutput, out spaces);
|
|
}
|
|
|
|
/// xrCreateReferenceSpace
|
|
OpenXRHelper.xrCreateReferenceSpaceDelegate xrCreateReferenceSpace;
|
|
/// <summary>
|
|
/// Creates a reference space
|
|
/// See <see href="https://registry.khronos.org/OpenXR/specs/1.0/man/html/xrCreateReferenceSpace.html">xrCreateReferenceSpace</see>
|
|
/// </summary>
|
|
private XrResult CreateReferenceSpace(ref XrReferenceSpaceCreateInfo createInfo, out XrSpace space)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
space = 0;
|
|
return XrResult.XR_ERROR_SESSION_NOT_RUNNING;
|
|
}
|
|
|
|
return xrCreateReferenceSpace(m_XrSession, ref createInfo, out space);
|
|
}
|
|
|
|
/// xrDestroySpace
|
|
OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
|
|
private XrResult DestroySpace(XrSpace space)
|
|
{
|
|
if (space != 0)
|
|
{
|
|
return xrDestroySpace(space);
|
|
}
|
|
return XrResult.XR_ERROR_REFERENCE_SPACE_UNSUPPORTED;
|
|
}
|
|
|
|
|
|
VivePassthroughHelper.xrEnumeratePassthroughImageRatesHTCDelegate xrEnumeratePassthroughImageRatesHTC;
|
|
VivePassthroughHelper.xrGetPassthroughConfigurationHTCDelegate xrGetPassthroughConfigurationHTC;
|
|
VivePassthroughHelper.xrSetPassthroughConfigurationHTCDelegate xrSetPassthroughConfigurationHTC;
|
|
|
|
private bool GetXrFunctionDelegates(XrInstance xrInstance)
|
|
{
|
|
/// xrGetInstanceProcAddr
|
|
if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetInstanceProcAddr.");
|
|
XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
|
|
xrGetInstanceProcAddr,
|
|
typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetInstanceProcAddr");
|
|
return false;
|
|
}
|
|
|
|
IntPtr funcPtr = IntPtr.Zero;
|
|
/// xrGetSystemProperties
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetSystemProperties.");
|
|
xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetSystemProperties");
|
|
return false;
|
|
}
|
|
/// xrEnumerateReferenceSpaces
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrEnumerateReferenceSpaces", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrEnumerateReferenceSpaces.");
|
|
xrEnumerateReferenceSpaces = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrEnumerateReferenceSpacesDelegate)) as OpenXRHelper.xrEnumerateReferenceSpacesDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrEnumerateReferenceSpaces");
|
|
return false;
|
|
}
|
|
/// xrCreateReferenceSpace
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrCreateReferenceSpace", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrCreateReferenceSpace.");
|
|
xrCreateReferenceSpace = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrCreateReferenceSpaceDelegate)) as OpenXRHelper.xrCreateReferenceSpaceDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrCreateReferenceSpace");
|
|
return false;
|
|
}
|
|
/// xrDestroySpace
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrDestroySpace.");
|
|
xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrDestroySpace");
|
|
return false;
|
|
}
|
|
#if UNITY_ANDROID
|
|
/// xrEnumeratePassthroughImageRatesHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrEnumeratePassthroughImageRatesHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrEnumeratePassthroughImageRatesHTC.");
|
|
xrEnumeratePassthroughImageRatesHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(VivePassthroughHelper.xrEnumeratePassthroughImageRatesHTCDelegate)) as VivePassthroughHelper.xrEnumeratePassthroughImageRatesHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrEnumeratePassthroughImageRatesHTC");
|
|
//return false;
|
|
}
|
|
|
|
/// xrGetPassthroughConfigurationHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetPassthroughConfigurationHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetPassthroughConfigurationHTC.");
|
|
xrGetPassthroughConfigurationHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(VivePassthroughHelper.xrGetPassthroughConfigurationHTCDelegate)) as VivePassthroughHelper.xrGetPassthroughConfigurationHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetPassthroughConfigurationHTC");
|
|
//return false;
|
|
}
|
|
|
|
/// xrSetPassthroughConfigurationHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrSetPassthroughConfigurationHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrSetPassthroughConfigurationHTC.");
|
|
xrSetPassthroughConfigurationHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(VivePassthroughHelper.xrSetPassthroughConfigurationHTCDelegate)) as VivePassthroughHelper.xrSetPassthroughConfigurationHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrSetPassthroughConfigurationHTC");
|
|
//return false;
|
|
}
|
|
#endif
|
|
#if UNITY_STANDALONE
|
|
/// xrCreatePassthroughHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrCreatePassthroughHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrCreatePassthroughHTC.");
|
|
xrCreatePassthroughHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(VivePassthroughHelper.xrCreatePassthroughHTCDelegate)) as VivePassthroughHelper.xrCreatePassthroughHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrCreatePassthroughHTC");
|
|
return false;
|
|
}
|
|
/// xrCreatePassthroughHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrDestroyPassthroughHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrDestroyPassthroughHTC.");
|
|
xrDestroyPassthroughHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(VivePassthroughHelper.xrDestroyPassthroughHTCDelegate)) as VivePassthroughHelper.xrDestroyPassthroughHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrDestroyPassthroughHTC");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#if UNITY_ANDROID
|
|
if (GetFuncAddrs(xrInstance, xrGetInstanceProcAddr) == XrResult.XR_SUCCESS)
|
|
{
|
|
DEBUG("Get function pointers in native.");
|
|
}
|
|
else
|
|
{
|
|
ERROR("GetFuncAddrs");
|
|
return false;
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#if UNITY_ANDROID
|
|
#region Android Hook - Public
|
|
private const string ExtLib = "viveopenxr";
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_CreatePassthrough")]
|
|
private static extern int ViveCreatePassthrough(XrSession session, CompositionLayer.LayerType layerType, PassthroughLayerForm layerForm, uint compositionDepth = 0);
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_DestroyPassthrough")]
|
|
private static extern bool ViveDestroyPassthrough(int passthroughID);
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetAlpha")]
|
|
private static extern bool ViveSetAlpha(int passthroughID, float alpha);
|
|
/// <summary>
|
|
/// Set Passthough Alpha.
|
|
/// </summary>
|
|
public bool SetAlpha(XrPassthroughHTC passthrough, float alpha)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetAlpha: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetAlpha() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetAlpha() passthrough: ").Append(passthroughID).Append(", alpha: ").Append(alpha); DEBUG(sb);
|
|
return ViveSetAlpha(passthroughID, alpha);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetLayerType")]
|
|
private static extern bool ViveSetLayerType(int passthroughID, CompositionLayer.LayerType layerType, uint compositionDepth = 0);
|
|
/// <summary>
|
|
/// Set Passthough Layer Type.
|
|
/// </summary>
|
|
public bool SetLayerType(XrPassthroughHTC passthrough, CompositionLayer.LayerType layerType, uint compositionDepth = 0)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetLayerType: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetLayerType() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetAlpha() passthrough: ").Append(passthroughID).Append(", layerType: ").Append(layerType).Append(", compositionDepth: ").Append(compositionDepth); DEBUG(sb);
|
|
return ViveSetLayerType(passthroughID, layerType, compositionDepth);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMesh")]
|
|
private static extern bool ViveSetMesh(int passthroughID, uint vertexCount, [In, Out] XrVector3f[] vertexBuffer, uint indexCount, [In, Out] uint[] indexBuffer);
|
|
/// <summary>
|
|
/// Set Passthough Mesh.
|
|
/// </summary>
|
|
public bool SetMesh(XrPassthroughHTC passthrough, uint vertexCount, [In, Out] XrVector3f[] vertexBuffer, uint indexCount, [In, Out] uint[] indexBuffer)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMesh: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMesh() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMesh() passthrough: ").Append(passthroughID).Append(", vertexCount: ").Append(vertexCount).Append(", indexCount: ").Append(indexCount); DEBUG(sb);
|
|
return ViveSetMesh(passthroughID, vertexCount, vertexBuffer, indexCount, indexBuffer);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransform")]
|
|
private static extern bool ViveSetMeshTransform(int passthroughID, XrSpace meshSpace, XrPosef meshPose, XrVector3f meshScale);
|
|
/// <summary>
|
|
/// Set Passthough Mesh Transform.
|
|
/// </summary>
|
|
public bool SetMeshTransform(XrPassthroughHTC passthrough, XrSpace meshSpace, XrPosef meshPose, XrVector3f meshScale)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMeshTransform: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMeshTransform() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMeshTransform() passthrough: ").Append(passthroughID).Append(", meshSpace: ").Append(meshSpace); DEBUG(sb);
|
|
return ViveSetMeshTransform(passthroughID, meshSpace, meshPose, meshScale);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformSpace")]
|
|
private static extern bool ViveSetMeshTransformSpace(int passthroughID, XrSpace meshSpace);
|
|
/// <summary>
|
|
/// Set Passthough Mesh Transform Space.
|
|
/// </summary>
|
|
public bool SetMeshTransformSpace(XrPassthroughHTC passthrough, XrSpace meshSpace)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMeshTransformSpace: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMeshTransformSpace() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMeshTransformSpace() passthrough: ").Append(passthroughID).Append(", meshSpace: ").Append(meshSpace); DEBUG(sb);
|
|
return ViveSetMeshTransformSpace(passthroughID, meshSpace);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformPosition")]
|
|
private static extern bool ViveSetMeshTransformPosition(int passthroughID, XrVector3f meshPosition);
|
|
/// <summary>
|
|
/// Set Passthough Mesh Transform Position.
|
|
/// </summary>
|
|
public bool SetMeshTransformPosition(XrPassthroughHTC passthrough, XrVector3f meshPosition)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMeshTransformPosition: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMeshTransformPosition() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMeshTransformPosition() passthrough: ").Append(passthroughID); DEBUG(sb);
|
|
return ViveSetMeshTransformPosition(passthroughID, meshPosition);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformOrientation")]
|
|
private static extern bool ViveSetMeshTransformOrientation(int passthroughID, XrQuaternionf meshOrientation);
|
|
/// <summary>
|
|
/// Set Passthough Mesh Transform orientation.
|
|
/// </summary>
|
|
public bool SetMeshTransformOrientation(XrPassthroughHTC passthrough, XrQuaternionf meshOrientation)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMeshTransformOrientation: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMeshTransformOrientation() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMeshTransformOrientation() passthrough: ").Append(passthroughID); DEBUG(sb);
|
|
return ViveSetMeshTransformOrientation(passthroughID, meshOrientation);
|
|
}
|
|
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_SetMeshTransformScale")]
|
|
private static extern bool ViveSetMeshTransformScale(int passthroughID, XrVector3f meshScale);
|
|
/// <summary>
|
|
/// Set Passthough Mesh Transform scale.
|
|
/// </summary>
|
|
public bool SetMeshTransformScale(XrPassthroughHTC passthrough, XrVector3f meshScale)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("SetMeshTransformScale: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
if (passthrough == 0) { ERROR("SetMeshTransformScale() Invalid passthrough."); return false; }
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
sb.Clear().Append("SetMeshTransformScale() passthrough: ").Append(passthroughID); DEBUG(sb);
|
|
return ViveSetMeshTransformScale(passthroughID, meshScale);
|
|
}
|
|
#endregion
|
|
|
|
#region Android Hook - Private
|
|
[DllImport(ExtLib, EntryPoint = "htcpassthrough_GetFuncAddrs")]
|
|
private static extern XrResult ViveGetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr);
|
|
private XrResult GetFuncAddrs(XrInstance xrInstance, IntPtr xrGetInstanceProcAddrFuncPtr)
|
|
{
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("ViveGetFuncAddrs: " + kOpenxrExtensionStrings + " is NOT enabled.");
|
|
return XrResult.XR_ERROR_FEATURE_UNSUPPORTED;
|
|
}
|
|
|
|
return ViveGetFuncAddrs(xrInstance, xrGetInstanceProcAddrFuncPtr);
|
|
}
|
|
#endregion
|
|
#endif
|
|
|
|
private List<XrPassthroughHTC> passthroughList = new List<XrPassthroughHTC>();
|
|
public List<XrPassthroughHTC> PassthroughList {
|
|
get {
|
|
if (passthroughList == null) { passthroughList = new List<XrPassthroughHTC>(); }
|
|
return passthroughList;
|
|
}
|
|
}
|
|
|
|
#region Public API
|
|
public XrResult CreatePassthroughHTC(XrPassthroughCreateInfoHTC createInfo, out XrPassthroughHTC passthrough, CompositionLayer.LayerType layerType, uint compositionDepth, OnPassthroughSessionDestroyDelegate onDestroy)
|
|
{
|
|
passthrough = 0;
|
|
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("CreatePassthroughHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("CreatePassthroughHTC() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
sb.Clear().Append("CreatePassthroughHTC() layerType: ").Append(layerType).Append(", compositionDepth: ").Append(compositionDepth); DEBUG(sb);
|
|
|
|
XrResult result = XrResult.XR_ERROR_RUNTIME_FAILURE;
|
|
|
|
#if UNITY_STANDALONE
|
|
result = xrCreatePassthroughHTC(m_XrSession, createInfo, out passthrough);
|
|
DEBUG("CreatePassthroughHTC() xrCreatePassthroughHTC result: " + result);
|
|
if (result == XrResult.XR_SUCCESS)
|
|
{
|
|
passthroughList.Add(passthrough);
|
|
if (onDestroy != null) { OnPassthroughSessionDestroyHandlerDictionary.Add(passthrough, onDestroy); }
|
|
}
|
|
#endif
|
|
|
|
#if UNITY_ANDROID
|
|
int passthroughID = 0;
|
|
|
|
if (createInfo.form == XrPassthroughFormHTC.XR_PASSTHROUGH_FORM_PLANAR_HTC)
|
|
passthroughID = ViveCreatePassthrough(m_XrSession, layerType, PassthroughLayerForm.Planar, compositionDepth);
|
|
else // createInfo.form == XrPassthroughFormHTC.XR_PASSTHROUGH_FORM_PROJECTED_HTC
|
|
passthroughID = ViveCreatePassthrough(m_XrSession, layerType, PassthroughLayerForm.Projected, compositionDepth);
|
|
|
|
sb.Clear().Append("CreatePassthroughHTC() CreatePassthrough passthroughID: ").Append(passthroughID); DEBUG(sb);
|
|
if (passthroughID != 0)
|
|
{
|
|
passthrough = (UInt64)(passthroughID & 0x7FFFFFFF);
|
|
passthroughList.Add(passthrough);
|
|
if (onDestroy != null) { OnPassthroughSessionDestroyHandlerDictionary.Add(passthrough, onDestroy); }
|
|
result = XrResult.XR_SUCCESS;
|
|
}
|
|
#endif
|
|
return result;
|
|
}
|
|
public XrResult CreatePassthroughHTC(XrPassthroughCreateInfoHTC createInfo, out XrPassthroughHTC passthrough, CompositionLayer.LayerType layerType, OnPassthroughSessionDestroyDelegate onDestroy = null)
|
|
{
|
|
return CreatePassthroughHTC(createInfo, out passthrough, layerType, 0, onDestroy);
|
|
}
|
|
public XrResult CreatePassthroughHTC(XrPassthroughCreateInfoHTC createInfo, out XrPassthroughHTC passthrough, CompositionLayer.LayerType layerType = CompositionLayer.LayerType.Overlay)
|
|
{
|
|
return CreatePassthroughHTC(createInfo, out passthrough, layerType, 0, null);
|
|
}
|
|
|
|
public XrResult DestroyPassthroughHTC(XrPassthroughHTC passthrough)
|
|
{
|
|
if (!passthroughList.Contains(passthrough))
|
|
{
|
|
ERROR("DestroyPassthroughHTC() Invalid passthrough: " + passthrough);
|
|
return XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
}
|
|
|
|
sb.Clear().Append("DestroyPassthroughHTC() passthrough: ").Append(passthrough); DEBUG(sb);
|
|
|
|
XrResult result = XrResult.XR_ERROR_RUNTIME_FAILURE;
|
|
|
|
int passthroughID = (int)(passthrough & 0x00007FFF);
|
|
#if UNITY_STANDALONE
|
|
result = xrDestroyPassthroughHTC(passthrough);
|
|
sb.Clear().Append("DestroyPassthroughHTC() ").Append(passthrough).Append(", result: ").Append(result); DEBUG(sb);
|
|
if (result == XrResult.XR_SUCCESS)
|
|
{
|
|
passthroughList.Remove(passthrough);
|
|
if (OnPassthroughSessionDestroyHandlerDictionary.ContainsKey(passthrough))
|
|
OnPassthroughSessionDestroyHandlerDictionary.Remove(passthrough);
|
|
}
|
|
#endif
|
|
|
|
#if UNITY_ANDROID
|
|
bool ret = ViveDestroyPassthrough(passthroughID);
|
|
sb.Clear().Append("DestroyPassthroughHTC() ").Append(passthroughID).Append(", ret: ").Append(ret); DEBUG(sb);
|
|
if (ret)
|
|
{
|
|
passthroughList.Remove(passthrough);
|
|
if (OnPassthroughSessionDestroyHandlerDictionary.ContainsKey(passthrough))
|
|
OnPassthroughSessionDestroyHandlerDictionary.Remove(passthrough);
|
|
result = XrResult.XR_SUCCESS;
|
|
}
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// According to XRInputSubsystem's tracking origin mode, return the corresponding XrSpace.
|
|
/// </summary>
|
|
/// <returns><see cref="XrSpace"/> for tracking origin.</returns>
|
|
public XrSpace GetTrackingSpace()
|
|
{
|
|
XrSpace space = GetCurrentAppSpace();
|
|
sb.Clear().Append("GetTrackingSpace() ").Append(space); DEBUG(sb);
|
|
return space;
|
|
}
|
|
|
|
private List<XRInputSubsystem> inputSubsystems = new List<XRInputSubsystem>();
|
|
/// <summary>
|
|
/// Helper function to get XrSpace from space type.
|
|
/// </summary>
|
|
public XrSpace GetXrSpaceFromSpaceType(ProjectedPassthroughSpaceType spaceType)
|
|
{
|
|
XrSpace meshSpace = 0;
|
|
switch (spaceType)
|
|
{
|
|
case ProjectedPassthroughSpaceType.Headlock:
|
|
meshSpace = HeadLockSpace;
|
|
break;
|
|
case ProjectedPassthroughSpaceType.Worldlock:
|
|
default:
|
|
XRInputSubsystem subsystem = null;
|
|
SubsystemManager.GetInstances(inputSubsystems);
|
|
if (inputSubsystems.Count > 0)
|
|
{
|
|
subsystem = inputSubsystems[0];
|
|
}
|
|
|
|
if (subsystem != null)
|
|
{
|
|
TrackingOriginModeFlags trackingOriginMode = subsystem.GetTrackingOriginMode();
|
|
|
|
switch (trackingOriginMode)
|
|
{
|
|
default:
|
|
case TrackingOriginModeFlags.Floor:
|
|
meshSpace = WorldLockSpaceOriginOnFloor;
|
|
break;
|
|
case TrackingOriginModeFlags.Device:
|
|
meshSpace = WorldLockSpaceOriginOnHead;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
meshSpace = WorldLockSpaceOriginOnFloor;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return meshSpace;
|
|
}
|
|
|
|
public XrResult EnumeratePassthroughImageRatesHTC([In] UInt32 imageRateCapacityInput, ref UInt32 imageRateCountOutput,[In, Out] XrPassthroughConfigurationImageRateHTC[] imageRates)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("EnumeratePassthroughImageRatesHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
return xrEnumeratePassthroughImageRatesHTC(m_XrSession, imageRateCapacityInput, ref imageRateCountOutput, imageRates);
|
|
}
|
|
|
|
public XrResult GetPassthroughConfigurationHTC(IntPtr config)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("GetPassthroughConfigurationHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
return xrGetPassthroughConfigurationHTC(m_XrSession, config);
|
|
}
|
|
|
|
public XrResult SetPassthroughConfigurationHTC(IntPtr config)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("SetPassthroughConfigurationHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
return xrSetPassthroughConfigurationHTC(m_XrSession, config);
|
|
}
|
|
|
|
private XrBool32 m_SupportsImageRate;
|
|
private XrBool32 m_SupportsImageQuality;
|
|
XrSystemProperties systemProperties;
|
|
XrSystemPassthroughConfigurationPropertiesHTC passthroughConfigurationProperties;
|
|
private void CheckConfigurationSupport()
|
|
{
|
|
m_SupportsImageRate = false;
|
|
m_SupportsImageQuality = false;
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("CheckUserPresenceSupport() session is not created.");
|
|
return;
|
|
}
|
|
|
|
passthroughConfigurationProperties.type = XrStructureType.XR_TYPE_SYSTEM_PASSTHROUGH_CONFIGURATION_PROPERTIES_HTC;
|
|
passthroughConfigurationProperties.next = IntPtr.Zero;
|
|
systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
|
|
systemProperties.next = Marshal.AllocHGlobal(Marshal.SizeOf(passthroughConfigurationProperties));
|
|
|
|
long offset = 0;
|
|
if (IntPtr.Size == 4)
|
|
offset = systemProperties.next.ToInt32();
|
|
else
|
|
offset = systemProperties.next.ToInt64();
|
|
|
|
IntPtr passthroughConfigurationPtr = new IntPtr(offset);
|
|
Marshal.StructureToPtr(passthroughConfigurationProperties, passthroughConfigurationPtr, false);
|
|
|
|
if (GetSystemProperties(ref systemProperties) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (IntPtr.Size == 4)
|
|
offset = systemProperties.next.ToInt32();
|
|
else
|
|
offset = systemProperties.next.ToInt64();
|
|
|
|
passthroughConfigurationPtr = new IntPtr(offset);
|
|
passthroughConfigurationProperties = (XrSystemPassthroughConfigurationPropertiesHTC)Marshal.PtrToStructure(passthroughConfigurationPtr, typeof(XrSystemPassthroughConfigurationPropertiesHTC));
|
|
|
|
sb.Clear().Append("CheckConfigurationSupport() supportsImageQuality: ").Append((UInt32)passthroughConfigurationProperties.supportsImageQuality); DEBUG(sb);
|
|
sb.Clear().Append("CheckConfigurationSupport() supportsImageRate: ").Append((UInt32)passthroughConfigurationProperties.supportsImageRate); DEBUG(sb);
|
|
m_SupportsImageQuality = passthroughConfigurationProperties.supportsImageQuality;
|
|
m_SupportsImageRate = passthroughConfigurationProperties.supportsImageRate;
|
|
}
|
|
else
|
|
{
|
|
ERROR("CheckSupport() GetSystemProperties failed.");
|
|
}
|
|
|
|
Marshal.FreeHGlobal(systemProperties.next);
|
|
}
|
|
public bool SupportsImageRate() { return m_SupportsImageRate; }
|
|
public bool SupportsImageQuality() { return m_SupportsImageQuality; }
|
|
|
|
#endregion
|
|
}
|
|
}
|