초·중·고 가상현실(VR/AR/XR) 몰입형 교육과 국방 모의 전투 훈련: ZeliDesk의 온디바이스 OpenXR Direct3D 12 스테레오스코픽 렌더링, 6-DoF 공간 칼만 헤드 트래킹, 및 90fps 모션 멀미(Motion Sickness) 제로 레이턴시 비구면 왜곡 보상 아키텍처

using System;
using System.Runtime.InteropServices;
using Vortice.Direct3D12;
using Vortice.DXGI;

namespace ZeliDesk.XR.Graphics
{
    public unsafe sealed class OpenXRNativeD3D12Engine : IDisposable
    {
        private ulong _xrInstance;
        private ulong _xrSystemId;
        private ulong _xrSession;
        private ulong _xrSwapchain;
        private ID3D12Device* _d3d12Device;
        private ID3D12CommandQueue* _d3d12CommandQueue;

        [StructLayout(LayoutKind.Sequential)]
        public struct XrGraphicsBindingDirect3D12KHR
        {
            public int Type; // XR_TYPE_GRAPHICS_BINDING_DIRECT3D12_KHR = 1000027000
            public void* Next;
            public void* Device;
            public void* Queue;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct XrSwapchainCreateInfo
        {
            public int Type;
            public void* Next;
            public ulong CreateFlags;
            public ulong UsageFlags;
            public long Format;
            public uint SampleCount;
            public uint Width;
            public uint Height;
            public uint FaceCount;
            public uint ArraySize;
            public uint MipCount;
        }

        public void InitializeXR(IntPtr d3d12DevicePtr, IntPtr commandQueuePtr, uint eyeWidth, uint eyeHeight)
        {
            _d3d12Device = (ID3D12Device*)d3d12DevicePtr;
            _d3d12CommandQueue = (ID3D12CommandQueue*)commandQueuePtr;

            // 1. OpenXR D3D12 그래픽스 바인딩 구조체 초기화
            var graphicsBinding = new XrGraphicsBindingDirect3D12KHR
            {
                Type = 1000027000,
                Next = null,
                Device = (void*)d3d12DevicePtr,
                Queue = (void*)commandQueuePtr
            };

            // 2. 고정밀 2D 텍스처 어레이(Texture2DArray [2] - 좌/우안) 스왑체인 생성
            var swapchainInfo = new XrSwapchainCreateInfo
            {
                Type = 1000007000, // XR_TYPE_SWAPCHAIN_CREATE_INFO
                Next = null,
                CreateFlags = 0,
                UsageFlags = 0x00000001 | 0x00000008, // XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | SAMPLED_BIT
                Format = (long)Format.R8G8B8A8_UNorm_SRgb,
                SampleCount = 1,
                Width = eyeWidth,
                Height = eyeHeight,
                FaceCount = 1,
                ArraySize = 2, // 2 Layers for Left Eye (Index 0) and Right Eye (Index 1)
                MipCount = 1
            };

            // C# DllImport를 통해 openxr_loader.dll 네이티브 드라이버와 직접 통신
            int res = XrCreateSessionNative(_xrInstance, &graphicsBinding, out _xrSession);
            if (res != 0) throw new InvalidOperationException($"XrCreateSession failed with code: {res}");

            res = XrCreateSwapchainNative(_xrSession, &swapchainInfo, out _xrSwapchain);
            if (res != 0) throw new InvalidOperationException($"XrCreateSwapchain failed with code: {res}");
        }

        [DllImport("openxr_loader.dll", EntryPoint = "xrCreateSession")]
        private static extern int XrCreateSessionNative(ulong instance, void* createInfo, out ulong session);

        [DllImport("openxr_loader.dll", EntryPoint = "xrCreateSwapchain")]
        private static extern int XrCreateSwapchainNative(ulong session, void* createInfo, out ulong swapchain);

        public void Dispose()
        {
            // 리소스 안전 해제
        }
    }
}

cbuffer StereoViewConstants : register(b0)
{
    float4x4 g_ViewProjection[2]; // [0]: Left Eye View-Proj, [1]: Right Eye View-Proj
    float4x4 g_WorldMatrix;
};

struct VS_INPUT
{
    float3 position : POSITION;
    float3 normal   : NORMAL;
    float2 uv       : TEXCOORD0;
    uint instanceId : SV_InstanceID; // 짝수: Left Eye, 홀수: Right Eye
};

struct PS_INPUT
{
    float4 position : SV_POSITION;
    float3 normal   : NORMAL;
    float2 uv       : TEXCOORD0;
    uint rtIndex    : SV_RenderTargetArrayIndex; // GPU가 직접 텍스처 어레이 슬라이스로 분기
};

PS_INPUT VSMain(VS_INPUT input)
{
    PS_INPUT output;
    
    // 비트 AND 연산으로 0 (Left Eye) 또는 1 (Right Eye)을 1사이클 만에 도출
    uint eyeIndex = input.instanceId & 1;
    
    float4 worldPos = mul(float4(input.position, 1.0f), g_WorldMatrix);
    output.position = mul(worldPos, g_ViewProjection[eyeIndex]);
    output.normal   = mul(input.normal, (float3x3)g_WorldMatrix);
    output.uv       = input.uv;
    output.rtIndex  = eyeIndex; // 래스터라이저가 해당 텍스처 어레이 슬라이스로 픽셀 전송
    
    return output;
}

using System;
using System.Numerics;

namespace ZeliDesk.XR.Tracking
{
    public sealed class HeadPoseEKFTracker
    {
        private Vector3 _position;
        private Vector3 _velocity;
        private Quaternion _orientation;
        private Vector3 _angularVelocity;
        
        // 공분산 행렬 상태
        private float _posCovariance = 0.001f;
        private float _rotCovariance = 0.0001f;

        public HeadPoseEKFTracker()
        {
            _position = Vector3.Zero;
            _velocity = Vector3.Zero;
            _orientation = Quaternion.Identity;
            _angularVelocity = Vector3.Zero;
        }

        /// 

        /// 1000Hz IMU 고속 예측 단계 (Prediction Step)
        /// 
        public void Predict(Vector3 accel, Vector3 gyro, float dt)
        {
            // 1. 선형 운동 적분
            _position += _velocity * dt + 0.5f * accel * dt * dt;
            _velocity += accel * dt;

            // 2. 쿼터니언 각속도 적분 (Hamilton Product)
            _angularVelocity = gyro;
            float angle = gyro.Length() * dt;
            if (angle > 1e-6f)
            {
                Vector3 axis = Vector3.Normalize(gyro);
                Quaternion deltaQ = Quaternion.CreateFromAxisAngle(axis, angle);
                _orientation = Quaternion.Normalize(_orientation * deltaQ);
            }

            _posCovariance += 0.0005f * dt;
            _rotCovariance += 0.0001f * dt;
        }

        /// 

        /// 60Hz 광학 카메라 관측 보정 단계 (Update Step)
        /// 
        public void Correct(Vector3 measuredPos, Quaternion measuredRot)
        {
            // 칼만 이득 계산 (Kalman Gain K)
            float kPos = _posCovariance / (_posCovariance + 0.005f);
            float kRot = _rotCovariance / (_rotCovariance + 0.002f);

            // 위치 및 회전 잔차(Residual) 보정
            _position = Vector3.Lerp(_position, measuredPos, kPos);
            _orientation = Quaternion.Slerp(_orientation, measuredRot, kRot);

            _posCovariance *= (1.0f - kPos);
            _rotCovariance *= (1.0f - kRot);
        }

        /// 

        /// 디스플레이 표시 시점(미래 dt초)의 헤드 자세 사전 투사(Forward Projection)
        /// 
        public (Vector3 PredPos, Quaternion PredRot) PredictFuturePose(float predictionHorizonSeconds)
        {
            Vector3 futurePos = _position + _velocity * predictionHorizonSeconds;
            float futureAngle = _angularVelocity.Length() * predictionHorizonSeconds;
            Quaternion futureRot = _orientation;
            
            if (futureAngle > 1e-6f)
            {
                Vector3 axis = Vector3.Normalize(_angularVelocity);
                Quaternion deltaQ = Quaternion.CreateFromAxisAngle(axis, futureAngle);
                futureRot = Quaternion.Normalize(_orientation * deltaQ);
            }

            return (futurePos, futureRot);
        }
    }
}

Texture2DArray g_RenderedEyeTexture : register(t0);
RWTexture2DArray g_BackbufferUAV     : register(u0);
SamplerState g_LinearClampSampler           : register(s0);

cbuffer ATWConstants : register(b0)
{
    float3x3 g_DeltaRotation[2]; // Left & Right Eye Delta Matrix
    float4   g_DistortionCoeffs; // [k1, k2, k3, unused]
    float2   g_LensCenter[2];    // Optical Centers
};

[numthreads(16, 16, 1)]
void CSMain(uint3 dispatchThreadId : SV_DispatchThreadID)
{
    uint eyeIndex = dispatchThreadId.z;
    uint2 pixelCoord = dispatchThreadId.xy;
    
    // 정규화된 스크린 좌표계 [-1, 1] 변환
    float2 uv = (float2(pixelCoord) + 0.5f) / float2(1920.0f, 1080.0f);
    float2 ndc = uv * 2.0f - 1.0f;
    float2 opticalCenter = g_LensCenter[eyeIndex];
    float2 offset = ndc - opticalCenter;
    
    // 1. 브라운-콘라디 방사 왜곡(Radial Distortion) 역보정
    float r2 = dot(offset, offset);
    float distortionFactor = 1.0f + g_DistortionCoeffs.x * r2 
                                  + g_DistortionCoeffs.y * r2 * r2 
                                  + g_DistortionCoeffs.z * r2 * r2 * r2;
    float2 distortedOffset = offset * distortionFactor;
    
    // 2. 레이트 래칭 타임워프(Late-Latching TimeWarp) 광선 재투영
    float3 rayDir = float3(distortedOffset, 1.0f);
    float3 warpedRay = mul(rayDir, g_DeltaRotation[eyeIndex]);
    float2 warpedNDC = warpedRay.xy / warpedRay.z;
    
    float2 finalUV = (warpedNDC + opticalCenter) * 0.5f + 0.5f;
    
    // 경계 클리핑 및 텍스처 샘플링
    if (finalUV.x < 0.0f || finalUV.x > 1.0f || finalUV.y < 0.0f || finalUV.y > 1.0f)
    {
        g_BackbufferUAV[uint3(pixelCoord, eyeIndex)] = float4(0, 0, 0, 1); // 외곽 검은색 마스킹
    }
    else
    {
        float4 color = g_RenderedEyeTexture.SampleLevel(g_LinearClampSampler, float3(finalUV, eyeIndex), 0);
        g_BackbufferUAV[uint3(pixelCoord, eyeIndex)] = color;
    }
}