535 lines
23 KiB
C#
535 lines
23 KiB
C#
// Copyright HTC Corporation All Rights Reserved.
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Runtime.InteropServices;
|
||
using UnityEngine;
|
||
|
||
namespace VIVE.OpenXR.Passthrough
|
||
{
|
||
/// <summary>
|
||
/// The forms of passthrough layer.
|
||
/// </summary>
|
||
public enum PassthroughLayerForm
|
||
{
|
||
///<summary> Fullscreen Passthrough Form</summary>
|
||
Planar = 0,
|
||
///<summary> Projected Passthrough Form</summary>
|
||
Projected = 1
|
||
}
|
||
|
||
/// <summary>
|
||
/// The types of passthrough space.
|
||
/// </summary>
|
||
public enum ProjectedPassthroughSpaceType
|
||
{
|
||
///<summary>
|
||
/// XR_REFERENCE_SPACE_TYPE_VIEW at (0,0,0) with orientation (0,0,0,1)
|
||
///</summary>
|
||
Headlock = 0,
|
||
///<summary>
|
||
/// When TrackingOriginMode is TrackingOriginModeFlags.Floor:
|
||
/// XR_REFERENCE_SPACE_TYPE_STAGE at (0,0,0) with orientation (0,0,0,1)
|
||
///
|
||
/// When TrackingOriginMode is TrackingOriginModeFlags.Device:
|
||
/// XR_REFERENCE_SPACE_TYPE_LOCAL at (0,0,0) with orientation (0,0,0,1)
|
||
///
|
||
///</summary>
|
||
Worldlock = 1
|
||
}
|
||
|
||
// -------------------- 12.88. XR_HTC_passthrough --------------------
|
||
|
||
#region New Object Types
|
||
/// <summary>
|
||
/// An application can create an <see href="https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XrPassthroughHTC">XrPassthroughHTC</see> handle by calling <see href="https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#xrCreatePassthroughHTC">xrCreatePassthroughHTC</see>. The returned passthrough handle can be subsequently used in API calls.
|
||
/// </summary>
|
||
public struct XrPassthroughHTC : IEquatable<UInt64>
|
||
{
|
||
private readonly UInt64 value;
|
||
|
||
public XrPassthroughHTC(UInt64 u)
|
||
{
|
||
value = u;
|
||
}
|
||
|
||
public static implicit operator UInt64(XrPassthroughHTC equatable)
|
||
{
|
||
return equatable.value;
|
||
}
|
||
public static implicit operator XrPassthroughHTC(UInt64 u)
|
||
{
|
||
return new XrPassthroughHTC(u);
|
||
}
|
||
|
||
public bool Equals(XrPassthroughHTC other)
|
||
{
|
||
return value == other.value;
|
||
}
|
||
public bool Equals(UInt64 other)
|
||
{
|
||
return value == other;
|
||
}
|
||
public override bool Equals(object obj)
|
||
{
|
||
return obj is XrPassthroughHTC && Equals((XrPassthroughHTC)obj);
|
||
}
|
||
|
||
public override int GetHashCode()
|
||
{
|
||
return value.GetHashCode();
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return value.ToString();
|
||
}
|
||
|
||
public static bool operator ==(XrPassthroughHTC a, XrPassthroughHTC b) { return a.Equals(b); }
|
||
public static bool operator !=(XrPassthroughHTC a, XrPassthroughHTC b) { return !a.Equals(b); }
|
||
public static bool operator >=(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value >= b.value; }
|
||
public static bool operator <=(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value <= b.value; }
|
||
public static bool operator >(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value > b.value; }
|
||
public static bool operator <(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value < b.value; }
|
||
public static XrPassthroughHTC operator +(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value + b.value; }
|
||
public static XrPassthroughHTC operator -(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value - b.value; }
|
||
public static XrPassthroughHTC operator *(XrPassthroughHTC a, XrPassthroughHTC b) { return a.value * b.value; }
|
||
public static XrPassthroughHTC operator /(XrPassthroughHTC a, XrPassthroughHTC b)
|
||
{
|
||
if (b.value == 0)
|
||
{
|
||
throw new DivideByZeroException();
|
||
}
|
||
return a.value / b.value;
|
||
}
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region New Enums
|
||
/// <summary>
|
||
/// The XrPassthroughFormHTC enumeration identifies the form of the passthrough, presenting the passthrough fill the full screen or project onto a specified mesh.
|
||
/// </summary>
|
||
public enum XrPassthroughFormHTC
|
||
{
|
||
/// <summary>
|
||
/// Presents the passthrough with full of the entire screen..
|
||
/// </summary>
|
||
XR_PASSTHROUGH_FORM_PLANAR_HTC = 0,
|
||
/// <summary>
|
||
/// Presents the passthrough projecting onto a custom mesh.
|
||
/// </summary>
|
||
XR_PASSTHROUGH_FORM_PROJECTED_HTC = 1,
|
||
};
|
||
#endregion
|
||
|
||
#region New Structures
|
||
/// <summary>
|
||
/// The XrPassthroughCreateInfoHTC structure describes the information to create an <see cref="XrPassthroughCreateInfoHTC">XrPassthroughCreateInfoHTC</see> handle.
|
||
/// </summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrPassthroughCreateInfoHTC
|
||
{
|
||
/// <summary>
|
||
/// The <see cref="XrStructureType">XrStructureType</see> of this structure.
|
||
/// </summary>
|
||
public XrStructureType type;
|
||
/// <summary>
|
||
/// NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.
|
||
/// </summary>
|
||
public IntPtr next;
|
||
/// <summary>
|
||
/// The form specifies the form of passthrough.
|
||
/// </summary>
|
||
public XrPassthroughFormHTC form;
|
||
|
||
/// <param name="in_type">The <see cref="XrStructureType">XrStructureType</see> of this structure.</param>
|
||
/// <param name="in_next">NULL or a pointer to the next structure in a structure chain. No such structures are defined in core OpenXR or this extension.</param>
|
||
/// <param name="in_facialTrackingType">An XrFacialTrackingTypeHTC which describes which type of facial tracking should be used for this handle.</param>
|
||
public XrPassthroughCreateInfoHTC(XrStructureType in_type, IntPtr in_next, XrPassthroughFormHTC in_form)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
form = in_form;
|
||
}
|
||
};
|
||
|
||
/// <summary>
|
||
/// The application can specify the XrPassthroughColorHTC to adjust the alpha value of the passthrough. The range is between 0.0f and 1.0f, 1.0f means opaque.
|
||
/// </summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrPassthroughColorHTC
|
||
{
|
||
/// <summary>
|
||
/// The XrStructureType of this structure.
|
||
/// </summary>
|
||
public XrStructureType type;
|
||
/// <summary>
|
||
/// Next is NULL or a pointer to the next structure in a structure chain, such as XrPassthroughMeshTransformInfoHTC.
|
||
/// </summary>
|
||
public IntPtr next;
|
||
/// <summary>
|
||
/// The alpha value of the passthrough in the range [0, 1].
|
||
/// </summary>
|
||
public float alpha;
|
||
public XrPassthroughColorHTC(XrStructureType in_type, IntPtr in_next, float in_alpha)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
alpha = in_alpha;
|
||
}
|
||
};
|
||
|
||
/// <summary>
|
||
/// The XrPassthroughMeshTransformInfoHTC structure describes the mesh and transformation.
|
||
/// </summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrPassthroughMeshTransformInfoHTC
|
||
{
|
||
/// <summary>
|
||
/// The XrStructureType of this structure.
|
||
/// </summary>
|
||
public XrStructureType type;
|
||
/// <summary>
|
||
/// Next is NULL or a pointer to the next structure in a structure chain.
|
||
/// </summary>
|
||
public IntPtr next;
|
||
/// <summary>
|
||
/// The count of vertices array in the mesh.
|
||
/// </summary>
|
||
public UInt32 vertexCount;
|
||
/// <summary>
|
||
/// An array of XrVector3f. The size of the array must be equal to vertexCount.
|
||
/// </summary>
|
||
public XrVector3f[] vertices;
|
||
/// <summary>
|
||
/// The count of indices array in the mesh.
|
||
/// </summary>
|
||
public UInt32 indexCount;
|
||
/// <summary>
|
||
/// An array of triangle indices. The size of the array must be equal to indexCount.
|
||
/// </summary>
|
||
public UInt32[] indices;
|
||
/// <summary>
|
||
/// The XrSpace that defines the projected passthrough's base space for transformations.
|
||
/// </summary>
|
||
public XrSpace baseSpace;
|
||
/// <summary>
|
||
/// The XrTime that defines the time at which the transform is applied.
|
||
/// </summary>
|
||
public XrTime time;
|
||
/// <summary>
|
||
/// The XrPosef that defines the pose of the mesh
|
||
/// </summary>
|
||
public XrPosef pose;
|
||
/// <summary>
|
||
/// The XrVector3f that defines the scale of the mesh
|
||
/// </summary>
|
||
public XrVector3f scale;
|
||
public XrPassthroughMeshTransformInfoHTC(XrStructureType in_type, IntPtr in_next, UInt32 in_vertexCount,
|
||
XrVector3f[] in_vertices, UInt32 in_indexCount, UInt32[] in_indices, XrSpace in_baseSpace, XrTime in_time,
|
||
XrPosef in_pose, XrVector3f in_scale)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
vertexCount = in_vertexCount;
|
||
vertices = in_vertices;
|
||
indexCount = in_indexCount;
|
||
indices = in_indices;
|
||
baseSpace = in_baseSpace;
|
||
time = in_time;
|
||
pose = in_pose;
|
||
scale = in_scale;
|
||
}
|
||
};
|
||
|
||
/// <summary>
|
||
/// A pointer to XrCompositionLayerPassthroughHTC may be submitted in xrEndFrame as a pointer to the base structure XrCompositionLayerBaseHeader, in the desired layer order, to request the runtime to composite a passthrough layer into the final frame output.
|
||
/// </summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrCompositionLayerPassthroughHTC
|
||
{
|
||
/// <summary>
|
||
/// The XrStructureType of this structure.
|
||
/// </summary>
|
||
public XrStructureType type;
|
||
/// <summary>
|
||
/// Next is NULL or a pointer to the next structure in a structure chain, such as XrPassthroughMeshTransformInfoHTC.
|
||
/// </summary>
|
||
public IntPtr next;
|
||
/// <summary>
|
||
/// A bitmask of XrCompositionLayerFlagBits describing flags to apply to the layer.
|
||
/// </summary>
|
||
public XrCompositionLayerFlags layerFlags;
|
||
/// <summary>
|
||
/// The XrSpace that specifies the layer<65><72>s space - must be XR_NULL_HANDLE.
|
||
/// </summary>
|
||
public XrSpace space;
|
||
/// <summary>
|
||
/// The XrPassthroughHTC previously created by xrCreatePassthroughHTC.
|
||
/// </summary>
|
||
public XrPassthroughHTC passthrough;
|
||
/// <summary>
|
||
/// The XrPassthroughColorHTC describing the color information with the alpha value of the passthrough layer.
|
||
/// </summary>
|
||
public XrPassthroughColorHTC color;
|
||
public XrCompositionLayerPassthroughHTC(XrStructureType in_type, IntPtr in_next, XrCompositionLayerFlags in_layerFlags,
|
||
XrSpace in_space, XrPassthroughHTC in_passthrough, XrPassthroughColorHTC in_color)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
layerFlags = in_layerFlags;
|
||
space = in_space;
|
||
passthrough = in_passthrough;
|
||
color = in_color;
|
||
}
|
||
};
|
||
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrPassthroughConfigurationBaseHeaderHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
};
|
||
|
||
[StructLayout(LayoutKind.Sequential, Pack = 8)]
|
||
public struct XrPassthroughConfigurationImageRateHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
public float srcImageRate;
|
||
public float dstImageRate;
|
||
};
|
||
|
||
|
||
[StructLayout(LayoutKind.Sequential, Pack = 8)]
|
||
public struct XrPassthroughConfigurationImageQualityHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
public float scale;
|
||
};
|
||
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrEventDataPassthroughConfigurationImageRateChangedHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
public XrPassthroughConfigurationImageRateHTC fromImageRate;
|
||
public XrPassthroughConfigurationImageRateHTC toImageRate;
|
||
|
||
public XrEventDataPassthroughConfigurationImageRateChangedHTC(XrStructureType in_type, IntPtr in_next, XrPassthroughConfigurationImageRateHTC in_fromImageRate, XrPassthroughConfigurationImageRateHTC in_toImageRate)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
fromImageRate = in_fromImageRate;
|
||
toImageRate = in_toImageRate;
|
||
}
|
||
public static XrEventDataPassthroughConfigurationImageRateChangedHTC identity
|
||
{
|
||
get
|
||
{
|
||
return new XrEventDataPassthroughConfigurationImageRateChangedHTC(
|
||
XrStructureType.XR_TYPE_EVENT_DATA_PASSTHROUGH_CONFIGURATION_IMAGE_RATE_CHANGED_HTC,
|
||
IntPtr.Zero,
|
||
new XrPassthroughConfigurationImageRateHTC { type = XrStructureType.XR_TYPE_PASSTHROUGH_CONFIGURATION_IMAGE_RATE_HTC, next = IntPtr.Zero },
|
||
new XrPassthroughConfigurationImageRateHTC { type = XrStructureType.XR_TYPE_PASSTHROUGH_CONFIGURATION_IMAGE_RATE_HTC, next = IntPtr.Zero }); // user is default present
|
||
}
|
||
}
|
||
public static bool Get(XrEventDataBuffer eventDataBuffer, out XrEventDataPassthroughConfigurationImageRateChangedHTC eventDataPassthroughConfigurationImageRate)
|
||
{
|
||
eventDataPassthroughConfigurationImageRate = identity;
|
||
if (eventDataBuffer.type == XrStructureType.XR_TYPE_EVENT_DATA_PASSTHROUGH_CONFIGURATION_IMAGE_RATE_CHANGED_HTC)
|
||
{
|
||
eventDataPassthroughConfigurationImageRate.next = eventDataBuffer.next;
|
||
eventDataPassthroughConfigurationImageRate.fromImageRate.type = (XrStructureType)BitConverter.ToUInt32(eventDataBuffer.varying, 0);
|
||
eventDataPassthroughConfigurationImageRate.fromImageRate.next = (IntPtr)BitConverter.ToInt64(eventDataBuffer.varying, 8);
|
||
eventDataPassthroughConfigurationImageRate.fromImageRate.srcImageRate = BitConverter.ToSingle(eventDataBuffer.varying, 16);
|
||
eventDataPassthroughConfigurationImageRate.fromImageRate.dstImageRate = BitConverter.ToSingle(eventDataBuffer.varying, 20);
|
||
eventDataPassthroughConfigurationImageRate.toImageRate.type = (XrStructureType)BitConverter.ToUInt32(eventDataBuffer.varying, 24);
|
||
eventDataPassthroughConfigurationImageRate.toImageRate.next = (IntPtr)BitConverter.ToInt64(eventDataBuffer.varying, 32);
|
||
eventDataPassthroughConfigurationImageRate.toImageRate.srcImageRate = BitConverter.ToSingle(eventDataBuffer.varying, 40);
|
||
eventDataPassthroughConfigurationImageRate.toImageRate.dstImageRate = BitConverter.ToSingle(eventDataBuffer.varying, 44);
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
};
|
||
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrEventDataPassthroughConfigurationImageQualityChangedHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
public XrPassthroughConfigurationImageQualityHTC fromImageQuality;
|
||
public XrPassthroughConfigurationImageQualityHTC toImageQuality;
|
||
|
||
public XrEventDataPassthroughConfigurationImageQualityChangedHTC(XrStructureType in_type, IntPtr in_next, XrPassthroughConfigurationImageQualityHTC in_fromImageQuality, XrPassthroughConfigurationImageQualityHTC in_toImageQuality)
|
||
{
|
||
type = in_type;
|
||
next = in_next;
|
||
fromImageQuality = in_fromImageQuality;
|
||
toImageQuality = in_toImageQuality;
|
||
}
|
||
public static XrEventDataPassthroughConfigurationImageQualityChangedHTC identity
|
||
{
|
||
get
|
||
{
|
||
return new XrEventDataPassthroughConfigurationImageQualityChangedHTC(
|
||
XrStructureType.XR_TYPE_EVENT_DATA_PASSTHROUGH_CONFIGURATION_IMAGE_QUALITY_CHANGED_HTC,
|
||
IntPtr.Zero,
|
||
new XrPassthroughConfigurationImageQualityHTC { type = XrStructureType.XR_TYPE_PASSTHROUGH_CONFIGURATION_IMAGE_QUALITY_HTC, next = IntPtr.Zero },
|
||
new XrPassthroughConfigurationImageQualityHTC { type = XrStructureType.XR_TYPE_PASSTHROUGH_CONFIGURATION_IMAGE_QUALITY_HTC, next = IntPtr.Zero }); // user is default present
|
||
}
|
||
}
|
||
public static bool Get(XrEventDataBuffer eventDataBuffer, out XrEventDataPassthroughConfigurationImageQualityChangedHTC ventDataPassthroughConfigurationImageQuality)
|
||
{
|
||
ventDataPassthroughConfigurationImageQuality = identity;
|
||
if (eventDataBuffer.type == XrStructureType.XR_TYPE_EVENT_DATA_PASSTHROUGH_CONFIGURATION_IMAGE_QUALITY_CHANGED_HTC)
|
||
{
|
||
ventDataPassthroughConfigurationImageQuality.next = eventDataBuffer.next;
|
||
ventDataPassthroughConfigurationImageQuality.fromImageQuality.type = (XrStructureType)BitConverter.ToUInt32(eventDataBuffer.varying, 0);
|
||
ventDataPassthroughConfigurationImageQuality.fromImageQuality.next = (IntPtr)BitConverter.ToInt64(eventDataBuffer.varying, 8);
|
||
ventDataPassthroughConfigurationImageQuality.fromImageQuality.scale = BitConverter.ToSingle(eventDataBuffer.varying, 16);
|
||
ventDataPassthroughConfigurationImageQuality.toImageQuality.type = (XrStructureType)BitConverter.ToUInt32(eventDataBuffer.varying, 24);
|
||
ventDataPassthroughConfigurationImageQuality.toImageQuality.next = (IntPtr)BitConverter.ToInt64(eventDataBuffer.varying, 32);
|
||
ventDataPassthroughConfigurationImageQuality.toImageQuality.scale = BitConverter.ToSingle(eventDataBuffer.varying, 40);
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
};
|
||
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct XrSystemPassthroughConfigurationPropertiesHTC
|
||
{
|
||
public XrStructureType type;
|
||
public IntPtr next;
|
||
public XrBool32 supportsImageRate;
|
||
public XrBool32 supportsImageQuality;
|
||
};
|
||
|
||
#endregion
|
||
|
||
#region New Functions
|
||
public static class VivePassthroughHelper
|
||
{
|
||
/// <summary>
|
||
/// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreatePassthroughHTC">xrCreatePassthroughHTC</see>.
|
||
/// </summary>
|
||
/// <param name="session">An <see cref="XrSession">XrSession</see> in which the passthrough will be active.</param>
|
||
/// <param name="createInfo">createInfo is a pointer to an <see cref="XrPassthroughCreateInfoHTC">XrPassthroughCreateInfoHTC</see> structure containing information about how to create the passthrough.</param>
|
||
/// <param name="passthrough">passthrough is a pointer to a handle in which the created <see cref="XrPassthroughHTC">XrPassthroughHTC</see> is returned.</param>
|
||
/// <returns>XR_SUCCESS for success.</returns>
|
||
public delegate XrResult xrCreatePassthroughHTCDelegate(
|
||
XrSession session,
|
||
XrPassthroughCreateInfoHTC createInfo,
|
||
out XrPassthroughHTC passthrough);
|
||
|
||
/// <summary>
|
||
/// The delegate function of <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyPassthroughHTC">xrDestroyFacialTrackerHTC</see>.
|
||
/// </summary>
|
||
/// <param name="passthrough">passthrough is the <see cref="XrPassthroughHTC">XrPassthroughHTC</see> to be destroyed..</param>
|
||
/// <returns>XR_SUCCESS for success.</returns>
|
||
public delegate XrResult xrDestroyPassthroughHTCDelegate(
|
||
XrPassthroughHTC passthrough);
|
||
|
||
public delegate XrResult xrEnumeratePassthroughImageRatesHTCDelegate(
|
||
XrSession session,
|
||
[In] UInt32 imageRateCapacityInput,
|
||
ref UInt32 imageRateCountOutput,
|
||
[In, Out] XrPassthroughConfigurationImageRateHTC[] imageRates);
|
||
|
||
public delegate XrResult xrGetPassthroughConfigurationHTCDelegate(
|
||
XrSession session,
|
||
IntPtr/*ref XrPassthroughConfigurationBaseHeaderHTC*/ config);
|
||
|
||
public delegate XrResult xrSetPassthroughConfigurationHTCDelegate(
|
||
XrSession session,
|
||
IntPtr/*ref XrPassthroughConfigurationBaseHeaderHTC*/ config);
|
||
}
|
||
|
||
public static class VivePassthroughImageQualityChanged
|
||
{
|
||
public delegate void OnImageQualityChanged(float fromQuality, float toQuality);
|
||
|
||
public static void Listen(OnImageQualityChanged callback)
|
||
{
|
||
if (!allEventListeners.Contains(callback))
|
||
allEventListeners.Add(callback);
|
||
}
|
||
public static void Remove(OnImageQualityChanged callback)
|
||
{
|
||
if (allEventListeners.Contains(callback))
|
||
allEventListeners.Remove(callback);
|
||
}
|
||
public static void Send(float fromQuality, float toQuality)
|
||
{
|
||
int N = 0;
|
||
if (allEventListeners != null)
|
||
{
|
||
N = allEventListeners.Count;
|
||
for (int i = N - 1; i >= 0; i--)
|
||
{
|
||
OnImageQualityChanged single = allEventListeners[i];
|
||
try
|
||
{
|
||
single(fromQuality, toQuality);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Debug.Log("Event : " + e.ToString());
|
||
allEventListeners.Remove(single);
|
||
Debug.Log("Event : A listener is removed due to exception.");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private static List<OnImageQualityChanged> allEventListeners = new List<OnImageQualityChanged>();
|
||
}
|
||
|
||
public static class VivePassthroughImageRateChanged
|
||
{
|
||
public delegate void OnImageRateChanged(float fromSrcImageRate, float fromDestImageRate, float toSrcImageRate, float toDestImageRate);
|
||
|
||
public static void Listen(OnImageRateChanged callback)
|
||
{
|
||
if (!allEventListeners.Contains(callback))
|
||
allEventListeners.Add(callback);
|
||
}
|
||
public static void Remove(OnImageRateChanged callback)
|
||
{
|
||
if (allEventListeners.Contains(callback))
|
||
allEventListeners.Remove(callback);
|
||
}
|
||
public static void Send(float fromSrcImageRate, float fromDestImageRate, float toSrcImageRate, float toDestImageRate)
|
||
{
|
||
int N = 0;
|
||
if (allEventListeners != null)
|
||
{
|
||
N = allEventListeners.Count;
|
||
for (int i = N - 1; i >= 0; i--)
|
||
{
|
||
OnImageRateChanged single = allEventListeners[i];
|
||
try
|
||
{
|
||
single(fromSrcImageRate, fromDestImageRate, toSrcImageRate, toDestImageRate);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Debug.Log("Event : " + e.ToString());
|
||
allEventListeners.Remove(single);
|
||
Debug.Log("Event : A listener is removed due to exception.");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private static List<OnImageRateChanged> allEventListeners = new List<OnImageRateChanged>();
|
||
}
|
||
#endregion
|
||
}
|