interoperabilità nativa Realtà mista in Unity

Articolo
07/04/2024

Ogni app Realtà mista ottiene un HolographicSpace prima di iniziare a ricevere i dati della fotocamera e i fotogrammi di rendering. In Unity il motore si occupa di questi passaggi, gestendo gli oggetti Holographic e aggiornando internamente come parte del ciclo di rendering.

Tuttavia, negli scenari avanzati potrebbe essere necessario ottenere l'accesso agli oggetti nativi sottostanti, ad esempio HolographicCamera e HolographicFrame corrente.

WindowsMixedRealityUtilities

Spazio dei nomi: Microsoft.MixedReality.Toolkit.WindowsMixedReality
Tipo: WindowsMixedRealityUtilities

MRTK fornisce tipi già sottoposti a marshalling in WSA legacy e XR SDK tramite la classe WindowsMixedRealityUtilities .

public static HolographicFrame CurrentHolographicFrame { get; }
public static SpatialCoordinateSystem SpatialCoordinateSystem { get; }
public static SpatialInteractionManager SpatialInteractionManager { get; }

WindowsMREnvironment

Spazio dei nomi: UnityEngine.XR.WindowsMR
Tipo: WindowsMREnvironment

La classe statica WindowsMREnvironment fornisce l'accesso a diversi puntatori nativi.

public static IntPtr CurrentHolographicRenderFrame { get; } // Windows::Graphics::Holographic::IHolographicFrame
public static IntPtr HolographicSpace { get; } // Windows::Graphics::Holographic::IHolographicSpace
public static IntPtr OriginSpatialCoordinateSystem { get; } // Windows::Perception::Spatial::ISpatialCoordinateSystem

XRDevice

Spazio dei nomi: UnityEngine.XR
Tipo: XRDevice

Il tipo XRDevice consente di ottenere l'accesso agli oggetti nativi sottostanti usando il metodo GetNativePtr . I risultati restituiti da GetNativePtr variano tra piattaforme diverse. Nel piattaforma UWP (Universal Windows Platform) quando la destinazione è Windows Realtà mista, XRDevice.GetNativePtr restituisce un puntatore (IntPtr) alla struttura seguente:

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
struct HolographicFrameNativeData
{
    public uint VersionNumber;
    public uint MaxNumberOfCameras;
    public IntPtr ISpatialCoordinateSystemPtr; // Windows::Perception::Spatial::ISpatialCoordinateSystem
    public IntPtr IHolographicFramePtr; // Windows::Graphics::Holographic::IHolographicFrame
    public IntPtr IHolographicCameraPtr; // Windows::Graphics::Holographic::IHolographicCamera
}

È possibile convertirlo in HolographicFrameNativeData usando il metodo Marshal.PtrToStructure:

IntPtr nativePtr = UnityEngine.XR.XRDevice.GetNativePtr();
HolographicFrameNativeData hfd = Marshal.PtrToStructure<HolographicFrameNativeData>(nativePtr);

IHolographicCameraPtr è una matrice di IntPtr sottoposto a marshalling come UnmanagedType.ByValArray con una lunghezza uguale a MaxNumberOfCameras

Annullare ilmarshaling dei puntatori nativi

Dopo aver IntPtr ottenuto da uno dei metodi precedenti (non necessari per MRTK), usare i frammenti di codice seguenti per effettuare il marshalling degli oggetti gestiti.

Se si usa Microsoft.Windows.MixedReality.DotNetWinRT, è possibile costruire un oggetto gestito da un puntatore nativo usando il FromNativePtr() metodo :

var worldOrigin = Microsoft.Windows.Perception.Spatial.SpatialCoordinateSystem.FromNativePtr(spatialCoordinateSystemPtr);

In caso contrario, usare ed eseguire Marshal.GetObjectForIUnknown() il cast al tipo desiderato:

#if ENABLE_WINMD_SUPPORT
var worldOrigin = Marshal.GetObjectForIUnknown(spatialCoordinateSystemPtr) as Windows.Perception.Spatial.SpatialCoordinateSystem;
#endif

Conversione tra sistemi di coordinate

Unity usa un sistema di coordinate sinistrorso, mentre le API Di percezione di Windows usano sistemi di coordinate destrorse. Per eseguire la conversione tra queste due convenzioni, è possibile usare gli helper seguenti:

namespace NumericsConversion
{
    public static class NumericsConversionExtensions
    {
        public static UnityEngine.Vector3 ToUnity(this System.Numerics.Vector3 v) => new UnityEngine.Vector3(v.X, v.Y, -v.Z);
        public static UnityEngine.Quaternion ToUnity(this System.Numerics.Quaternion q) => new UnityEngine.Quaternion(q.X, q.Y, -q.Z, -q.W);
        public static UnityEngine.Matrix4x4 ToUnity(this System.Numerics.Matrix4x4 m) => new UnityEngine.Matrix4x4(
            new Vector4( m.M11,  m.M12, -m.M13,  m.M14),
            new Vector4( m.M21,  m.M22, -m.M23,  m.M24),
            new Vector4(-m.M31, -m.M32,  m.M33, -m.M34),
            new Vector4( m.M41,  m.M42, -m.M43,  m.M44));

        public static System.Numerics.Vector3 ToSystem(this UnityEngine.Vector3 v) => new System.Numerics.Vector3(v.x, v.y, -v.z);
        public static System.Numerics.Quaternion ToSystem(this UnityEngine.Quaternion q) => new System.Numerics.Quaternion(q.x, q.y, -q.z, -q.w);
        public static System.Numerics.Matrix4x4 ToSystem(this UnityEngine.Matrix4x4 m) => new System.Numerics.Matrix4x4(
            m.m00,  m.m10, -m.m20,  m.m30,
            m.m01,  m.m11, -m.m21,  m.m31,
           -m.m02, -m.m12,  m.m22, -m.m32,
            m.m03,  m.m13, -m.m23,  m.m33);
    }
}

Uso di dati nativi holographicFrame

Nota

La modifica dello stato degli oggetti nativi ricevuti tramite HolographicFrameNativeData può causare comportamenti imprevedibili e artefatti di rendering, soprattutto se Unity causa anche lo stesso stato. Ad esempio, non è consigliabile chiamare HolographicFrame.UpdateCurrentPrediction oppure la stima della posizione di cui Unity esegue il rendering con tale fotogramma non sarà sincronizzata con la posizione prevista da Windows, riducendo così la stabilità dell'ologramma.

Se è necessario accedere alle interfacce native per scopi di rendering o debug, usare i dati di HolographicFrameNativeData nei plug-in nativi o nel codice C#.

Ecco un esempio di come usare HolographicFrameNativeData per ottenere la stima del fotogramma corrente per il tempo di foton usando le estensioni XR SDK.

using System;
using System.Runtime.InteropServices;

public static bool GetCurrentFrameDateTime(out DateTime frameDateTime)
{
#if ENABLE_WINMD_SUPPORT
    IntPtr holographicFramePtr = UnityEngine.XR.WindowsMR.WindowsMREnvironment.CurrentHolographicRenderFrame;

    if (holographicFramePtr != IntPtr.Zero)
    {
        var holographicFrame = Marshal.GetObjectForIUnknown(holographicFramePtr) as Windows.Graphics.Holographic.HolographicFrame;
        frameDateTime = holographicFrame.CurrentPrediction.Timestamp.TargetTime.DateTime;
        return true;
    }
#endif

    frameDateTime = DateTime.MinValue;
    return false;
}

Condividi tramite