diff --git a/MsftOpenXRGame/Config/DefaultGame.ini b/MsftOpenXRGame/Config/DefaultGame.ini index 8f205a9..3412148 100644 --- a/MsftOpenXRGame/Config/DefaultGame.ini +++ b/MsftOpenXRGame/Config/DefaultGame.ini @@ -1,4 +1,5 @@ + [/Script/EngineSettings.GeneralProjectSettings] ProjectID=99F0EDDB4B092C7CA6713EAA6EFCB918 CompanyName=Microsoft @@ -12,4 +13,7 @@ HandMeshMaterial=Material'/Game/Materials/M_BasicUnlit.M_BasicUnlit' [/Script/HoloLensSettings.SceneUnderstanding] ShouldDoSceneUnderstandingMeshDetection=true -SceneUnderstandingVolumeHeight=4 \ No newline at end of file +SceneUnderstandingVolumeHeight=4 + +[/Script/UnrealEd.ProjectPackagingSettings] ++DirectoriesToAlwaysStageAsNonUFS=(Path="AzureObjectAnchors") diff --git a/MsftOpenXRGame/Config/DefaultInput.ini b/MsftOpenXRGame/Config/DefaultInput.ini index 566df70..6db586e 100644 --- a/MsftOpenXRGame/Config/DefaultInput.ini +++ b/MsftOpenXRGame/Config/DefaultInput.ini @@ -108,6 +108,9 @@ DoubleClickTime=0.200000 +SpeechMappings=(ActionName="StopSpatialMapping",SpeechKeyword="StopSpatialMapping") +SpeechMappings=(ActionName="UploadAnchors",SpeechKeyword="UploadAnchors") +SpeechMappings=(ActionName="DeleteFoundAnchors",SpeechKeyword="DeleteFoundAnchors") ++SpeechMappings=(ActionName="StartObjectDetection",SpeechKeyword="StartObjectDetection") ++SpeechMappings=(ActionName="StopObjectDetection",SpeechKeyword="StopObjectDetection") ++SpeechMappings=(ActionName="ResetSearchArea",SpeechKeyword="ResetSearchArea") DefaultPlayerInputClass=/Script/Engine.PlayerInput DefaultInputComponentClass=/Script/Engine.InputComponent DefaultTouchInterface=/Engine/MobileResources/HUD/DefaultVirtualJoysticks.DefaultVirtualJoysticks diff --git a/MsftOpenXRGame/Content/AzureObjectAnchorActor.uasset b/MsftOpenXRGame/Content/AzureObjectAnchorActor.uasset new file mode 100644 index 0000000..32c909b Binary files /dev/null and b/MsftOpenXRGame/Content/AzureObjectAnchorActor.uasset differ diff --git a/MsftOpenXRGame/Content/AzureObjectAnchorQueryModifiers.uasset b/MsftOpenXRGame/Content/AzureObjectAnchorQueryModifiers.uasset new file mode 100644 index 0000000..e2d43a5 Binary files /dev/null and b/MsftOpenXRGame/Content/AzureObjectAnchorQueryModifiers.uasset differ diff --git a/MsftOpenXRGame/Content/AzureObjectAnchors/cube_a03ddc87-441f-4d1f-b1c8-d915245d827c.ou b/MsftOpenXRGame/Content/AzureObjectAnchors/cube_a03ddc87-441f-4d1f-b1c8-d915245d827c.ou new file mode 100644 index 0000000..5fe5807 Binary files /dev/null and b/MsftOpenXRGame/Content/AzureObjectAnchors/cube_a03ddc87-441f-4d1f-b1c8-d915245d827c.ou differ diff --git a/MsftOpenXRGame/Content/EyeTrackingComponent.uasset b/MsftOpenXRGame/Content/EyeTrackingComponent.uasset index 8c45dbb..93c4b4f 100644 Binary files a/MsftOpenXRGame/Content/EyeTrackingComponent.uasset and b/MsftOpenXRGame/Content/EyeTrackingComponent.uasset differ diff --git a/MsftOpenXRGame/Content/MRPlayerPawn.uasset b/MsftOpenXRGame/Content/MRPlayerPawn.uasset index 61a037f..6a3d4a6 100644 Binary files a/MsftOpenXRGame/Content/MRPlayerPawn.uasset and b/MsftOpenXRGame/Content/MRPlayerPawn.uasset differ diff --git a/MsftOpenXRGame/Content/Maps/DefaultMap.umap b/MsftOpenXRGame/Content/Maps/DefaultMap.umap index 438b310..dd2cd00 100644 Binary files a/MsftOpenXRGame/Content/Maps/DefaultMap.umap and b/MsftOpenXRGame/Content/Maps/DefaultMap.umap differ diff --git a/MsftOpenXRGame/Content/Maps/DefaultMap_BuiltData.uasset b/MsftOpenXRGame/Content/Maps/DefaultMap_BuiltData.uasset index 19d9c08..26fa238 100644 Binary files a/MsftOpenXRGame/Content/Maps/DefaultMap_BuiltData.uasset and b/MsftOpenXRGame/Content/Maps/DefaultMap_BuiltData.uasset differ diff --git a/MsftOpenXRGame/Content/Materials/AzureObjectAnchorMaterial.uasset b/MsftOpenXRGame/Content/Materials/AzureObjectAnchorMaterial.uasset new file mode 100644 index 0000000..1762f9f Binary files /dev/null and b/MsftOpenXRGame/Content/Materials/AzureObjectAnchorMaterial.uasset differ diff --git a/MsftOpenXRGame/Content/QRTracker.uasset b/MsftOpenXRGame/Content/QRTracker.uasset index aac1134..5c8cb61 100644 Binary files a/MsftOpenXRGame/Content/QRTracker.uasset and b/MsftOpenXRGame/Content/QRTracker.uasset differ diff --git a/MsftOpenXRGame/Content/SpatialMappingActor.uasset b/MsftOpenXRGame/Content/SpatialMappingActor.uasset index 995b16b..5aad7d5 100644 Binary files a/MsftOpenXRGame/Content/SpatialMappingActor.uasset and b/MsftOpenXRGame/Content/SpatialMappingActor.uasset differ diff --git a/MsftOpenXRGame/MsftOpenXRGame.uproject b/MsftOpenXRGame/MsftOpenXRGame.uproject index c14ce32..953364e 100644 --- a/MsftOpenXRGame/MsftOpenXRGame.uproject +++ b/MsftOpenXRGame/MsftOpenXRGame.uproject @@ -1,6 +1,6 @@ { "FileVersion": 3, - "EngineAssociation": "4.26", + "EngineAssociation": "4.27", "Category": "", "Description": "", "Modules": [ diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/MicrosoftOpenXR.uplugin b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/MicrosoftOpenXR.uplugin index 57d6f81..49bce8d 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/MicrosoftOpenXR.uplugin +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/MicrosoftOpenXR.uplugin @@ -1,7 +1,7 @@ { "FileVersion": 3, "Version": 1, - "VersionName": "1.1.9", + "VersionName": "1.1.11", "FriendlyName": "Microsoft OpenXR", "Description": "The Microsoft OpenXR plugin is a game plugin which provides additional features available on Microsoft's Mixed Reality devices like the HoloLens 2 when using OpenXR.", "Category": "Mixed Reality", @@ -10,7 +10,7 @@ "DocsURL": "", "MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/ef8930ca860148c498b46887da196239", "SupportURL": "https://github.com/microsoft/Microsoft-OpenXR-Unreal", - "EngineVersion": "4.26.0", + "EngineVersion": "4.27.0", "CanContainContent": true, "IsBetaVersion": false, "IsExperimentalVersion": false, diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.cpp new file mode 100644 index 0000000..080a96d --- /dev/null +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.cpp @@ -0,0 +1,795 @@ +// Copyright (c) 2022 Microsoft Corporation. +// Licensed under the MIT License. + +#include "AzureObjectAnchorsPlugin.h" + +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + +#include "Interfaces/IPluginManager.h" +#include "Misc/Paths.h" +#include "Modules/ModuleManager.h" + +#include "winrt/Windows.ApplicationModel.h" +#include "winrt/Windows.Storage.h" +#include "winrt/Windows.Storage.Streams.h" + +namespace WF = winrt::Windows::Foundation; +namespace WFN = WF::Numerics; + +namespace MicrosoftOpenXR +{ + void FAzureObjectAnchorsPlugin::Register() + { + IModularFeatures::Get().RegisterModularFeature(GetModularFeatureName(), this); + + const FString PluginBaseDir = IPluginManager::Get().FindPlugin("MicrosoftOpenXR")->GetBaseDir(); + FString PackageRelativePath = PluginBaseDir / THIRDPARTY_BINARY_SUBFOLDER; + + // On HoloLens, DLLs must be loaded relative to the package with no ".."'s in the path. + // If using FPlatformProcess::PushDLLDirectory, the library path must be made relative to the RootDir. +#if PLATFORM_HOLOLENS + FPaths::MakePathRelativeTo(PackageRelativePath, *(FPaths::RootDir() + TEXT("/"))); +#endif + FString Binaries[] = { + "ObjectTrackerApi.dll", + "ObjectTrackerDiagnostics.dll", + "VolumeFusionAPI.dll", + "ObjectTrackerFusion.dll", + "ObjectTrackerRefinement.dll", + "Microsoft.Azure.ObjectAnchors.dll" + }; + + FPlatformProcess::PushDllDirectory(*PackageRelativePath); + for (FString Binary : Binaries) + { + if (!FPlatformProcess::GetDllHandle(*Binary)) + { + UE_LOG(LogAOA, Warning, TEXT("Dll \'%s\' can't be loaded from \'%s\'"), *Binary, *PackageRelativePath); + } + } + FPlatformProcess::PopDllDirectory(*PackageRelativePath); + } + + void FAzureObjectAnchorsPlugin::Unregister() + { + IModularFeatures::Get().UnregisterModularFeature(GetModularFeatureName(), this); + + if (ObjectAnchorObserver) + { + ObjectAnchorObserver.Close(); + ObjectAnchorObserver = nullptr; + } + } + + FAzureObjectAnchorsPlugin::~FAzureObjectAnchorsPlugin() + { + if (DetectTask) + { + DetectTask.Cancel(); + } + } + + bool FAzureObjectAnchorsPlugin::GetRequiredExtensions(TArray& OutExtensions) + { + OutExtensions.Add(XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME); + return true; + } + + const void* FAzureObjectAnchorsPlugin::OnCreateSession(XrInstance InInstance, XrSystemId InSystem, const void* InNext) + { + // First check for the correct spatial graph bridge extension version. + XR_ENSURE_MSFT(xrGetInstanceProcAddr(InInstance, "xrEnumerateInstanceExtensionProperties", (PFN_xrVoidFunction*)&xrEnumerateInstanceExtensionProperties)); + XR_ENSURE_MSFT(xrGetInstanceProcAddr(InInstance, "xrCreateSpatialGraphNodeSpaceMSFT", (PFN_xrVoidFunction*)&xrCreateSpatialGraphNodeSpaceMSFT)); + + uint32_t ExtensionsCount = 0; + if (XR_SUCCEEDED(xrEnumerateInstanceExtensionProperties(nullptr, 0, &ExtensionsCount, nullptr))) + { + TArray Properties; + Properties.SetNum(ExtensionsCount); + for (auto& Prop : Properties) + { + Prop = XrExtensionProperties{ XR_TYPE_EXTENSION_PROPERTIES }; + } + + if (XR_ENSURE_MSFT(xrEnumerateInstanceExtensionProperties(nullptr, ExtensionsCount, &ExtensionsCount, Properties.GetData()))) + { + for (const XrExtensionProperties& Prop : Properties) + { + if (strcmp(Prop.extensionName, XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME) == 0) + { + CanUseSpatialGraphExtension = Prop.extensionVersion >= 2; + break; + } + } + } + } + + if (CanUseSpatialGraphExtension) + { + XR_ENSURE_MSFT(xrGetInstanceProcAddr(InInstance, "xrTryCreateSpatialGraphStaticNodeBindingMSFT", (PFN_xrVoidFunction*)&xrTryCreateSpatialGraphStaticNodeBindingMSFT)); + XR_ENSURE_MSFT(xrGetInstanceProcAddr(InInstance, "xrGetSpatialGraphNodeBindingPropertiesMSFT", (PFN_xrVoidFunction*)&xrGetSpatialGraphNodeBindingPropertiesMSFT)); + } + else + { + UE_LOG(LogAOA, Warning, TEXT("Current OpenXR runtime does not support Azure Object Anchors. Requires XR_MSFT_SPATIAL_GRAPH_BRIDGE version 2.")); + } + + if (IOpenXRARModule::IsAvailable()) + { + TrackedMeshHolder = IOpenXRARModule::Get().GetTrackedMeshHolder(); + } + + return InNext; + } + + const void* FAzureObjectAnchorsPlugin::OnBeginSession(XrSession InSession, const void* InNext) + { + Session = InSession; + WorldToMetersScale = UHeadMountedDisplayFunctionLibrary::GetWorldToMetersScale(GWorld); + + return InNext; + } + + void FAzureObjectAnchorsPlugin::UpdateDeviceLocations(XrSession InSession, XrTime DisplayTime, XrSpace TrackingSpace) + { + { + FScopeLock Lock(&MeshComponentLock); + if (IsAzureObjectAnchorsStartDesired) + { + // Azure Object Anchors was initialized too early, attempt to start it now. + InitAzureObjectAnchors(AzureObjectAnchorConfiguration); + return; + } + + if (!CanUseSpatialGraphExtension || + AOAMap.Num() == 0 || + ObjectAnchorObserver == nullptr || + IsCurrentlyDetecting) + { + return; + } + } + + if (OriginCoordinateSystemTrackingSpace != TrackingSpace + || !FrameOfReferenceLocated) + { + FScopeLock Lock(&MeshComponentLock); + for (auto& data : AOAMap) + { + data.Value.ResetObjectInstance(TrackedMeshHolder); + } + + XrSpatialGraphStaticNodeBindingCreateInfoMSFT SpatialGraphStaticNodeBindingCreateInfo + { + XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT, + nullptr, + TrackingSpace, + ToXrPose(FTransform::Identity), + DisplayTime + }; + + XrSpatialGraphNodeBindingMSFT NodeBinding; + if (XR_SUCCEEDED(xrTryCreateSpatialGraphStaticNodeBindingMSFT(InSession, &SpatialGraphStaticNodeBindingCreateInfo, &NodeBinding))) + { + if (NodeBinding == XR_NULL_HANDLE) + { + // If the NodeBinding fails to be created, try again next frame. + UE_LOG(LogAOA, Warning, TEXT("SpatialGraphStaticNodeBinding was not created.")); + return; + } + + XrSpatialGraphNodeBindingPropertiesGetInfoMSFT PropertiesGetInfo{ XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT }; + XrSpatialGraphNodeBindingPropertiesMSFT NodeProperties{ XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT }; + + if (XR_SUCCEEDED(xrGetSpatialGraphNodeBindingPropertiesMSFT(NodeBinding, &PropertiesGetInfo, &NodeProperties))) + { + const XrQuaternionf& Rot = NodeProperties.poseInNodeSpace.orientation; + const XrVector3f& Pos = NodeProperties.poseInNodeSpace.position; + const WFN::float4x4 CoordinateSystemToNodeTransform = + WFN::make_float4x4_from_quaternion(WFN::quaternion(Rot.x, Rot.y, Rot.z, Rot.w)) * + WFN::make_float4x4_translation(WFN::float3(Pos.x, Pos.y, Pos.z)); + + OriginCoordinateSystem = { + winrt::guid(reinterpret_cast(NodeProperties.nodeId)), + CoordinateSystemToNodeTransform + }; + OriginCoordinateSystemTrackingSpace = TrackingSpace; + + FrameOfReferenceLocated = true; + } + } + } + + if (!FrameOfReferenceLocated) + { + return; + } + + // Locate object anchors that have changed. + { + FScopeLock Lock(&MeshComponentLock); + for (auto& data : AOAMap) + { + if (data.Value.HasChanged) + { + data.Value.HasChanged = false; + + // If the Object instance has closed or cannot be found, reset it. + if (data.Value.ObjectInstance == nullptr || + data.Value.ObjectInstance.TryGetCurrentState() == nullptr) + { + data.Value.ResetObjectInstance(TrackedMeshHolder); + continue; + } + + TrackedMeshHolder->StartMeshUpdates(); + + FOpenXRMeshUpdate* MeshUpdate = TrackedMeshHolder->AllocateMeshUpdate(data.Key); + MeshUpdate->Type = EARObjectClassification::SceneObject; + + MeshUpdate->Indices = data.Value.Indices; + MeshUpdate->Vertices = data.Value.Vertices; + + XrSpaceLocation Location{ XR_TYPE_SPACE_LOCATION }; + xrLocateSpace(data.Value.Space, TrackingSpace, DisplayTime, &Location); + const XrSpaceLocationFlags ValidFlags = XR_SPACE_LOCATION_ORIENTATION_VALID_BIT | XR_SPACE_LOCATION_POSITION_VALID_BIT; + if ((Location.locationFlags & ValidFlags) == ValidFlags) + { + MeshUpdate->TrackingState = EARTrackingState::Tracking; + MeshUpdate->LocalToTrackingTransform = ToFTransform(Location.pose, WorldToMetersScale); + } + else + { + MeshUpdate->TrackingState = EARTrackingState::NotTracking; + MeshUpdate->LocalToTrackingTransform = FTransform(FQuat::Identity, FVector::ZeroVector, FVector::ZeroVector); + } + +#if !UE_VERSION_OLDER_THAN(4, 27, 1) + MeshUpdate->SpatialMeshUsageFlags = + (EARSpatialMeshUsageFlags)((int32)EARSpatialMeshUsageFlags::Visible | + (int32)EARSpatialMeshUsageFlags::Collision); +#endif + + TrackedMeshHolder->EndMeshUpdates(); + } + } + } + + IsCurrentlyDetecting = true; + + Queries.clear(); + { + FScopeLock Lock(&MeshComponentLock); + for (auto& data : AOAMap) + { + data.Value.ResetStaleObjectInstance(TrackedMeshHolder); + if (!data.Value.IsCurrentlyBeingTracked()) + { + OA::ObjectQuery Query = OA::ObjectQuery(data.Value.ObjectModel); + + if (SearchAreas.empty()) + { + FXRHMDData HMDData; + UHeadMountedDisplayFunctionLibrary::GetHMDData(GWorld, HMDData); + FVector HMDPosTrackingSpace = UHeadMountedDisplayFunctionLibrary::GetTrackingToWorldTransform(GWorld).Inverse().TransformPosition(HMDData.Position); + DirectX::XMFLOAT3 HeadPos = WMRUtility::ToMixedRealityVector(HMDPosTrackingSpace / WorldToMetersScale); + + OA::SpatialGraph::SpatialSphere sphere = + { + WFN::float3(HeadPos.x, HeadPos.y, HeadPos.z), + AzureObjectAnchorConfiguration.SearchRadius / WorldToMetersScale + }; + + OA::ObjectSearchArea SearchArea = OA::ObjectSearchArea::FromSphere(OriginCoordinateSystem, sphere); + Query.SearchAreas().Append(SearchArea); + } + else + { + for (OA::SpatialGraph::SpatialSphere sphere : SearchAreas) + { + OA::ObjectSearchArea SearchArea = OA::ObjectSearchArea::FromSphere(OriginCoordinateSystem, sphere); + Query.SearchAreas().Append(SearchArea); + } + } + + if (AzureObjectAnchorConfiguration.QueryModifiers != nullptr) + { + if (AzureObjectAnchorConfiguration.QueryModifiers->bUseExpectedMaxVerticalOrientationInDegrees) + { + Query.ExpectedMaxVerticalOrientationInDegrees(AzureObjectAnchorConfiguration.QueryModifiers->ExpectedMaxVerticalOrientationInDegrees); + } + if (AzureObjectAnchorConfiguration.QueryModifiers->bUseExpectedToBeStandingOnGroundPlane) + { + Query.IsExpectedToBeStandingOnGroundPlane(AzureObjectAnchorConfiguration.QueryModifiers->ExpectedToBeStandingOnGroundPlane); + } + if (AzureObjectAnchorConfiguration.QueryModifiers->bUseMaxScaleChange) + { + Query.MaxScaleChange(AzureObjectAnchorConfiguration.QueryModifiers->MaxScaleChange); + } + if (AzureObjectAnchorConfiguration.QueryModifiers->bUseMinSurfaceCoverage) + { + Query.MinSurfaceCoverage(AzureObjectAnchorConfiguration.QueryModifiers->MinSurfaceCoverage); + } + } + Queries.emplace_back(std::move(Query)); + } + } + } + + if (Queries.size() == 0) + { + IsCurrentlyDetecting = false; + return; + } + + // Try to find any currently untracked object models. + TWeakPtr WeakSelf = SharedThis(this); + DetectTask = ObjectAnchorObserver.DetectAsync(Queries); + DetectTask.Completed([WeakSelf]( + WF::IAsyncOperation> AsyncOp, + WF::AsyncStatus Status) + { + if (TSharedPtr Self = WeakSelf.Pin()) + { + if (Status != WF::AsyncStatus::Completed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors DetectAsync failed.")); + + Self->IsCurrentlyDetecting = false; + return; + } + + WF::Collections::IVector Objects = AsyncOp.GetResults(); + for (OA::ObjectInstance Object : Objects) + { + if (Object.TryGetCurrentState() != nullptr) + { + Object.Mode(Self->AzureObjectAnchorConfiguration.TrackingMode == EObjectInstanceTrackingMode::LowLatencyCoarsePosition ? + OA::ObjectInstanceTrackingMode::LowLatencyCoarsePosition : + OA::ObjectInstanceTrackingMode::HighLatencyAccuratePosition + ); + + // Create a space with the initial state in case the changed event never fires + Self->UpdateSpatialGraphInfoForObjectInstance(Object); + + Self->AOAMap[WMRUtility::GUIDToFGuid(Object.ModelId())].ObjectInstanceChangedEventToken = + Object.Changed([WeakSelf](winrt::Windows::Foundation::IInspectable sender, OA::ObjectInstanceChangedEventArgs args) + { + if (TSharedPtr Self = WeakSelf.Pin()) + { + auto Object = sender.as(); + Self->UpdateSpatialGraphInfoForObjectInstance(Object); + } + }); + } + else + { + Object.Close(); + } + } + + Self->IsCurrentlyDetecting = false; + } + }); + } + + void FAzureObjectAnchorsPlugin::UpdateSpatialGraphInfoForObjectInstance(OA::ObjectInstance Object) + { + FScopeLock Lock(&MeshComponentLock); + + FGuid guid = WMRUtility::GUIDToFGuid(Object.ModelId()); + + AOAContext& AOAEntry = AOAMap[guid]; + AOAEntry.ObjectInstance = Object; + auto State = Object.TryGetCurrentState(); + if (State != nullptr) + { + OA::ObjectInstanceState CurrentState = State.as(); + + // Create a new XrSpace for this node if necessary. + if (AOAEntry.Space == XR_NULL_HANDLE + || AOAEntry.SpatialGraphNodeId != CurrentState.Center.NodeId) + { + if (AOAEntry.Space != XR_NULL_HANDLE) + { + xrDestroySpace(AOAEntry.Space); + } + + XrSpatialGraphNodeSpaceCreateInfoMSFT SpatialGraphNodeSpaceCreateInfo{ XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT }; + SpatialGraphNodeSpaceCreateInfo.nodeType = XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT; + SpatialGraphNodeSpaceCreateInfo.pose = XrPosef{ + XrQuaternionf + { + CurrentState.Center.Orientation.x, + CurrentState.Center.Orientation.y, + CurrentState.Center.Orientation.z, + CurrentState.Center.Orientation.w + }, + XrVector3f + { + CurrentState.Center.Position.x, + CurrentState.Center.Position.y, + CurrentState.Center.Position.z + } + }; + + FMemory::Memcpy(&SpatialGraphNodeSpaceCreateInfo.nodeId, &CurrentState.Center.NodeId, sizeof(SpatialGraphNodeSpaceCreateInfo.nodeId)); + + XrSpace Space; + if (XR_SUCCEEDED(xrCreateSpatialGraphNodeSpaceMSFT(Session, &SpatialGraphNodeSpaceCreateInfo, &Space))) + { + // If this fails, the next object update will try again. + AOAEntry.Space = Space; + } + } + + AOAEntry.SpatialGraphNodeId = CurrentState.Center.NodeId; + AOAEntry.LastKnownState = CurrentState; + AOAEntry.HasChanged = true; + } + } + + void FAzureObjectAnchorsPlugin::OnStartARSession(class UARSessionConfig* SessionConfig) + { + // ARTrackedGeometry requires a valid ARSession to know what class to use when initializing added geometry. + ARSessionStarted = true; + } + + bool FAzureObjectAnchorsPlugin::OnToggleARCapture(const bool bOnOff) + { + // Toggling "on" is a no-op, because this override does not support adding a session configuration. + // InitAzureObjectAnchors must be called to start the session. + + if (!bOnOff) + { + StopAzureObjectAnchors(); + } + + return true; + } + + void FAzureObjectAnchorsPlugin::InitAzureObjectAnchors(FAzureObjectAnchorSessionConfiguration AOAConfiguration) + { + if (UMicrosoftOpenXRFunctionLibrary::IsRemoting()) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors is not supported over remoting.")); + return; + } + + if (!OA::ObjectObserver::IsSupported()) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors is not supported on this device.")); + return; + } + + AzureObjectAnchorConfiguration = AOAConfiguration; + + FScopeLock Lock(&MeshComponentLock); + if (!ARSessionStarted || TrackedMeshHolder == nullptr) + { + // Azure Object Anchors is not ready to start, + // Set this flag to start when ready. + IsAzureObjectAnchorsStartDesired = true; + return; + } + + // Ready to start, reset flag. + IsAzureObjectAnchorsStartDesired = false; + + if (ObjectAnchorObserver != nullptr) + { + UE_LOG(LogAOA, Warning, TEXT("Attempting to initialize Azure Object Anchors after it was already initialized.")); + return; + } + + // Reset any currently tracked Azure Object Anchors. + AOAMap.Empty(); + + TWeakPtr WeakSelf = SharedThis(this); + auto RequestAccessOp = OA::ObjectObserver::RequestAccessAsync(); + RequestAccessOp.Completed([WeakSelf]( + WF::IAsyncOperation AsyncOp, + WF::AsyncStatus Status) + { + if (TSharedPtr Self = WeakSelf.Pin()) + { + if (Status != WF::AsyncStatus::Completed || + AsyncOp.GetResults() != OA::ObjectObserverAccessStatus::Allowed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors RequestAccessAsync failed with AsyncStatus %d, and ObjectObserverAccessStatus %d"), (int)Status, (int)AsyncOp.GetResults()); + return; + } + + FGuid AccountID(Self->AzureObjectAnchorConfiguration.AccountID); + if (!AccountID.IsValid()) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors invalid account ID guid.")); + return; + } + + winrt::hstring AccountKey = winrt::hstring(*Self->AzureObjectAnchorConfiguration.AccountKey); + winrt::hstring AccountDomain = winrt::hstring(*Self->AzureObjectAnchorConfiguration.AccountDomain); + OA::AccountInformation AccountInfo(WMRUtility::FGUIDToGuid(AccountID), AccountKey, AccountDomain); + + FScopeLock Lock(&Self->MeshComponentLock); + Self->ObjectAnchorSession = OA::ObjectAnchorsSession(AccountInfo); + Self->ObjectAnchorObserver = Self->ObjectAnchorSession.CreateObjectObserver(); + + // Set the models the ObjectObserver will look for. These must have gone through the Object Anchor parser. + // Models in the game project must be manually included in the package: + // Project Settings > Packaging > Additional Non-Asset Directories To Copy + // Or they should be placed in the 3D Objects directory on the device, and the Objects3D capability must be set. + Self->LoadObjectModelsAsync(winrt::Windows::ApplicationModel::Package::Current().InstalledLocation().Path()); + Self->LoadObjectModelsAsync(winrt::Windows::Storage::KnownFolders::Objects3D().Path()); + } + }); + } + + void FAzureObjectAnchorsPlugin::StopAzureObjectAnchors() + { + FScopeLock Lock(&MeshComponentLock); + IsAzureObjectAnchorsStartDesired = false; + + if (DetectTask) + { + DetectTask.Cancel(); + } + + if (ObjectAnchorObserver) + { + ObjectAnchorObserver.Close(); + ObjectAnchorObserver = nullptr; + } + } + + void FAzureObjectAnchorsPlugin::ResetObjectSearchAreaAroundHead() + { + FScopeLock Lock(&MeshComponentLock); + // Clear any search areas so queries will look around the current pose. + SearchAreas.clear(); + + // Trigger new search queries + for (auto& data : AOAMap) + { + data.Value.ResetObjectInstance(TrackedMeshHolder); + } + } + + void FAzureObjectAnchorsPlugin::ResetObjectSearchAreaAroundPoint(FVector Point, float Radius, bool ClearExistingSearchAreas) + { + FScopeLock Lock(&MeshComponentLock); + if (ClearExistingSearchAreas) + { + SearchAreas.clear(); + } + + FVector PointInTrackingSpace = UHeadMountedDisplayFunctionLibrary::GetTrackingToWorldTransform(GWorld).Inverse().TransformPosition(Point); + DirectX::XMFLOAT3 Origin = WMRUtility::ToMixedRealityVector(PointInTrackingSpace / WorldToMetersScale); + + OA::SpatialGraph::SpatialSphere sphere = + { + WFN::float3(Origin.x, Origin.y, Origin.z), + Radius / WorldToMetersScale + }; + + SearchAreas.push_back(sphere); + + // Trigger new search queries + for (auto& data : AOAMap) + { + data.Value.ResetObjectInstance(TrackedMeshHolder); + } + } + + TArray FAzureObjectAnchorsPlugin::OnLineTraceTrackedObjects(const TSharedPtr ARCompositionComponent, const FVector Start, const FVector End, const EARLineTraceChannels TraceChannels) + { + TSharedPtr ARSystem = ARCompositionComponent; + if (ARSystem == nullptr) + { + ARSystem = TSharedPtr{ + StaticCastSharedPtr(GEngine->XRSystem)->GetARCompositionComponent() }; + } + + TArray Results; + + FScopeLock Lock(&MeshComponentLock); + TArray Meshes = UARBlueprintLibrary::GetAllGeometriesByClass(); + for (auto& data : AOAMap) + { + if (data.Value.CollisionInfo == nullptr) + { + continue; + } + + for (UARMeshGeometry* Mesh : Meshes) + { + if (Mesh->UniqueId == data.Key) + { + FVector HitPoint, HitNormal; + float HitDistance; + if (data.Value.CollisionInfo->Collides(Start, End, Mesh->GetLocalToWorldTransform(), HitPoint, HitNormal, HitDistance)) + { + // Append a hit. The calling function will then sort by HitDistance. + Results.Add(FARTraceResult(ARSystem, HitDistance, TraceChannels, + FTransform(HitNormal.ToOrientationQuat(), HitPoint), Mesh)); + } + + break; + } + } + } + + return Results; + } + + void FAzureObjectAnchorsPlugin::LoadObjectModelsAsync(winrt::hstring Path) + { + TWeakPtr WeakSelf = SharedThis(this); + auto GetFolderTask = winrt::Windows::Storage::StorageFolder::GetFolderFromPathAsync(Path); + GetFolderTask.Completed([WeakSelf](WF::IAsyncOperation AsyncOp, WF::AsyncStatus Status) + { + if (Status != WF::AsyncStatus::Completed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors GetFolderFromPathAsync failed.")); + return; + } + + auto GetItemsTask = AsyncOp.GetResults().GetItemsAsync(); + GetItemsTask.Completed([WeakSelf]( + WF::IAsyncOperation< + WF::Collections::IVectorView> AsyncOp, WF::AsyncStatus Status) + { + TSharedPtr Self = WeakSelf.Pin(); + if (Self == nullptr) + { + return; + } + + if (Status != WF::AsyncStatus::Completed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors GetItemsAsync failed.")); + return; + } + + for (auto const& item : AsyncOp.GetResults()) + { + if (item.IsOfType(winrt::Windows::Storage::StorageItemTypes::Folder)) + { + // Load models in subdirectories. + Self->LoadObjectModelsAsync(item.as().Path()); + continue; + } + + const auto file = item.as(); + // Object Anchor service requires the input models to have gone through its parser before being used by the observer. + if (file.FileType() != L".ou") + { + continue; + } + + auto ReadBufferTask = winrt::Windows::Storage::FileIO::ReadBufferAsync(file); + ReadBufferTask.Completed([WeakSelf](WF::IAsyncOperation AsyncOp, WF::AsyncStatus Status) + { + TSharedPtr Self = WeakSelf.Pin(); + if (Self == nullptr) + { + return; + } + + if (Status != WF::AsyncStatus::Completed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors ReadBufferAsync failed.")); + return; + } + + winrt::Windows::Storage::Streams::IBuffer Buffer = AsyncOp.GetResults(); + + FScopeLock Lock(&Self->MeshComponentLock); + if (Self->ObjectAnchorObserver == nullptr) + { + return; + } + auto LoadObjectTask = Self->ObjectAnchorObserver.LoadObjectModelAsync( + winrt::array_view(Buffer.data(), Buffer.Length())); + LoadObjectTask.Completed([WeakSelf, Buffer](WF::IAsyncOperation AsyncOp, WF::AsyncStatus Status) + { + TSharedPtr Self = WeakSelf.Pin(); + if (Self == nullptr) + { + return; + } + + if (Status != WF::AsyncStatus::Completed) + { + UE_LOG(LogAOA, Warning, TEXT("Azure Object Anchors LoadObjectModelAsync failed.")); + return; + } + + OA::ObjectModel Model = AsyncOp.GetResults(); + if (!Self->AOAMap.Contains(WMRUtility::GUIDToFGuid(Model.Id()))) + { + AsyncTask(ENamedThreads::GameThread, [WeakSelf, Model]() + { + TSharedPtr Self = WeakSelf.Pin(); + if (Self == nullptr) + { + return; + } + + FScopeLock Lock(&Self->MeshComponentLock); + AOAContext Context; + Context.ObjectModel = Model; + + // Load the mesh data to set the collision mesh. + std::vector SrcVertices(Model.VertexCount()); + std::vector SrcIndices(Model.TriangleIndexCount()); + + Model.GetVertexPositions(SrcVertices); + Model.GetTriangleIndices(SrcIndices); + + TArray Vertices; + TArray Indices; + + Vertices.AddUninitialized(Model.VertexCount()); + Indices.AddUninitialized(Model.TriangleIndexCount()); + + // MRMesh uses uint16 for indices so we cannot directly memcpy + for (size_t i = 0; i < Model.TriangleIndexCount(); i++) + { + Indices[i] = (MRMESH_INDEX_TYPE)SrcIndices[i]; + } + + for (size_t i = 0; i < Model.VertexCount(); i++) + { + Vertices[i] = MicrosoftOpenXR::WMRUtility::FromFloat3(SrcVertices[i], Self->WorldToMetersScale); + } + + Context.CollisionInfo = new TrackedGeometryCollision(Vertices, Indices); + + // Update the MRMesh data with the chosen render mode. + Self->TrackedMeshHolder->StartMeshUpdates(); + FOpenXRMeshUpdate* MeshUpdate = Self->TrackedMeshHolder->AllocateMeshUpdate(WMRUtility::GUIDToFGuid(Model.Id())); + + if (Self->AzureObjectAnchorConfiguration.ObjectRenderMode == EObjectRenderMode::Mesh) + { + // Use the full mesh data in the MRMesh + Context.Indices = Indices; + Context.Vertices = Vertices; + } + else if (Self->AzureObjectAnchorConfiguration.ObjectRenderMode == EObjectRenderMode::BoundingBox) + { + // Create an indexed primitive from the bounding box rather than using all of the model mesh data. + // This can help performance if the object model has too many polys. + + FVector Center = WMRUtility::FromFloat3(Model.BoundingBox().Center, Self->WorldToMetersScale); + FVector HalfExtents = WMRUtility::FromFloat3(Model.BoundingBox().Extents / 2.0f, Self->WorldToMetersScale); + + TrackedGeometryCollision::CreateMeshDataForBoundingBox(Center, HalfExtents, Context.Vertices, Context.Indices); + } + + MeshUpdate->Indices = Context.Indices; + MeshUpdate->Vertices = Context.Vertices; + + MeshUpdate->Type = EARObjectClassification::SceneObject; + MeshUpdate->LocalToTrackingTransform = FTransform(FQuat::Identity, FVector::ZeroVector, FVector::ZeroVector); +#if !UE_VERSION_OLDER_THAN(4, 27, 1) + MeshUpdate->SpatialMeshUsageFlags = + (EARSpatialMeshUsageFlags)((int32)EARSpatialMeshUsageFlags::Visible | + (int32)EARSpatialMeshUsageFlags::Collision); +#endif + + Self->TrackedMeshHolder->EndMeshUpdates(); + + Self->AOAMap.Add(WMRUtility::GUIDToFGuid(Model.Id()), Context); + }); + } + }); + }); + } + }); + }); + } + +} // namespace MicrosoftOpenXR + +#endif //PLATFORM_WINDOWS || PLATFORM_HOLOLENS diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.h new file mode 100644 index 0000000..8559d2a --- /dev/null +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/AzureObjectAnchorsPlugin.h @@ -0,0 +1,164 @@ +// Copyright (c) 2022 Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once + +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + +#include "OpenXRCommon.h" +#include "OpenXRCore.h" +#include "MicrosoftOpenXR.h" + +#include +#include +#include + +#include "Async/Async.h" +#include "Engine/Engine.h" + +#include "WindowsMixedRealityInteropUtility.h" + +#include "IOpenXRARTrackedGeometryHolder.h" +#include "IOpenXRARModule.h" +#include "Misc/EngineVersionComparison.h" + +#include "TrackedGeometryCollision.h" +#include "ARBlueprintLibrary.h" +#include "HeadMountedDisplayFunctionLibrary.h" + +namespace OA = winrt::Microsoft::Azure::ObjectAnchors; + +namespace MicrosoftOpenXR +{ + class FAzureObjectAnchorsPlugin : + public IOpenXRExtensionPlugin, + public IOpenXRCustomCaptureSupport, + public TSharedFromThis + { + public: + void Register(); + void Unregister(); + + ~FAzureObjectAnchorsPlugin(); + + void OnStartARSession(class UARSessionConfig* SessionConfig) override; + + bool GetRequiredExtensions(TArray& OutExtensions) override; + const void* OnCreateSession(XrInstance InInstance, XrSystemId InSystem, const void* InNext) override; + virtual const void* OnBeginSession(XrSession InSession, const void* InNext) override; + void UpdateDeviceLocations(XrSession InSession, XrTime DisplayTime, XrSpace TrackingSpace) override; + + bool OnToggleARCapture(const bool bOnOff) override; + void InitAzureObjectAnchors(FAzureObjectAnchorSessionConfiguration AOAConfiguration); + void ResetObjectSearchAreaAroundHead(); + void ResetObjectSearchAreaAroundPoint(FVector Point, float Radius, bool ClearExistingSearchAreas); + + TArray OnLineTraceTrackedObjects(const TSharedPtr ARCompositionComponent, const FVector Start, const FVector End, const EARLineTraceChannels TraceChannels) override; + + private: + XrSession Session; + + PFN_xrCreateSpatialGraphNodeSpaceMSFT xrCreateSpatialGraphNodeSpaceMSFT; + PFN_xrEnumerateInstanceExtensionProperties xrEnumerateInstanceExtensionProperties; + PFN_xrTryCreateSpatialGraphStaticNodeBindingMSFT xrTryCreateSpatialGraphStaticNodeBindingMSFT; + PFN_xrGetSpatialGraphNodeBindingPropertiesMSFT xrGetSpatialGraphNodeBindingPropertiesMSFT; + + bool IsAzureObjectAnchorsStartDesired = false; + + bool CanUseSpatialGraphExtension = false; + bool ARSessionStarted = false; + bool FrameOfReferenceLocated = false; + bool IsCurrentlyDetecting = false; + + winrt::Windows::Foundation::IAsyncOperation> DetectTask = nullptr; + + FAzureObjectAnchorSessionConfiguration AzureObjectAnchorConfiguration; + OA::SpatialGraph::SpatialSphere SearchSphere; + std::vector Queries; + + IOpenXRARTrackedMeshHolder* TrackedMeshHolder = nullptr; + float WorldToMetersScale = 100.0f; + + OA::ObjectAnchorsSession ObjectAnchorSession = nullptr; + OA::ObjectObserver ObjectAnchorObserver = nullptr; + + OA::SpatialGraph::SpatialGraphCoordinateSystem OriginCoordinateSystem; + XrSpace OriginCoordinateSystemTrackingSpace = XR_NULL_HANDLE; + + struct AOAContext + { + winrt::guid SpatialGraphNodeId; + XrSpace Space = XR_NULL_HANDLE; + + OA::ObjectModel ObjectModel = nullptr; + OA::ObjectInstance ObjectInstance = nullptr; + winrt::event_token ObjectInstanceChangedEventToken; + + bool HasChanged = false; + OA::ObjectInstanceState LastKnownState; + + TArray Vertices; + TArray Indices; + + TrackedGeometryCollision* CollisionInfo = nullptr; + + public: + void ResetObjectInstance(IOpenXRARTrackedMeshHolder* TrackedMeshHolder) + { + if (ObjectInstance != nullptr) + { + if (ObjectInstanceChangedEventToken.value != 0) + { + ObjectInstance.Changed(ObjectInstanceChangedEventToken); + } + + ObjectInstance.Close(); + + TrackedMeshHolder->StartMeshUpdates(); + TrackedMeshHolder->RemoveMesh(WMRUtility::GUIDToFGuid(ObjectModel.Id())); + TrackedMeshHolder->EndMeshUpdates(); + } + + ObjectInstanceChangedEventToken.value = 0; + + if (Space != XR_NULL_HANDLE) + { + xrDestroySpace(Space); + Space = XR_NULL_HANDLE; + } + + SpatialGraphNodeId = winrt::guid(); + HasChanged = false; + } + + bool IsCurrentlyBeingTracked() + { + return ObjectInstanceChangedEventToken.value != 0; + } + + // This can happen if the device loses tracking: + // The underlying object instance can be closed without triggering a changed event. + // Reset the object instance to find a new one. + void ResetStaleObjectInstance(IOpenXRARTrackedMeshHolder* TrackedMeshHolder) + { + if (IsCurrentlyBeingTracked() && + (ObjectInstance == nullptr || + ObjectInstance.TryGetCurrentState() == nullptr)) + { + ResetObjectInstance(TrackedMeshHolder); + } + } + }; + + FCriticalSection MeshComponentLock; + TMap AOAMap; + + std::vector SearchAreas; + + void StopAzureObjectAnchors(); + void LoadObjectModelsAsync(winrt::hstring Path); + void UpdateSpatialGraphInfoForObjectInstance(OA::ObjectInstance Object); + }; +} // namespace MicrosoftOpenXR + +#endif //PLATFORM_WINDOWS || PLATFORM_HOLOLENS \ No newline at end of file diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr.h index bd59b66..103b6f5 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr.h @@ -2,7 +2,7 @@ #define OPENXR_H_ 1 /* -** Copyright (c) 2017-2021, The Khronos Group Inc. +** Copyright (c) 2017-2022, The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 OR MIT */ @@ -25,7 +25,7 @@ extern "C" { ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL)) // OpenXR current version number. -#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 0, 18) +#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 0, 22) #define XR_VERSION_MAJOR(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL) #define XR_VERSION_MINOR(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL) @@ -38,7 +38,7 @@ extern "C" { #define XR_NULL_HANDLE 0 #endif #endif - + #define XR_NULL_SYSTEM_ID 0 @@ -87,13 +87,13 @@ extern "C" { #define XR_DEFINE_HANDLE(object) typedef uint64_t object; #endif #endif - + #if !defined(XR_DEFINE_ATOM) #define XR_DEFINE_ATOM(object) typedef uint64_t object; #endif - + typedef uint64_t XrVersion; typedef uint64_t XrFlags64; @@ -196,6 +196,16 @@ typedef enum XrResult { XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT = -1000097005, XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB = -1000101000, XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB = -1000108000, + XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB = -1000118000, + XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB = -1000118001, + XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB = -1000118002, + XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB = -1000118003, + XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB = -1000118004, + XR_ERROR_UNKNOWN_PASSTHROUGH_FB = -1000118050, + XR_ERROR_RENDER_MODEL_KEY_INVALID_FB = -1000119000, + XR_RENDER_MODEL_UNAVAILABLE_FB = 1000119020, + XR_ERROR_MARKER_NOT_TRACKED_VARJO = -1000124000, + XR_ERROR_MARKER_ID_INVALID_VARJO = -1000124001, XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001, XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002, XR_RESULT_MAX_ENUM = 0x7FFFFFFF @@ -294,7 +304,6 @@ typedef enum XrStructureType { XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB = 1000041001, XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT = 1000046000, XR_TYPE_GRAPHICS_BINDING_EGL_MNDX = 1000048004, - XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT = 1000049000, XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT = 1000051000, XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT = 1000051001, XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT = 1000051002, @@ -351,22 +360,61 @@ typedef enum XrStructureType { XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT = 1000098000, XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT = 1000098001, XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB = 1000101000, + XR_TYPE_VIVE_TRACKER_PATHS_HTCX = 1000103000, + XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX = 1000103001, + XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC = 1000104000, + XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC = 1000104001, + XR_TYPE_FACIAL_EXPRESSIONS_HTC = 1000104002, XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB = 1000108000, + XR_TYPE_HAND_TRACKING_MESH_FB = 1000110001, + XR_TYPE_HAND_TRACKING_SCALE_FB = 1000110003, + XR_TYPE_HAND_TRACKING_AIM_STATE_FB = 1000111001, + XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB = 1000112000, XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB = 1000114000, XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB = 1000114001, XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB = 1000114002, XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB = 1000115000, + XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB = 1000116009, + XR_TYPE_KEYBOARD_TRACKING_QUERY_FB = 1000116004, + XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB = 1000116002, + XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB = 1000117001, + XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB = 1000118000, + XR_TYPE_PASSTHROUGH_CREATE_INFO_FB = 1000118001, + XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB = 1000118002, + XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB = 1000118003, + XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB = 1000118004, + XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB = 1000118005, + XR_TYPE_PASSTHROUGH_STYLE_FB = 1000118020, + XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB = 1000118021, + XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB = 1000118022, + XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB = 1000118030, + XR_TYPE_RENDER_MODEL_PATH_INFO_FB = 1000119000, + XR_TYPE_RENDER_MODEL_PROPERTIES_FB = 1000119001, + XR_TYPE_RENDER_MODEL_BUFFER_FB = 1000119002, + XR_TYPE_RENDER_MODEL_LOAD_INFO_FB = 1000119003, + XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB = 1000119004, XR_TYPE_BINDING_MODIFICATIONS_KHR = 1000120000, XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO = 1000121000, XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO = 1000121001, XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO = 1000121002, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO = 1000122000, + XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO = 1000124000, + XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO = 1000124001, + XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO = 1000124002, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT = 1000142000, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT = 1000142001, XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB = 1000160000, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB = 1000161000, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB = 1000162000, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB = 1000163000, + XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB = 1000171000, + XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB = 1000171001, + XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE = 1000196000, + XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB = 1000203002, + XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT = 1000049000, + XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT = 1000049001, + XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT = 1000049002, + XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT = 1000049003, XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, @@ -445,8 +493,14 @@ typedef enum XrObjectType { XR_OBJECT_TYPE_HAND_TRACKER_EXT = 1000051000, XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT = 1000097000, XR_OBJECT_TYPE_SCENE_MSFT = 1000097001, + XR_OBJECT_TYPE_FACIAL_TRACKER_HTC = 1000104000, XR_OBJECT_TYPE_FOVEATION_PROFILE_FB = 1000114000, + XR_OBJECT_TYPE_TRIANGLE_MESH_FB = 1000117000, + XR_OBJECT_TYPE_PASSTHROUGH_FB = 1000118000, + XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB = 1000118002, + XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB = 1000118004, XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000, + XR_OBJECT_TYPE_SPATIAL_GRAPH_NODE_BINDING_MSFT = 1000049000, XR_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF } XrObjectType; typedef XrFlags64 XrInstanceCreateFlags; @@ -973,7 +1027,7 @@ typedef struct XrEventDataInstanceLossPending { } XrEventDataInstanceLossPending; typedef struct XrEventDataSessionStateChanged { - XrStructureType type; + XrStructureType type; const void* XR_MAY_ALIAS next; XrSession session; XrSessionState state; @@ -1046,7 +1100,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReferenceSpaces)(XrSession session, typedef XrResult (XRAPI_PTR *PFN_xrCreateReferenceSpace)(XrSession session, const XrReferenceSpaceCreateInfo* createInfo, XrSpace* space); typedef XrResult (XRAPI_PTR *PFN_xrGetReferenceSpaceBoundsRect)(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df* bounds); typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSpace)(XrSession session, const XrActionSpaceCreateInfo* createInfo, XrSpace* space); -typedef XrResult (XRAPI_PTR *PFN_xrLocateSpace)(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation* location); +typedef XrResult (XRAPI_PTR *PFN_xrLocateSpace)(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation* location); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpace)(XrSpace space); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurations)(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t* viewConfigurationTypeCountOutput, XrViewConfigurationType* viewConfigurationTypes); typedef XrResult (XRAPI_PTR *PFN_xrGetViewConfigurationProperties)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties* configurationProperties); @@ -1055,9 +1109,9 @@ typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainFormats)(XrSession session, typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchain)(XrSession session, const XrSwapchainCreateInfo* createInfo, XrSwapchain* swapchain); typedef XrResult (XRAPI_PTR *PFN_xrDestroySwapchain)(XrSwapchain swapchain); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainImages)(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t* imageCountOutput, XrSwapchainImageBaseHeader* images); -typedef XrResult (XRAPI_PTR *PFN_xrAcquireSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo* acquireInfo, uint32_t* index); +typedef XrResult (XRAPI_PTR *PFN_xrAcquireSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo* acquireInfo, uint32_t* index); typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageWaitInfo* waitInfo); -typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo* releaseInfo); +typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo* releaseInfo); typedef XrResult (XRAPI_PTR *PFN_xrBeginSession)(XrSession session, const XrSessionBeginInfo* beginInfo); typedef XrResult (XRAPI_PTR *PFN_xrEndSession)(XrSession session); typedef XrResult (XRAPI_PTR *PFN_xrRequestExitSession)(XrSession session); @@ -1521,7 +1575,7 @@ typedef struct XrCompositionLayerEquirect2KHR { #define XR_KHR_binding_modification 1 #define XR_KHR_binding_modification_SPEC_VERSION 1 #define XR_KHR_BINDING_MODIFICATION_EXTENSION_NAME "XR_KHR_binding_modification" -typedef struct XrBindingModificationBaseHeaderKHR { +typedef struct XR_MAY_ALIAS XrBindingModificationBaseHeaderKHR { XrStructureType type; const void* XR_MAY_ALIAS next; } XrBindingModificationBaseHeaderKHR; @@ -1661,7 +1715,7 @@ typedef XrBool32 (XRAPI_PTR *PFN_xrDebugUtilsMessengerCallbackEXT)( XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT* callbackData, void* userData); - + // XrDebugUtilsMessengerCreateInfoEXT extends XrInstanceCreateInfo typedef struct XrDebugUtilsMessengerCreateInfoEXT { @@ -1676,7 +1730,7 @@ typedef struct XrDebugUtilsMessengerCreateInfoEXT { typedef XrResult (XRAPI_PTR *PFN_xrSetDebugUtilsObjectNameEXT)(XrInstance instance, const XrDebugUtilsObjectNameInfoEXT* nameInfo); typedef XrResult (XRAPI_PTR *PFN_xrCreateDebugUtilsMessengerEXT)(XrInstance instance, const XrDebugUtilsMessengerCreateInfoEXT* createInfo, XrDebugUtilsMessengerEXT* messenger); typedef XrResult (XRAPI_PTR *PFN_xrDestroyDebugUtilsMessengerEXT)(XrDebugUtilsMessengerEXT messenger); -typedef XrResult (XRAPI_PTR *PFN_xrSubmitDebugUtilsMessageEXT)(XrInstance instance, XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT* callbackData); +typedef XrResult (XRAPI_PTR *PFN_xrSubmitDebugUtilsMessageEXT)(XrInstance instance, XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT* callbackData); typedef XrResult (XRAPI_PTR *PFN_xrSessionBeginDebugUtilsLabelRegionEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo); typedef XrResult (XRAPI_PTR *PFN_xrSessionEndDebugUtilsLabelRegionEXT)(XrSession session); typedef XrResult (XRAPI_PTR *PFN_xrSessionInsertDebugUtilsLabelEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo); @@ -1695,7 +1749,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrCreateDebugUtilsMessengerEXT( XRAPI_ATTR XrResult XRAPI_CALL xrDestroyDebugUtilsMessengerEXT( XrDebugUtilsMessengerEXT messenger); -XRAPI_ATTR XrResult XRAPI_CALL xrSubmitDebugUtilsMessageEXT( +XRAPI_ATTR XrResult XRAPI_CALL xrSubmitDebugUtilsMessageEXT( XrInstance instance, XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, @@ -1927,8 +1981,12 @@ XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceLocationEXT( #define XR_MSFT_spatial_graph_bridge 1 -#define XR_MSFT_spatial_graph_bridge_SPEC_VERSION 1 + + XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT) + +#define XR_MSFT_spatial_graph_bridge_SPEC_VERSION 2 #define XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME "XR_MSFT_spatial_graph_bridge" +#define XR_GUID_SIZE_MSFT 16 typedef enum XrSpatialGraphNodeTypeMSFT { XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT = 1, @@ -1943,7 +2001,30 @@ typedef struct XrSpatialGraphNodeSpaceCreateInfoMSFT { XrPosef pose; } XrSpatialGraphNodeSpaceCreateInfoMSFT; +typedef struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef poseInSpace; + XrTime time; +} XrSpatialGraphStaticNodeBindingCreateInfoMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialGraphNodeBindingPropertiesGetInfoMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint8_t nodeId[XR_GUID_SIZE_MSFT]; + XrPosef poseInNodeSpace; +} XrSpatialGraphNodeBindingPropertiesMSFT; + typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo, XrSpatialGraphNodeBindingMSFT* nodeBinding); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo, XrSpatialGraphNodeBindingPropertiesMSFT* properties); #ifndef XR_NO_PROTOTYPES #ifdef XR_EXTENSION_PROTOTYPES @@ -1951,6 +2032,19 @@ XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT( XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrTryCreateSpatialGraphStaticNodeBindingMSFT( + XrSession session, + const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo, + XrSpatialGraphNodeBindingMSFT* nodeBinding); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialGraphNodeBindingMSFT( + XrSpatialGraphNodeBindingMSFT nodeBinding); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialGraphNodeBindingPropertiesMSFT( + XrSpatialGraphNodeBindingMSFT nodeBinding, + const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo, + XrSpatialGraphNodeBindingPropertiesMSFT* properties); #endif /* XR_EXTENSION_PROTOTYPES */ #endif /* !XR_NO_PROTOTYPES */ @@ -2080,7 +2174,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrLocateHandJointsEXT( #define XR_MSFT_hand_tracking_mesh 1 -#define XR_MSFT_hand_tracking_mesh_SPEC_VERSION 3 +#define XR_MSFT_hand_tracking_mesh_SPEC_VERSION 4 #define XR_MSFT_HAND_TRACKING_MESH_EXTENSION_NAME "XR_MSFT_hand_tracking_mesh" typedef enum XrHandPoseTypeMSFT { @@ -2405,9 +2499,8 @@ typedef struct XrCompositionLayerSecureContentFB { #define XR_VALVE_analog_threshold 1 -#define XR_VALVE_analog_threshold_SPEC_VERSION 1 +#define XR_VALVE_analog_threshold_SPEC_VERSION 2 #define XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME "XR_VALVE_analog_threshold" -// XrInteractionProfileAnalogThresholdVALVE extends XrInteractionProfileSuggestedBinding typedef struct XrInteractionProfileAnalogThresholdVALVE { XrStructureType type; const void* XR_MAY_ALIAS next; @@ -2860,8 +2953,161 @@ XRAPI_ATTR XrResult XRAPI_CALL xrRequestDisplayRefreshRateFB( #define XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_cosmos_controller_interaction" +#define XR_HTCX_vive_tracker_interaction 1 +#define XR_HTCX_vive_tracker_interaction_SPEC_VERSION 1 +#define XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTCX_vive_tracker_interaction" +typedef struct XrViveTrackerPathsHTCX { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPath persistentPath; + XrPath rolePath; +} XrViveTrackerPathsHTCX; + +typedef struct XrEventDataViveTrackerConnectedHTCX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViveTrackerPathsHTCX* paths; +} XrEventDataViveTrackerConnectedHTCX; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViveTrackerPathsHTCX)(XrInstance instance, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrViveTrackerPathsHTCX* paths); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViveTrackerPathsHTCX( + XrInstance instance, + uint32_t pathCapacityInput, + uint32_t* pathCountOutput, + XrViveTrackerPathsHTCX* paths); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HTC_facial_tracking 1 + +#define XR_FACIAL_EXPRESSION_EYE_COUNT_HTC 14 + + +#define XR_FACIAL_EXPRESSION_LIP_COUNT_HTC 37 + +XR_DEFINE_HANDLE(XrFacialTrackerHTC) +#define XR_HTC_facial_tracking_SPEC_VERSION 1 +#define XR_HTC_FACIAL_TRACKING_EXTENSION_NAME "XR_HTC_facial_tracking" + +typedef enum XrEyeExpressionHTC { + XR_EYE_EXPRESSION_LEFT_BLINK_HTC = 0, + XR_EYE_EXPRESSION_LEFT_WIDE_HTC = 1, + XR_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2, + XR_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3, + XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4, + XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5, + XR_EYE_EXPRESSION_LEFT_DOWN_HTC = 6, + XR_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7, + XR_EYE_EXPRESSION_LEFT_OUT_HTC = 8, + XR_EYE_EXPRESSION_RIGHT_IN_HTC = 9, + XR_EYE_EXPRESSION_LEFT_IN_HTC = 10, + XR_EYE_EXPRESSION_RIGHT_OUT_HTC = 11, + XR_EYE_EXPRESSION_LEFT_UP_HTC = 12, + XR_EYE_EXPRESSION_RIGHT_UP_HTC = 13, + XR_EYE_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF +} XrEyeExpressionHTC; + +typedef enum XrLipExpressionHTC { + XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0, + XR_LIP_EXPRESSION_JAW_LEFT_HTC = 1, + XR_LIP_EXPRESSION_JAW_FORWARD_HTC = 2, + XR_LIP_EXPRESSION_JAW_OPEN_HTC = 3, + XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4, + XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5, + XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6, + XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7, + XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8, + XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9, + XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10, + XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11, + XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = 12, + XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = 13, + XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = 14, + XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = 15, + XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16, + XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17, + XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18, + XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19, + XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20, + XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21, + XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22, + XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23, + XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24, + XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25, + XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26, + XR_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27, + XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28, + XR_LIP_EXPRESSION_TONGUE_UP_HTC = 29, + XR_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30, + XR_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31, + XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32, + XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33, + XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34, + XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35, + XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36, + XR_LIP_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF +} XrLipExpressionHTC; + +typedef enum XrFacialTrackingTypeHTC { + XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1, + XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC = 2, + XR_FACIAL_TRACKING_TYPE_MAX_ENUM_HTC = 0x7FFFFFFF +} XrFacialTrackingTypeHTC; +// XrSystemFacialTrackingPropertiesHTC extends XrSystemProperties +typedef struct XrSystemFacialTrackingPropertiesHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportEyeFacialTracking; + XrBool32 supportLipFacialTracking; +} XrSystemFacialTrackingPropertiesHTC; + +typedef struct XrFacialExpressionsHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 isActive; + XrTime sampleTime; + uint32_t expressionCount; + float* expressionWeightings; +} XrFacialExpressionsHTC; + +typedef struct XrFacialTrackerCreateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFacialTrackingTypeHTC facialTrackingType; +} XrFacialTrackerCreateInfoHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialTrackerHTC)(XrSession session, const XrFacialTrackerCreateInfoHTC* createInfo, XrFacialTrackerHTC* facialTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC facialTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC* facialExpressions); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFacialTrackerHTC( + XrSession session, + const XrFacialTrackerCreateInfoHTC* createInfo, + XrFacialTrackerHTC* facialTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFacialTrackerHTC( + XrFacialTrackerHTC facialTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialExpressionsHTC( + XrFacialTrackerHTC facialTracker, + XrFacialExpressionsHTC* facialExpressions); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_HTC_vive_focus3_controller_interaction 1 +#define XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION 1 +#define XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_focus3_controller_interaction" + + #define XR_FB_color_space 1 -#define XR_FB_color_space_SPEC_VERSION 1 +#define XR_FB_color_space_SPEC_VERSION 2 #define XR_FB_COLOR_SPACE_EXTENSION_NAME "XR_FB_color_space" typedef enum XrColorSpaceFB { @@ -2875,6 +3121,7 @@ typedef enum XrColorSpaceFB { XR_COLOR_SPACE_ADOBE_RGB_FB = 7, XR_COLOR_SPACE_MAX_ENUM_FB = 0x7FFFFFFF } XrColorSpaceFB; +// XrSystemColorSpacePropertiesFB extends XrSystemProperties typedef struct XrSystemColorSpacePropertiesFB { XrStructureType type; void* XR_MAY_ALIAS next; @@ -2899,6 +3146,109 @@ XRAPI_ATTR XrResult XRAPI_CALL xrSetColorSpaceFB( #endif /* !XR_NO_PROTOTYPES */ +#define XR_FB_hand_tracking_mesh 1 +#define XR_FB_hand_tracking_mesh_SPEC_VERSION 1 +#define XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME "XR_FB_hand_tracking_mesh" +typedef struct XrVector4sFB { + int16_t x; + int16_t y; + int16_t z; + int16_t w; +} XrVector4sFB; + +typedef struct XrHandTrackingMeshFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t jointCapacityInput; + uint32_t jointCountOutput; + XrPosef* jointBindPoses; + float* jointRadii; + XrHandJointEXT* jointParents; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertexPositions; + XrVector3f* vertexNormals; + XrVector2f* vertexUVs; + XrVector4sFB* vertexBlendIndices; + XrVector4f* vertexBlendWeights; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + int16_t* indices; +} XrHandTrackingMeshFB; + +// XrHandTrackingScaleFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingScaleFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + float sensorOutput; + float currentOutput; + XrBool32 overrideHandScale; + float overrideValueInput; +} XrHandTrackingScaleFB; + +typedef XrResult (XRAPI_PTR *PFN_xrGetHandMeshFB)(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB* mesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetHandMeshFB( + XrHandTrackerEXT handTracker, + XrHandTrackingMeshFB* mesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_hand_tracking_aim 1 +#define XR_FB_hand_tracking_aim_SPEC_VERSION 1 +#define XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME "XR_FB_hand_tracking_aim" +typedef XrFlags64 XrHandTrackingAimFlagsFB; + +// Flag bits for XrHandTrackingAimFlagsFB +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB = 0x00000001; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_VALID_BIT_FB = 0x00000002; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB = 0x00000004; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB = 0x00000008; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB = 0x00000010; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB = 0x00000020; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB = 0x00000040; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB = 0x00000080; +static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB = 0x00000100; + +// XrHandTrackingAimStateFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingAimStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandTrackingAimFlagsFB status; + XrPosef aimPose; + float pinchStrengthIndex; + float pinchStrengthMiddle; + float pinchStrengthRing; + float pinchStrengthLittle; +} XrHandTrackingAimStateFB; + + + +#define XR_FB_hand_tracking_capsules 1 +#define XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB 2 +#define XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB +#define XR_HAND_TRACKING_CAPSULE_COUNT_FB 19 +#define XR_FB_HAND_TRACKING_CAPSULE_COUNT XR_HAND_TRACKING_CAPSULE_COUNT_FB +#define XR_FB_hand_tracking_capsules_SPEC_VERSION 2 +#define XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME "XR_FB_hand_tracking_capsules" +typedef struct XrHandCapsuleFB { + XrVector3f points[XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT]; + float radius; + XrHandJointEXT joint; +} XrHandCapsuleFB; + +// XrHandTrackingCapsulesStateFB extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingCapsulesStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandCapsuleFB capsules[XR_FB_HAND_TRACKING_CAPSULE_COUNT]; +} XrHandTrackingCapsulesStateFB; + + + #define XR_FB_foveation 1 XR_DEFINE_HANDLE(XrFoveationProfileFB) #define XR_FB_foveation_SPEC_VERSION 1 @@ -2976,6 +3326,377 @@ typedef struct XrFoveationLevelProfileCreateInfoFB { +#define XR_FB_keyboard_tracking 1 +#define XR_FB_keyboard_tracking_SPEC_VERSION 1 +#define XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME "XR_FB_keyboard_tracking" +#define XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB 128 +typedef XrFlags64 XrKeyboardTrackingFlagsFB; + +// Flag bits for XrKeyboardTrackingFlagsFB +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_EXISTS_BIT_FB = 0x00000001; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_LOCAL_BIT_FB = 0x00000002; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_REMOTE_BIT_FB = 0x00000004; +static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB = 0x00000008; + +typedef XrFlags64 XrKeyboardTrackingQueryFlagsFB; + +// Flag bits for XrKeyboardTrackingQueryFlagsFB +static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB = 0x00000002; +static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB = 0x00000004; + +// XrSystemKeyboardTrackingPropertiesFB extends XrSystemProperties +typedef struct XrSystemKeyboardTrackingPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsKeyboardTracking; +} XrSystemKeyboardTrackingPropertiesFB; + +typedef struct XrKeyboardTrackingDescriptionFB { + uint64_t trackedKeyboardId; + XrVector3f size; + XrKeyboardTrackingFlagsFB flags; + char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB]; +} XrKeyboardTrackingDescriptionFB; + +typedef struct XrKeyboardSpaceCreateInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint64_t trackedKeyboardId; +} XrKeyboardSpaceCreateInfoFB; + +typedef struct XrKeyboardTrackingQueryFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrKeyboardTrackingQueryFlagsFB flags; +} XrKeyboardTrackingQueryFB; + +typedef XrResult (XRAPI_PTR *PFN_xrQuerySystemTrackedKeyboardFB)(XrSession session, const XrKeyboardTrackingQueryFB* queryInfo, XrKeyboardTrackingDescriptionFB* keyboard); +typedef XrResult (XRAPI_PTR *PFN_xrCreateKeyboardSpaceFB)(XrSession session, const XrKeyboardSpaceCreateInfoFB* createInfo, XrSpace* keyboardSpace); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySystemTrackedKeyboardFB( + XrSession session, + const XrKeyboardTrackingQueryFB* queryInfo, + XrKeyboardTrackingDescriptionFB* keyboard); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateKeyboardSpaceFB( + XrSession session, + const XrKeyboardSpaceCreateInfoFB* createInfo, + XrSpace* keyboardSpace); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_triangle_mesh 1 +XR_DEFINE_HANDLE(XrTriangleMeshFB) +#define XR_FB_triangle_mesh_SPEC_VERSION 1 +#define XR_FB_TRIANGLE_MESH_EXTENSION_NAME "XR_FB_triangle_mesh" + +typedef enum XrWindingOrderFB { + XR_WINDING_ORDER_UNKNOWN_FB = 0, + XR_WINDING_ORDER_CW_FB = 1, + XR_WINDING_ORDER_CCW_FB = 2, + XR_WINDING_ORDER_MAX_ENUM_FB = 0x7FFFFFFF +} XrWindingOrderFB; +typedef XrFlags64 XrTriangleMeshFlagsFB; + +// Flag bits for XrTriangleMeshFlagsFB +static const XrTriangleMeshFlagsFB XR_TRIANGLE_MESH_MUTABLE_BIT_FB = 0x00000001; + +typedef struct XrTriangleMeshCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTriangleMeshFlagsFB flags; + XrWindingOrderFB windingOrder; + uint32_t vertexCount; + const XrVector3f* vertexBuffer; + uint32_t triangleCount; + const uint32_t* indexBuffer; +} XrTriangleMeshCreateInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateTriangleMeshFB)(XrSession session, const XrTriangleMeshCreateInfoFB* createInfo, XrTriangleMeshFB* outTriangleMesh); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyTriangleMeshFB)(XrTriangleMeshFB mesh); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB mesh, XrVector3f** outVertexBuffer); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB mesh, uint32_t** outIndexBuffer); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginUpdateFB)(XrTriangleMeshFB mesh); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndUpdateFB)(XrTriangleMeshFB mesh, uint32_t vertexCount, uint32_t triangleCount); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginVertexBufferUpdateFB)(XrTriangleMeshFB mesh, uint32_t* outVertexCount); +typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndVertexBufferUpdateFB)(XrTriangleMeshFB mesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateTriangleMeshFB( + XrSession session, + const XrTriangleMeshCreateInfoFB* createInfo, + XrTriangleMeshFB* outTriangleMesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTriangleMeshFB( + XrTriangleMeshFB mesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetVertexBufferFB( + XrTriangleMeshFB mesh, + XrVector3f** outVertexBuffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetIndexBufferFB( + XrTriangleMeshFB mesh, + uint32_t** outIndexBuffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginUpdateFB( + XrTriangleMeshFB mesh); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndUpdateFB( + XrTriangleMeshFB mesh, + uint32_t vertexCount, + uint32_t triangleCount); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginVertexBufferUpdateFB( + XrTriangleMeshFB mesh, + uint32_t* outVertexCount); + +XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndVertexBufferUpdateFB( + XrTriangleMeshFB mesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_passthrough 1 +XR_DEFINE_HANDLE(XrPassthroughFB) +XR_DEFINE_HANDLE(XrPassthroughLayerFB) +XR_DEFINE_HANDLE(XrGeometryInstanceFB) +#define XR_FB_passthrough_SPEC_VERSION 1 +#define XR_FB_PASSTHROUGH_EXTENSION_NAME "XR_FB_passthrough" +#define XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB 256 + +typedef enum XrPassthroughLayerPurposeFB { + XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB = 0, + XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB = 1, + XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB = 1000203001, + XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB = 0x7FFFFFFF +} XrPassthroughLayerPurposeFB; +typedef XrFlags64 XrPassthroughFlagsFB; + +// Flag bits for XrPassthroughFlagsFB +static const XrPassthroughFlagsFB XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB = 0x00000001; + +typedef XrFlags64 XrPassthroughStateChangedFlagsFB; + +// Flag bits for XrPassthroughStateChangedFlagsFB +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB = 0x00000001; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB = 0x00000002; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB = 0x00000004; +static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB = 0x00000008; + +// XrSystemPassthroughPropertiesFB extends XrSystemProperties +typedef struct XrSystemPassthroughPropertiesFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsPassthrough; +} XrSystemPassthroughPropertiesFB; + +typedef struct XrPassthroughCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughFlagsFB flags; +} XrPassthroughCreateInfoFB; + +typedef struct XrPassthroughLayerCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughFB passthrough; + XrPassthroughFlagsFB flags; + XrPassthroughLayerPurposeFB purpose; +} XrPassthroughLayerCreateInfoFB; + +// XrCompositionLayerPassthroughFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerPassthroughFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags flags; + XrSpace space; + XrPassthroughLayerFB layerHandle; +} XrCompositionLayerPassthroughFB; + +typedef struct XrGeometryInstanceCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughLayerFB layer; + XrTriangleMeshFB mesh; + XrSpace baseSpace; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceCreateInfoFB; + +typedef struct XrGeometryInstanceTransformFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceTransformFB; + +typedef struct XrPassthroughStyleFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float textureOpacityFactor; + XrColor4f edgeColor; +} XrPassthroughStyleFB; + +typedef struct XrPassthroughColorMapMonoToRgbaFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToRgbaFB; + +typedef struct XrPassthroughColorMapMonoToMonoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToMonoFB; + +typedef struct XrEventDataPassthroughStateChangedFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughStateChangedFlagsFB flags; +} XrEventDataPassthroughStateChangedFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughFB)(XrSession session, const XrPassthroughCreateInfoFB* createInfo, XrPassthroughFB* outPassthrough); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughStartFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughPauseFB)(XrPassthroughFB passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerFB)(XrSession session, const XrPassthroughLayerCreateInfoFB* createInfo, XrPassthroughLayerFB* outLayer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerPauseFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerResumeFB)(XrPassthroughLayerFB layer); +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetStyleFB)(XrPassthroughLayerFB layer, const XrPassthroughStyleFB* style); +typedef XrResult (XRAPI_PTR *PFN_xrCreateGeometryInstanceFB)(XrSession session, const XrGeometryInstanceCreateInfoFB* createInfo, XrGeometryInstanceFB* outGeometryInstance); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB instance); +typedef XrResult (XRAPI_PTR *PFN_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB* transformation); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughFB( + XrSession session, + const XrPassthroughCreateInfoFB* createInfo, + XrPassthroughFB* outPassthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughStartFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughPauseFB( + XrPassthroughFB passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughLayerFB( + XrSession session, + const XrPassthroughLayerCreateInfoFB* createInfo, + XrPassthroughLayerFB* outLayer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughLayerFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerPauseFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerResumeFB( + XrPassthroughLayerFB layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetStyleFB( + XrPassthroughLayerFB layer, + const XrPassthroughStyleFB* style); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeometryInstanceFB( + XrSession session, + const XrGeometryInstanceCreateInfoFB* createInfo, + XrGeometryInstanceFB* outGeometryInstance); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyGeometryInstanceFB( + XrGeometryInstanceFB instance); + +XRAPI_ATTR XrResult XRAPI_CALL xrGeometryInstanceSetTransformFB( + XrGeometryInstanceFB instance, + const XrGeometryInstanceTransformFB* transformation); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_render_model 1 + +#define XR_NULL_RENDER_MODEL_KEY_FB 0 + +XR_DEFINE_ATOM(XrRenderModelKeyFB) +#define XR_FB_render_model_SPEC_VERSION 1 +#define XR_FB_RENDER_MODEL_EXTENSION_NAME "XR_FB_render_model" +#define XR_MAX_RENDER_MODEL_NAME_SIZE_FB 64 +typedef XrFlags64 XrRenderModelFlagsFB; + +// Flag bits for XrRenderModelFlagsFB + +typedef struct XrRenderModelPathInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPath path; +} XrRenderModelPathInfoFB; + +typedef struct XrRenderModelPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vendorId; + char modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB]; + XrRenderModelKeyFB modelKey; + uint32_t modelVersion; + XrRenderModelFlagsFB flags; +} XrRenderModelPropertiesFB; + +typedef struct XrRenderModelBufferFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + uint8_t* buffer; +} XrRenderModelBufferFB; + +typedef struct XrRenderModelLoadInfoFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrRenderModelKeyFB modelKey; +} XrRenderModelLoadInfoFB; + +// XrSystemRenderModelPropertiesFB extends XrSystemProperties +typedef struct XrSystemRenderModelPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsRenderModelLoading; +} XrSystemRenderModelPropertiesFB; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelPathsFB)(XrSession session, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrRenderModelPathInfoFB* paths); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesFB)(XrSession session, XrPath path, XrRenderModelPropertiesFB* properties); +typedef XrResult (XRAPI_PTR *PFN_xrLoadRenderModelFB)(XrSession session, const XrRenderModelLoadInfoFB* info, XrRenderModelBufferFB* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRenderModelPathsFB( + XrSession session, + uint32_t pathCapacityInput, + uint32_t* pathCountOutput, + XrRenderModelPathInfoFB* paths); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPropertiesFB( + XrSession session, + XrPath path, + XrRenderModelPropertiesFB* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrLoadRenderModelFB( + XrSession session, + const XrRenderModelLoadInfoFB* info, + XrRenderModelBufferFB* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + #define XR_VARJO_foveated_rendering 1 #define XR_VARJO_foveated_rendering_SPEC_VERSION 2 #define XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME "XR_VARJO_foveated_rendering" @@ -3029,6 +3750,67 @@ XRAPI_ATTR XrResult XRAPI_CALL xrSetEnvironmentDepthEstimationVARJO( #endif /* !XR_NO_PROTOTYPES */ +#define XR_VARJO_marker_tracking 1 +#define XR_VARJO_marker_tracking_SPEC_VERSION 1 +#define XR_VARJO_MARKER_TRACKING_EXTENSION_NAME "XR_VARJO_marker_tracking" +// XrSystemMarkerTrackingPropertiesVARJO extends XrSystemProperties +typedef struct XrSystemMarkerTrackingPropertiesVARJO { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsMarkerTracking; +} XrSystemMarkerTrackingPropertiesVARJO; + +typedef struct XrEventDataMarkerTrackingUpdateVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint64_t markerId; + XrBool32 isActive; + XrBool32 isPredicted; + XrTime time; +} XrEventDataMarkerTrackingUpdateVARJO; + +typedef struct XrMarkerSpaceCreateInfoVARJO { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint64_t markerId; + XrPosef poseInMarkerSpace; +} XrMarkerSpaceCreateInfoVARJO; + +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingVARJO)(XrSession session, XrBool32 enabled); +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingTimeoutVARJO)(XrSession session, uint64_t markerId, XrDuration timeout); +typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingPredictionVARJO)(XrSession session, uint64_t markerId, XrBool32 enabled); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerSizeVARJO)(XrSession session, uint64_t markerId, XrExtent2Df* size); +typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceVARJO)(XrSession session, const XrMarkerSpaceCreateInfoVARJO* createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingVARJO( + XrSession session, + XrBool32 enabled); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingTimeoutVARJO( + XrSession session, + uint64_t markerId, + XrDuration timeout); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingPredictionVARJO( + XrSession session, + uint64_t markerId, + XrBool32 enabled); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerSizeVARJO( + XrSession session, + uint64_t markerId, + XrExtent2Df* size); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerSpaceVARJO( + XrSession session, + const XrMarkerSpaceCreateInfoVARJO* createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + #define XR_MSFT_spatial_anchor_persistence 1 XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT) #define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT 256 @@ -3057,7 +3839,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSp typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo); typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNamesCapacityInput, uint32_t* spatialAnchorNamesCountOutput, XrSpatialAnchorPersistenceNameMSFT* persistedAnchorNames); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, XrSpatialAnchorMSFT* spatialAnchor); -typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName); typedef XrResult (XRAPI_PTR *PFN_xrClearSpatialAnchorStoreMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); #ifndef XR_NO_PROTOTYPES @@ -3093,6 +3875,93 @@ XRAPI_ATTR XrResult XRAPI_CALL xrClearSpatialAnchorStoreMSFT( #endif /* XR_EXTENSION_PROTOTYPES */ #endif /* !XR_NO_PROTOTYPES */ + +#define XR_FB_space_warp 1 +#define XR_FB_space_warp_SPEC_VERSION 1 +#define XR_FB_SPACE_WARP_EXTENSION_NAME "XR_FB_space_warp" +typedef XrFlags64 XrCompositionLayerSpaceWarpInfoFlagsFB; + +// Flag bits for XrCompositionLayerSpaceWarpInfoFlagsFB + +// XrCompositionLayerSpaceWarpInfoFB extends XrCompositionLayerProjectionView +typedef struct XrCompositionLayerSpaceWarpInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerSpaceWarpInfoFlagsFB layerFlags; + XrSwapchainSubImage motionVectorSubImage; + XrPosef appSpaceDeltaPose; + XrSwapchainSubImage depthSubImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrCompositionLayerSpaceWarpInfoFB; + +// XrSystemSpaceWarpPropertiesFB extends XrSystemProperties +typedef struct XrSystemSpaceWarpPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t recommendedMotionVectorImageRectWidth; + uint32_t recommendedMotionVectorImageRectHeight; +} XrSystemSpaceWarpPropertiesFB; + + + +#define XR_ALMALENCE_digital_lens_control 1 +#define XR_ALMALENCE_digital_lens_control_SPEC_VERSION 1 +#define XR_ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME "XR_ALMALENCE_digital_lens_control" +typedef XrFlags64 XrDigitalLensControlFlagsALMALENCE; + +// Flag bits for XrDigitalLensControlFlagsALMALENCE +static const XrDigitalLensControlFlagsALMALENCE XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE = 0x00000001; + +typedef struct XrDigitalLensControlALMALENCE { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDigitalLensControlFlagsALMALENCE flags; +} XrDigitalLensControlALMALENCE; + +typedef XrResult (XRAPI_PTR *PFN_xrSetDigitalLensControlALMALENCE)(XrSession session, const XrDigitalLensControlALMALENCE* digitalLensControl); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetDigitalLensControlALMALENCE( + XrSession session, + const XrDigitalLensControlALMALENCE* digitalLensControl); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_FB_passthrough_keyboard_hands 1 +#define XR_FB_passthrough_keyboard_hands_SPEC_VERSION 1 +#define XR_FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME "XR_FB_passthrough_keyboard_hands" +typedef struct XrPassthroughKeyboardHandsIntensityFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float leftHandIntensity; + float rightHandIntensity; +} XrPassthroughKeyboardHandsIntensityFB; + +typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetKeyboardHandsIntensityFB)(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB* intensity); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetKeyboardHandsIntensityFB( + XrPassthroughLayerFB layer, + const XrPassthroughKeyboardHandsIntensityFB* intensity); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +#define XR_EXT_uuid 1 +#define XR_EXT_uuid_SPEC_VERSION 1 +#define XR_EXT_UUID_EXTENSION_NAME "XR_EXT_uuid" +#define XR_UUID_SIZE_EXT 16 +typedef struct XrUuidEXT { + uint8_t data[XR_UUID_SIZE_EXT]; +} XrUuidEXT; + + #ifdef __cplusplus } #endif diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform.h index 8f8427f..49eea18 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform.h @@ -2,7 +2,7 @@ #define OPENXR_PLATFORM_H_ 1 /* -** Copyright (c) 2017-2021, The Khronos Group Inc. +** Copyright (c) 2017-2022, The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 OR MIT */ @@ -94,7 +94,7 @@ typedef struct XrVulkanSwapchainFormatListCreateInfoKHR { #ifdef XR_USE_GRAPHICS_API_OPENGL #define XR_KHR_opengl_enable 1 -#define XR_KHR_opengl_enable_SPEC_VERSION 9 +#define XR_KHR_opengl_enable_SPEC_VERSION 10 #define XR_KHR_OPENGL_ENABLE_EXTENSION_NAME "XR_KHR_opengl_enable" #ifdef XR_USE_PLATFORM_WIN32 // XrGraphicsBindingOpenGLWin32KHR extends XrSessionCreateInfo @@ -170,7 +170,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLGraphicsRequirementsKHR( #ifdef XR_USE_GRAPHICS_API_OPENGL_ES #define XR_KHR_opengl_es_enable 1 -#define XR_KHR_opengl_es_enable_SPEC_VERSION 7 +#define XR_KHR_opengl_es_enable_SPEC_VERSION 8 #define XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME "XR_KHR_opengl_es_enable" #ifdef XR_USE_PLATFORM_ANDROID // XrGraphicsBindingOpenGLESAndroidKHR extends XrSessionCreateInfo @@ -275,7 +275,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirementsKHR( #ifdef XR_USE_GRAPHICS_API_D3D11 #define XR_KHR_D3D11_enable 1 -#define XR_KHR_D3D11_enable_SPEC_VERSION 5 +#define XR_KHR_D3D11_enable_SPEC_VERSION 8 #define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable" // XrGraphicsBindingD3D11KHR extends XrSessionCreateInfo typedef struct XrGraphicsBindingD3D11KHR { @@ -285,7 +285,7 @@ typedef struct XrGraphicsBindingD3D11KHR { } XrGraphicsBindingD3D11KHR; typedef struct XrSwapchainImageD3D11KHR { - XrStructureType type; + XrStructureType type; void* XR_MAY_ALIAS next; ID3D11Texture2D* texture; } XrSwapchainImageD3D11KHR; @@ -312,7 +312,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D11GraphicsRequirementsKHR( #ifdef XR_USE_GRAPHICS_API_D3D12 #define XR_KHR_D3D12_enable 1 -#define XR_KHR_D3D12_enable_SPEC_VERSION 7 +#define XR_KHR_D3D12_enable_SPEC_VERSION 8 #define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable" // XrGraphicsBindingD3D12KHR extends XrSessionCreateInfo typedef struct XrGraphicsBindingD3D12KHR { @@ -323,7 +323,7 @@ typedef struct XrGraphicsBindingD3D12KHR { } XrGraphicsBindingD3D12KHR; typedef struct XrSwapchainImageD3D12KHR { - XrStructureType type; + XrStructureType type; void* XR_MAY_ALIAS next; ID3D12Resource* texture; } XrSwapchainImageD3D12KHR; @@ -353,7 +353,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D12GraphicsRequirementsKHR( #define XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION 1 #define XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME "XR_KHR_win32_convert_performance_counter_time" typedef XrResult (XRAPI_PTR *PFN_xrConvertWin32PerformanceCounterToTimeKHR)(XrInstance instance, const LARGE_INTEGER* performanceCounter, XrTime* time); -typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToWin32PerformanceCounterKHR)(XrInstance instance, XrTime time, LARGE_INTEGER* performanceCounter); +typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToWin32PerformanceCounterKHR)(XrInstance instance, XrTime time, LARGE_INTEGER* performanceCounter); #ifndef XR_NO_PROTOTYPES #ifdef XR_EXTENSION_PROTOTYPES @@ -376,7 +376,7 @@ XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToWin32PerformanceCounterKHR( #define XR_KHR_convert_timespec_time_SPEC_VERSION 1 #define XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME "XR_KHR_convert_timespec_time" typedef XrResult (XRAPI_PTR *PFN_xrConvertTimespecTimeToTimeKHR)(XrInstance instance, const struct timespec* timespecTime, XrTime* time); -typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToTimespecTimeKHR)(XrInstance instance, XrTime time, struct timespec* timespecTime); +typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToTimespecTimeKHR)(XrInstance instance, XrTime time, struct timespec* timespecTime); #ifndef XR_NO_PROTOTYPES #ifdef XR_EXTENSION_PROTOTYPES @@ -454,9 +454,9 @@ typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR; typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR; -typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance instance, const XrVulkanInstanceCreateInfoKHR*createInfo, VkInstance* vulkanInstance, VkResult* vulkanResult); -typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance instance, const XrVulkanDeviceCreateInfoKHR* createInfo, VkDevice* vulkanDevice, VkResult* vulkanResult); -typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDevice2KHR)(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, VkPhysicalDevice* vulkanPhysicalDevice); +typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance instance, const XrVulkanInstanceCreateInfoKHR* createInfo, VkInstance* vulkanInstance, VkResult* vulkanResult); +typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance instance, const XrVulkanDeviceCreateInfoKHR* createInfo, VkDevice* vulkanDevice, VkResult* vulkanResult); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDevice2KHR)(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, VkPhysicalDevice* vulkanPhysicalDevice); typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirements2KHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements); #ifndef XR_NO_PROTOTYPES diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform_defines.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform_defines.h index a7ffcb4..31fa05a 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform_defines.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_platform_defines.h @@ -1,5 +1,5 @@ /* -** Copyright (c) 2017-2021, The Khronos Group Inc. +** Copyright (c) 2017-2022, The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 OR MIT */ diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_reflection.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_reflection.h index 59f2774..e1d5b49 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_reflection.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/External/openxr/openxr_reflection.h @@ -2,7 +2,7 @@ #define OPENXR_REFLECTION_H_ 1 /* -** Copyright (c) 2017-2021, The Khronos Group Inc. +** Copyright (c) 2017-2022, The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 OR MIT */ @@ -100,6 +100,16 @@ XR_ENUM_STR(XrResult); _(XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT, -1000097005) \ _(XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB, -1000101000) \ _(XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB, -1000108000) \ + _(XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB, -1000118000) \ + _(XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB, -1000118001) \ + _(XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB, -1000118002) \ + _(XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB, -1000118003) \ + _(XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB, -1000118004) \ + _(XR_ERROR_UNKNOWN_PASSTHROUGH_FB, -1000118050) \ + _(XR_ERROR_RENDER_MODEL_KEY_INVALID_FB, -1000119000) \ + _(XR_RENDER_MODEL_UNAVAILABLE_FB, 1000119020) \ + _(XR_ERROR_MARKER_NOT_TRACKED_VARJO, -1000124000) \ + _(XR_ERROR_MARKER_ID_INVALID_VARJO, -1000124001) \ _(XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT, -1000142001) \ _(XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT, -1000142002) \ _(XR_RESULT_MAX_ENUM, 0x7FFFFFFF) @@ -197,7 +207,6 @@ XR_ENUM_STR(XrResult); _(XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB, 1000041001) \ _(XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT, 1000046000) \ _(XR_TYPE_GRAPHICS_BINDING_EGL_MNDX, 1000048004) \ - _(XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT, 1000049000) \ _(XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT, 1000051000) \ _(XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT, 1000051001) \ _(XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT, 1000051002) \ @@ -254,22 +263,61 @@ XR_ENUM_STR(XrResult); _(XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT, 1000098000) \ _(XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT, 1000098001) \ _(XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB, 1000101000) \ + _(XR_TYPE_VIVE_TRACKER_PATHS_HTCX, 1000103000) \ + _(XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX, 1000103001) \ + _(XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC, 1000104000) \ + _(XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC, 1000104001) \ + _(XR_TYPE_FACIAL_EXPRESSIONS_HTC, 1000104002) \ _(XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB, 1000108000) \ + _(XR_TYPE_HAND_TRACKING_MESH_FB, 1000110001) \ + _(XR_TYPE_HAND_TRACKING_SCALE_FB, 1000110003) \ + _(XR_TYPE_HAND_TRACKING_AIM_STATE_FB, 1000111001) \ + _(XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB, 1000112000) \ _(XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB, 1000114000) \ _(XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB, 1000114001) \ _(XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB, 1000114002) \ _(XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB, 1000115000) \ + _(XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB, 1000116009) \ + _(XR_TYPE_KEYBOARD_TRACKING_QUERY_FB, 1000116004) \ + _(XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB, 1000116002) \ + _(XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB, 1000117001) \ + _(XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB, 1000118000) \ + _(XR_TYPE_PASSTHROUGH_CREATE_INFO_FB, 1000118001) \ + _(XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB, 1000118002) \ + _(XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB, 1000118003) \ + _(XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB, 1000118004) \ + _(XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB, 1000118005) \ + _(XR_TYPE_PASSTHROUGH_STYLE_FB, 1000118020) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB, 1000118021) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB, 1000118022) \ + _(XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB, 1000118030) \ + _(XR_TYPE_RENDER_MODEL_PATH_INFO_FB, 1000119000) \ + _(XR_TYPE_RENDER_MODEL_PROPERTIES_FB, 1000119001) \ + _(XR_TYPE_RENDER_MODEL_BUFFER_FB, 1000119002) \ + _(XR_TYPE_RENDER_MODEL_LOAD_INFO_FB, 1000119003) \ + _(XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB, 1000119004) \ _(XR_TYPE_BINDING_MODIFICATIONS_KHR, 1000120000) \ _(XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO, 1000121000) \ _(XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO, 1000121001) \ _(XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO, 1000121002) \ _(XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO, 1000122000) \ + _(XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO, 1000124000) \ + _(XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO, 1000124001) \ + _(XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO, 1000124002) \ _(XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT, 1000142000) \ _(XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT, 1000142001) \ _(XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB, 1000160000) \ _(XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB, 1000161000) \ _(XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB, 1000162000) \ _(XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB, 1000163000) \ + _(XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB, 1000171000) \ + _(XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB, 1000171001) \ + _(XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE, 1000196000) \ + _(XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB, 1000203002) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT, 1000049000) \ + _(XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT, 1000049001) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT, 1000049002) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT, 1000049003) \ _(XR_STRUCTURE_TYPE_MAX_ENUM, 0x7FFFFFFF) #define XR_LIST_ENUM_XrFormFactor(_) \ @@ -337,8 +385,14 @@ XR_ENUM_STR(XrResult); _(XR_OBJECT_TYPE_HAND_TRACKER_EXT, 1000051000) \ _(XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT, 1000097000) \ _(XR_OBJECT_TYPE_SCENE_MSFT, 1000097001) \ + _(XR_OBJECT_TYPE_FACIAL_TRACKER_HTC, 1000104000) \ _(XR_OBJECT_TYPE_FOVEATION_PROFILE_FB, 1000114000) \ + _(XR_OBJECT_TYPE_TRIANGLE_MESH_FB, 1000117000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_FB, 1000118000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB, 1000118002) \ + _(XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB, 1000118004) \ _(XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT, 1000142000) \ + _(XR_OBJECT_TYPE_SPATIAL_GRAPH_NODE_BINDING_MSFT, 1000049000) \ _(XR_OBJECT_TYPE_MAX_ENUM, 0x7FFFFFFF) #define XR_LIST_ENUM_XrAndroidThreadTypeKHR(_) \ @@ -500,6 +554,68 @@ XR_ENUM_STR(XrResult); _(XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT, 3) \ _(XR_SCENE_COMPUTE_STATE_MAX_ENUM_MSFT, 0x7FFFFFFF) +#define XR_LIST_ENUM_XrEyeExpressionHTC(_) \ + _(XR_EYE_EXPRESSION_LEFT_BLINK_HTC, 0) \ + _(XR_EYE_EXPRESSION_LEFT_WIDE_HTC, 1) \ + _(XR_EYE_EXPRESSION_RIGHT_BLINK_HTC, 2) \ + _(XR_EYE_EXPRESSION_RIGHT_WIDE_HTC, 3) \ + _(XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC, 4) \ + _(XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC, 5) \ + _(XR_EYE_EXPRESSION_LEFT_DOWN_HTC, 6) \ + _(XR_EYE_EXPRESSION_RIGHT_DOWN_HTC, 7) \ + _(XR_EYE_EXPRESSION_LEFT_OUT_HTC, 8) \ + _(XR_EYE_EXPRESSION_RIGHT_IN_HTC, 9) \ + _(XR_EYE_EXPRESSION_LEFT_IN_HTC, 10) \ + _(XR_EYE_EXPRESSION_RIGHT_OUT_HTC, 11) \ + _(XR_EYE_EXPRESSION_LEFT_UP_HTC, 12) \ + _(XR_EYE_EXPRESSION_RIGHT_UP_HTC, 13) \ + _(XR_EYE_EXPRESSION_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLipExpressionHTC(_) \ + _(XR_LIP_EXPRESSION_JAW_RIGHT_HTC, 0) \ + _(XR_LIP_EXPRESSION_JAW_LEFT_HTC, 1) \ + _(XR_LIP_EXPRESSION_JAW_FORWARD_HTC, 2) \ + _(XR_LIP_EXPRESSION_JAW_OPEN_HTC, 3) \ + _(XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC, 4) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC, 5) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC, 6) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC, 7) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC, 8) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC, 9) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC, 10) \ + _(XR_LIP_EXPRESSION_MOUTH_POUT_HTC, 11) \ + _(XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC, 12) \ + _(XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC, 13) \ + _(XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC, 14) \ + _(XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC, 15) \ + _(XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC, 16) \ + _(XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC, 17) \ + _(XR_LIP_EXPRESSION_CHEEK_SUCK_HTC, 18) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC, 19) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC, 20) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC, 21) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC, 22) \ + _(XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC, 23) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC, 24) \ + _(XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC, 25) \ + _(XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC, 26) \ + _(XR_LIP_EXPRESSION_TONGUE_LEFT_HTC, 27) \ + _(XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC, 28) \ + _(XR_LIP_EXPRESSION_TONGUE_UP_HTC, 29) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWN_HTC, 30) \ + _(XR_LIP_EXPRESSION_TONGUE_ROLL_HTC, 31) \ + _(XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC, 32) \ + _(XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC, 33) \ + _(XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC, 34) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC, 35) \ + _(XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC, 36) \ + _(XR_LIP_EXPRESSION_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFacialTrackingTypeHTC(_) \ + _(XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC, 1) \ + _(XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC, 2) \ + _(XR_FACIAL_TRACKING_TYPE_MAX_ENUM_HTC, 0x7FFFFFFF) + #define XR_LIST_ENUM_XrColorSpaceFB(_) \ _(XR_COLOR_SPACE_UNMANAGED_FB, 0) \ _(XR_COLOR_SPACE_REC2020_FB, 1) \ @@ -523,6 +639,18 @@ XR_ENUM_STR(XrResult); _(XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB, 1) \ _(XR_FOVEATION_DYNAMIC_MAX_ENUM_FB, 0x7FFFFFFF) +#define XR_LIST_ENUM_XrWindingOrderFB(_) \ + _(XR_WINDING_ORDER_UNKNOWN_FB, 0) \ + _(XR_WINDING_ORDER_CW_FB, 1) \ + _(XR_WINDING_ORDER_CCW_FB, 2) \ + _(XR_WINDING_ORDER_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPassthroughLayerPurposeFB(_) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB, 0) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB, 1) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB, 1000203001) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB, 0x7FFFFFFF) + #define XR_LIST_BITS_XrInstanceCreateFlags(_) #define XR_LIST_BITS_XrSessionCreateFlags(_) @@ -600,12 +728,52 @@ XR_ENUM_STR(XrResult); _(XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB, 0x00000001) \ _(XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB, 0x00000002) \ +#define XR_LIST_BITS_XrHandTrackingAimFlagsFB(_) \ + _(XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB, 0x00000001) \ + _(XR_HAND_TRACKING_AIM_VALID_BIT_FB, 0x00000002) \ + _(XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB, 0x00000004) \ + _(XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB, 0x00000008) \ + _(XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB, 0x00000010) \ + _(XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB, 0x00000020) \ + _(XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB, 0x00000040) \ + _(XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB, 0x00000080) \ + _(XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB, 0x00000100) \ + #define XR_LIST_BITS_XrSwapchainCreateFoveationFlagsFB(_) \ _(XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB, 0x00000001) \ _(XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB, 0x00000002) \ #define XR_LIST_BITS_XrSwapchainStateFoveationFlagsFB(_) +#define XR_LIST_BITS_XrKeyboardTrackingFlagsFB(_) \ + _(XR_KEYBOARD_TRACKING_EXISTS_BIT_FB, 0x00000001) \ + _(XR_KEYBOARD_TRACKING_LOCAL_BIT_FB, 0x00000002) \ + _(XR_KEYBOARD_TRACKING_REMOTE_BIT_FB, 0x00000004) \ + _(XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB, 0x00000008) \ + +#define XR_LIST_BITS_XrKeyboardTrackingQueryFlagsFB(_) \ + _(XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB, 0x00000002) \ + _(XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB, 0x00000004) \ + +#define XR_LIST_BITS_XrTriangleMeshFlagsFB(_) \ + _(XR_TRIANGLE_MESH_MUTABLE_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrPassthroughFlagsFB(_) \ + _(XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrPassthroughStateChangedFlagsFB(_) \ + _(XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB, 0x00000001) \ + _(XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB, 0x00000002) \ + _(XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB, 0x00000004) \ + _(XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB, 0x00000008) \ + +#define XR_LIST_BITS_XrRenderModelFlagsFB(_) + +#define XR_LIST_BITS_XrCompositionLayerSpaceWarpInfoFlagsFB(_) + +#define XR_LIST_BITS_XrDigitalLensControlFlagsALMALENCE(_) \ + _(XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE, 0x00000001) \ + #define XR_LIST_STRUCT_XrApiLayerProperties(_) \ _(type) \ _(next) \ @@ -1404,6 +1572,23 @@ XR_ENUM_STR(XrResult); _(nodeId) \ _(pose) \ +#define XR_LIST_STRUCT_XrSpatialGraphStaticNodeBindingCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(space) \ + _(poseInSpace) \ + _(time) \ + +#define XR_LIST_STRUCT_XrSpatialGraphNodeBindingPropertiesGetInfoMSFT(_) \ + _(type) \ + _(next) \ + +#define XR_LIST_STRUCT_XrSpatialGraphNodeBindingPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(nodeId) \ + _(poseInNodeSpace) \ + #define XR_LIST_STRUCT_XrSystemHandTrackingPropertiesEXT(_) \ _(type) \ _(next) \ @@ -1795,11 +1980,94 @@ XR_ENUM_STR(XrResult); _(fromDisplayRefreshRate) \ _(toDisplayRefreshRate) \ +#define XR_LIST_STRUCT_XrViveTrackerPathsHTCX(_) \ + _(type) \ + _(next) \ + _(persistentPath) \ + _(rolePath) \ + +#define XR_LIST_STRUCT_XrEventDataViveTrackerConnectedHTCX(_) \ + _(type) \ + _(next) \ + _(paths) \ + +#define XR_LIST_STRUCT_XrSystemFacialTrackingPropertiesHTC(_) \ + _(type) \ + _(next) \ + _(supportEyeFacialTracking) \ + _(supportLipFacialTracking) \ + +#define XR_LIST_STRUCT_XrFacialExpressionsHTC(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(sampleTime) \ + _(expressionCount) \ + _(expressionWeightings) \ + +#define XR_LIST_STRUCT_XrFacialTrackerCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(facialTrackingType) \ + #define XR_LIST_STRUCT_XrSystemColorSpacePropertiesFB(_) \ _(type) \ _(next) \ _(colorSpace) \ +#define XR_LIST_STRUCT_XrVector4sFB(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +#define XR_LIST_STRUCT_XrHandTrackingMeshFB(_) \ + _(type) \ + _(next) \ + _(jointCapacityInput) \ + _(jointCountOutput) \ + _(jointBindPoses) \ + _(jointRadii) \ + _(jointParents) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertexPositions) \ + _(vertexNormals) \ + _(vertexUVs) \ + _(vertexBlendIndices) \ + _(vertexBlendWeights) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +#define XR_LIST_STRUCT_XrHandTrackingScaleFB(_) \ + _(type) \ + _(next) \ + _(sensorOutput) \ + _(currentOutput) \ + _(overrideHandScale) \ + _(overrideValueInput) \ + +#define XR_LIST_STRUCT_XrHandTrackingAimStateFB(_) \ + _(type) \ + _(next) \ + _(status) \ + _(aimPose) \ + _(pinchStrengthIndex) \ + _(pinchStrengthMiddle) \ + _(pinchStrengthRing) \ + _(pinchStrengthLittle) \ + +#define XR_LIST_STRUCT_XrHandCapsuleFB(_) \ + _(points) \ + _(radius) \ + _(joint) \ + +#define XR_LIST_STRUCT_XrHandTrackingCapsulesStateFB(_) \ + _(type) \ + _(next) \ + _(capsules) \ + #define XR_LIST_STRUCT_XrFoveationProfileCreateInfoFB(_) \ _(type) \ _(next) \ @@ -1822,6 +2090,130 @@ XR_ENUM_STR(XrResult); _(verticalOffset) \ _(dynamic) \ +#define XR_LIST_STRUCT_XrSystemKeyboardTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsKeyboardTracking) \ + +#define XR_LIST_STRUCT_XrKeyboardTrackingDescriptionFB(_) \ + _(trackedKeyboardId) \ + _(size) \ + _(flags) \ + _(name) \ + +#define XR_LIST_STRUCT_XrKeyboardSpaceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(trackedKeyboardId) \ + +#define XR_LIST_STRUCT_XrKeyboardTrackingQueryFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrTriangleMeshCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(windingOrder) \ + _(vertexCount) \ + _(vertexBuffer) \ + _(triangleCount) \ + _(indexBuffer) \ + +#define XR_LIST_STRUCT_XrSystemPassthroughPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsPassthrough) \ + +#define XR_LIST_STRUCT_XrPassthroughCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrPassthroughLayerCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(passthrough) \ + _(flags) \ + _(purpose) \ + +#define XR_LIST_STRUCT_XrCompositionLayerPassthroughFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(space) \ + _(layerHandle) \ + +#define XR_LIST_STRUCT_XrGeometryInstanceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(layer) \ + _(mesh) \ + _(baseSpace) \ + _(pose) \ + _(scale) \ + +#define XR_LIST_STRUCT_XrGeometryInstanceTransformFB(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(pose) \ + _(scale) \ + +#define XR_LIST_STRUCT_XrPassthroughStyleFB(_) \ + _(type) \ + _(next) \ + _(textureOpacityFactor) \ + _(edgeColor) \ + +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToRgbaFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToMonoFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +#define XR_LIST_STRUCT_XrEventDataPassthroughStateChangedFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrRenderModelPathInfoFB(_) \ + _(type) \ + _(next) \ + _(path) \ + +#define XR_LIST_STRUCT_XrRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(vendorId) \ + _(modelName) \ + _(modelKey) \ + _(modelVersion) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrRenderModelBufferFB(_) \ + _(type) \ + _(next) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +#define XR_LIST_STRUCT_XrRenderModelLoadInfoFB(_) \ + _(type) \ + _(next) \ + _(modelKey) \ + +#define XR_LIST_STRUCT_XrSystemRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsRenderModelLoading) \ + #define XR_LIST_STRUCT_XrViewLocateFoveatedRenderingVARJO(_) \ _(type) \ _(next) \ @@ -1843,6 +2235,25 @@ XR_ENUM_STR(XrResult); _(depthTestRangeNearZ) \ _(depthTestRangeFarZ) \ +#define XR_LIST_STRUCT_XrSystemMarkerTrackingPropertiesVARJO(_) \ + _(type) \ + _(next) \ + _(supportsMarkerTracking) \ + +#define XR_LIST_STRUCT_XrEventDataMarkerTrackingUpdateVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(isActive) \ + _(isPredicted) \ + _(time) \ + +#define XR_LIST_STRUCT_XrMarkerSpaceCreateInfoVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(poseInMarkerSpace) \ + #define XR_LIST_STRUCT_XrSpatialAnchorPersistenceNameMSFT(_) \ _(name) \ @@ -1900,6 +2311,38 @@ XR_ENUM_STR(XrResult); _(maxAnisotropy) \ _(borderColor) \ +#define XR_LIST_STRUCT_XrCompositionLayerSpaceWarpInfoFB(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(motionVectorSubImage) \ + _(appSpaceDeltaPose) \ + _(depthSubImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +#define XR_LIST_STRUCT_XrSystemSpaceWarpPropertiesFB(_) \ + _(type) \ + _(next) \ + _(recommendedMotionVectorImageRectWidth) \ + _(recommendedMotionVectorImageRectHeight) \ + +#define XR_LIST_STRUCT_XrDigitalLensControlALMALENCE(_) \ + _(type) \ + _(next) \ + _(flags) \ + +#define XR_LIST_STRUCT_XrPassthroughKeyboardHandsIntensityFB(_) \ + _(type) \ + _(next) \ + _(leftHandIntensity) \ + _(rightHandIntensity) \ + +#define XR_LIST_STRUCT_XrUuidEXT(_) \ + _(data) \ + #define XR_LIST_STRUCTURE_TYPES_CORE(_) \ @@ -1976,6 +2419,9 @@ XR_ENUM_STR(XrResult); _(XrCompositionLayerAlphaBlendFB, XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB) \ _(XrViewConfigurationDepthRangeEXT, XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT) \ _(XrSpatialGraphNodeSpaceCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT) \ + _(XrSpatialGraphStaticNodeBindingCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT) \ + _(XrSpatialGraphNodeBindingPropertiesGetInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT) \ + _(XrSpatialGraphNodeBindingPropertiesMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT) \ _(XrSystemHandTrackingPropertiesEXT, XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT) \ _(XrHandTrackerCreateInfoEXT, XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT) \ _(XrHandJointsLocateInfoEXT, XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT) \ @@ -2025,17 +2471,52 @@ XR_ENUM_STR(XrResult); _(XrSerializedSceneFragmentDataGetInfoMSFT, XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT) \ _(XrSceneDeserializeInfoMSFT, XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT) \ _(XrEventDataDisplayRefreshRateChangedFB, XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB) \ + _(XrViveTrackerPathsHTCX, XR_TYPE_VIVE_TRACKER_PATHS_HTCX) \ + _(XrEventDataViveTrackerConnectedHTCX, XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX) \ + _(XrSystemFacialTrackingPropertiesHTC, XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC) \ + _(XrFacialExpressionsHTC, XR_TYPE_FACIAL_EXPRESSIONS_HTC) \ + _(XrFacialTrackerCreateInfoHTC, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC) \ _(XrSystemColorSpacePropertiesFB, XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB) \ + _(XrHandTrackingMeshFB, XR_TYPE_HAND_TRACKING_MESH_FB) \ + _(XrHandTrackingScaleFB, XR_TYPE_HAND_TRACKING_SCALE_FB) \ + _(XrHandTrackingAimStateFB, XR_TYPE_HAND_TRACKING_AIM_STATE_FB) \ + _(XrHandTrackingCapsulesStateFB, XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB) \ _(XrFoveationProfileCreateInfoFB, XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB) \ _(XrSwapchainCreateInfoFoveationFB, XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB) \ _(XrSwapchainStateFoveationFB, XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB) \ _(XrFoveationLevelProfileCreateInfoFB, XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB) \ + _(XrSystemKeyboardTrackingPropertiesFB, XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB) \ + _(XrKeyboardSpaceCreateInfoFB, XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB) \ + _(XrKeyboardTrackingQueryFB, XR_TYPE_KEYBOARD_TRACKING_QUERY_FB) \ + _(XrTriangleMeshCreateInfoFB, XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB) \ + _(XrSystemPassthroughPropertiesFB, XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB) \ + _(XrPassthroughCreateInfoFB, XR_TYPE_PASSTHROUGH_CREATE_INFO_FB) \ + _(XrPassthroughLayerCreateInfoFB, XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB) \ + _(XrCompositionLayerPassthroughFB, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB) \ + _(XrGeometryInstanceCreateInfoFB, XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB) \ + _(XrGeometryInstanceTransformFB, XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB) \ + _(XrPassthroughStyleFB, XR_TYPE_PASSTHROUGH_STYLE_FB) \ + _(XrPassthroughColorMapMonoToRgbaFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB) \ + _(XrPassthroughColorMapMonoToMonoFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB) \ + _(XrEventDataPassthroughStateChangedFB, XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB) \ + _(XrRenderModelPathInfoFB, XR_TYPE_RENDER_MODEL_PATH_INFO_FB) \ + _(XrRenderModelPropertiesFB, XR_TYPE_RENDER_MODEL_PROPERTIES_FB) \ + _(XrRenderModelBufferFB, XR_TYPE_RENDER_MODEL_BUFFER_FB) \ + _(XrRenderModelLoadInfoFB, XR_TYPE_RENDER_MODEL_LOAD_INFO_FB) \ + _(XrSystemRenderModelPropertiesFB, XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB) \ _(XrViewLocateFoveatedRenderingVARJO, XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO) \ _(XrFoveatedViewConfigurationViewVARJO, XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO) \ _(XrSystemFoveatedRenderingPropertiesVARJO, XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO) \ _(XrCompositionLayerDepthTestVARJO, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO) \ + _(XrSystemMarkerTrackingPropertiesVARJO, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO) \ + _(XrEventDataMarkerTrackingUpdateVARJO, XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO) \ + _(XrMarkerSpaceCreateInfoVARJO, XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO) \ _(XrSpatialAnchorPersistenceInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT) \ _(XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT) \ + _(XrCompositionLayerSpaceWarpInfoFB, XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB) \ + _(XrSystemSpaceWarpPropertiesFB, XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB) \ + _(XrDigitalLensControlALMALENCE, XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE) \ + _(XrPassthroughKeyboardHandsIntensityFB, XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB) \ @@ -2254,13 +2735,24 @@ XR_ENUM_STR(XrResult); _(XR_MSFT_scene_understanding_serialization, 99) \ _(XR_FB_display_refresh_rate, 102) \ _(XR_HTC_vive_cosmos_controller_interaction, 103) \ + _(XR_HTCX_vive_tracker_interaction, 104) \ + _(XR_HTC_facial_tracking, 105) \ + _(XR_HTC_vive_focus3_controller_interaction, 106) \ _(XR_FB_color_space, 109) \ + _(XR_FB_hand_tracking_mesh, 111) \ + _(XR_FB_hand_tracking_aim, 112) \ + _(XR_FB_hand_tracking_capsules, 113) \ _(XR_FB_foveation, 115) \ _(XR_FB_foveation_configuration, 116) \ + _(XR_FB_keyboard_tracking, 117) \ + _(XR_FB_triangle_mesh, 118) \ + _(XR_FB_passthrough, 119) \ + _(XR_FB_render_model, 120) \ _(XR_KHR_binding_modification, 121) \ _(XR_VARJO_foveated_rendering, 122) \ _(XR_VARJO_composition_layer_depth_test, 123) \ _(XR_VARJO_environment_depth_estimation, 124) \ + _(XR_VARJO_marker_tracking, 125) \ _(XR_MSFT_spatial_anchor_persistence, 143) \ _(XR_OCULUS_audio_device_guid, 160) \ _(XR_FB_foveation_vulkan, 161) \ @@ -2268,6 +2760,10 @@ XR_ENUM_STR(XrResult); _(XR_FB_swapchain_update_state_opengl_es, 163) \ _(XR_FB_swapchain_update_state_vulkan, 164) \ _(XR_KHR_swapchain_usage_input_attachment_bit, 166) \ + _(XR_FB_space_warp, 172) \ + _(XR_ALMALENCE_digital_lens_control, 197) \ + _(XR_FB_passthrough_keyboard_hands, 204) \ + _(XR_EXT_uuid, 300) \ #endif diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.cpp index 3233210..4441868 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.cpp @@ -12,6 +12,10 @@ namespace MicrosoftOpenXR void FHolographicRemotingPlugin::Register() { IModularFeatures::Get().RegisterModularFeature(GetModularFeatureName(), this); + +#if WITH_EDITOR + FCoreDelegates::OnFEngineLoopInitComplete.AddRaw(this, &FHolographicRemotingPlugin::BindConnectButtons); +#endif } void FHolographicRemotingPlugin::Unregister() @@ -23,6 +27,22 @@ namespace MicrosoftOpenXR UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingConnect.Unbind(); UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingDisconnect.Unbind(); } + +#if WITH_EDITOR + FCoreDelegates::OnFEngineLoopInitComplete.RemoveAll(this); +#endif + } + + void FHolographicRemotingPlugin::BindConnectButtons() + { +#if WITH_EDITOR + if (UMicrosoftOpenXRRuntimeSettings::Get()) + { + UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingConnect.BindSP(this, &FHolographicRemotingPlugin::ConnectToRemoteDevice); + UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingDisconnect.BindSP( + this, &FHolographicRemotingPlugin::DisconnectFromRemoteDevice); + } +#endif } bool FHolographicRemotingPlugin::GetCustomLoader(PFN_xrGetInstanceProcAddr* OutGetProcAddr) @@ -113,13 +133,6 @@ namespace MicrosoftOpenXR ParseRemotingConfig(); ConnectToRemoteDevice(remotingConnectionData); } - - if (UMicrosoftOpenXRRuntimeSettings::Get()) - { - UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingConnect.BindSP(this, &FHolographicRemotingPlugin::ConnectToRemoteDevice); - UMicrosoftOpenXRRuntimeSettings::Get()->OnRemotingDisconnect.BindSP( - this, &FHolographicRemotingPlugin::DisconnectFromRemoteDevice); - } #endif return InNext; diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.h index a0907f1..207586f 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/HolographicRemotingPlugin.h @@ -62,6 +62,7 @@ namespace MicrosoftOpenXR RemotingConnectionData remotingConnectionData; XrRemotingConnectionStateMSFT GetRemotingConnectionState(); + void BindConnectButtons(); void ConnectToRemoteDevice(RemotingConnectionData data); void DisconnectFromRemoteDevice(); diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/MicrosoftOpenXR.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/MicrosoftOpenXR.cpp index a860dbe..522085e 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/MicrosoftOpenXR.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/MicrosoftOpenXR.cpp @@ -3,6 +3,7 @@ #include "MicrosoftOpenXR.h" +#include "AzureObjectAnchorsPlugin.h" #include "CoreMinimal.h" #include "HandMeshPlugin.h" #include "HolographicRemotingPlugin.h" @@ -18,6 +19,8 @@ #include "SpatialMappingPlugin.h" #include "SpeechPlugin.h" +DEFINE_LOG_CATEGORY(LogAOA) + #define LOCTEXT_NAMESPACE "FMicrosoftOpenXRModule" namespace MicrosoftOpenXR @@ -33,6 +36,8 @@ namespace MicrosoftOpenXR HandMeshPlugin.Register(); SecondaryViewConfigurationPlugin.Register(); #if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + AzureObjectAnchorsPlugin = MakeShared(); + AzureObjectAnchorsPlugin->Register(); QRTrackingPlugin.Register(); LocatableCamPlugin.Register(); SpeechPlugin.Register(); @@ -62,6 +67,7 @@ namespace MicrosoftOpenXR HandMeshPlugin.Unregister(); SecondaryViewConfigurationPlugin.Unregister(); #if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + AzureObjectAnchorsPlugin->Unregister(); QRTrackingPlugin.Unregister(); LocatableCamPlugin.Unregister(); SpeechPlugin.Unregister(); @@ -84,6 +90,7 @@ namespace MicrosoftOpenXR FHandMeshPlugin HandMeshPlugin; FSpatialAnchorPlugin SpatialAnchorPlugin; #if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + TSharedPtr AzureObjectAnchorsPlugin; FQRTrackingPlugin QRTrackingPlugin; FLocatableCamPlugin LocatableCamPlugin; FSpeechPlugin SpeechPlugin; @@ -219,6 +226,52 @@ bool UMicrosoftOpenXRFunctionLibrary::CanDetectPlanes() return false; } +bool UMicrosoftOpenXRFunctionLibrary::ToggleAzureObjectAnchors(const bool bOnOff) +{ +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + return MicrosoftOpenXR::g_MicrosoftOpenXRModule->AzureObjectAnchorsPlugin->OnToggleARCapture(bOnOff); +#endif + + return true; +} + +void UMicrosoftOpenXRFunctionLibrary::InitAzureObjectAnchors(FAzureObjectAnchorSessionConfiguration AOAConfiguration) +{ +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + MicrosoftOpenXR::g_MicrosoftOpenXRModule->AzureObjectAnchorsPlugin->InitAzureObjectAnchors(AOAConfiguration); +#endif +} + +void UMicrosoftOpenXRFunctionLibrary::ResetObjectSearchAreaAroundHead() +{ +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + MicrosoftOpenXR::g_MicrosoftOpenXRModule->AzureObjectAnchorsPlugin->ResetObjectSearchAreaAroundHead(); +#endif +} + +void UMicrosoftOpenXRFunctionLibrary::ResetObjectSearchAreaAroundPoint(FVector Point, float Radius, bool ClearExistingSearchAreas) +{ +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + MicrosoftOpenXR::g_MicrosoftOpenXRModule->AzureObjectAnchorsPlugin->ResetObjectSearchAreaAroundPoint(Point, Radius, ClearExistingSearchAreas); +#endif +} + +TArray UMicrosoftOpenXRFunctionLibrary::LineTraceTrackedAzureObjectAnchors(const FVector Start, const FVector End) +{ +#if PLATFORM_WINDOWS || PLATFORM_HOLOLENS + TArray Results = MicrosoftOpenXR::g_MicrosoftOpenXRModule->AzureObjectAnchorsPlugin->OnLineTraceTrackedObjects(nullptr, Start, End, EARLineTraceChannels::None); + + Results.Sort([](const FARTraceResult& A, const FARTraceResult& B) + { + return A.GetDistanceFromCamera() < B.GetDistanceFromCamera(); + }); + + return Results; +#endif + + return {}; +} + #undef LOCTEXT_NAMESPACE IMPLEMENT_MODULE(MicrosoftOpenXR::FMicrosoftOpenXRModule, MicrosoftOpenXR) diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.cpp index 09893de..101e45c 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.cpp @@ -11,6 +11,10 @@ #include +#if WITH_EDITOR +#include "Editor.h" +#endif + using namespace winrt::Windows::Foundation; using namespace winrt::Windows::Foundation::Collections; using namespace winrt::Windows::Perception::Spatial; @@ -34,6 +38,17 @@ namespace MicrosoftOpenXR } FPlatformProcess::PopDllDirectory(*LibrariesDir); #endif + +#if WITH_EDITOR + // When PIE stops (when remoting), ShutdownModule is not called. + // This will prevent QR from working on subsequent plays. + FEditorDelegates::EndPIE.AddRaw(this, &FQRTrackingPlugin::HandleEndPIE); +#endif + } + + void FQRTrackingPlugin::HandleEndPIE(const bool InIsSimulating) + { + Unregister(); } void FQRTrackingPlugin::Unregister() @@ -195,7 +210,17 @@ namespace MicrosoftOpenXR void FQRTrackingPlugin::OnUpdated(QRCodeWatcher sender, QRCodeUpdatedEventArgs args) { - //OnUpdated works not good, so it's replaced by loop in UpdateDeviceLocations + // Mark the tracked QRCode as updated so it will be located in UpdateDeviceLocations. + std::lock_guard lock(QRCodeRefsLock); + if (QRTrackerInstance == nullptr) { return; } + + FScopeLock Lock(&QRCodeContextsMutex); + FGuid Guid = WMRUtility::GUIDToFGuid(args.Code().Id()); + if (QRCodeContexts.Contains(Guid)) + { + QRCodeContextPtr& Context = QRCodeContexts[Guid]; + Context->HasChanged = true; + } } void FQRTrackingPlugin::OnRemoved(QRCodeWatcher sender, QRCodeRemovedEventArgs args) @@ -246,6 +271,13 @@ namespace MicrosoftOpenXR } } + if (!Context->HasChanged) + { + // Only update QR Codes that have updated. + continue; + } + Context->HasChanged = false; + #if !UE_VERSION_OLDER_THAN(4, 27, 0) auto OutCode = MakeShared(); #else @@ -264,8 +296,9 @@ namespace MicrosoftOpenXR SpatialGraphNodeSpaceCreateInfo.nodeType = XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT; SpatialGraphNodeSpaceCreateInfo.pose = ToXrPose(FTransform::Identity, XRTrackingSystem->GetWorldToMetersScale()); - check(sizeof(SpatialGraphNodeSpaceCreateInfo.nodeId) == sizeof(FGuid)); - FMemory::Memcpy(&SpatialGraphNodeSpaceCreateInfo.nodeId, &Context->SpatialGraphNodeId, sizeof(SpatialGraphNodeSpaceCreateInfo.nodeId)); + check(sizeof(SpatialGraphNodeSpaceCreateInfo.nodeId) == sizeof(winrt::guid)); + winrt::guid SourceGuid = WMRUtility::FGUIDToGuid(Context->SpatialGraphNodeId); + FMemory::Memcpy(&SpatialGraphNodeSpaceCreateInfo.nodeId, &SourceGuid, sizeof(SpatialGraphNodeSpaceCreateInfo.nodeId)); XR_ENSURE_MSFT(xrCreateSpatialGraphNodeSpaceMSFT(InSession, &SpatialGraphNodeSpaceCreateInfo, &Context->Space)); } diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.h index 3a45a64..f73dd19 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/QRTrackingPlugin.h @@ -55,6 +55,8 @@ namespace MicrosoftOpenXR bool StartQRCodeWatcher(); void StopQRCodeWatcher(); + void HandleEndPIE(const bool InIsSimulating); + // WinRT handlers void OnAdded(winrt::Microsoft::MixedReality::QR::QRCodeWatcher sender, winrt::Microsoft::MixedReality::QR::QRCodeAddedEventArgs args); void OnUpdated(winrt::Microsoft::MixedReality::QR::QRCodeWatcher sender, winrt::Microsoft::MixedReality::QR::QRCodeUpdatedEventArgs args); @@ -76,6 +78,7 @@ namespace MicrosoftOpenXR EARTrackingState TrackingState = EARTrackingState::Unknown; FGuid SpatialGraphNodeId; XrSpace Space = XR_NULL_HANDLE; + bool HasChanged = false; ~QRCodeContext(); }; diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SceneUnderstandingBase.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SceneUnderstandingBase.cpp index 767fd13..093c877 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SceneUnderstandingBase.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SceneUnderstandingBase.cpp @@ -172,6 +172,8 @@ namespace MicrosoftOpenXR void FSceneUnderstandingBase::Unregister() { + IModularFeatures::Get().UnregisterModularFeature(GetModularFeatureName(), this); + Stop(); } diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.cpp index 56a3bdc..ab27edd 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.cpp @@ -5,6 +5,8 @@ #include "OpenXRCore.h" #include "ARPin.h" +#include "GameDelegates.h" + #if WINRT_ANCHOR_STORE_AVAILABLE using namespace winrt::Windows::Perception::Spatial; @@ -17,15 +19,12 @@ namespace MicrosoftOpenXR void FSpatialAnchorPlugin::Register() { IModularFeatures::Get().RegisterModularFeature(GetModularFeatureName(), this); + + FGameDelegates::Get().GetEndPlayMapDelegate().AddRaw(this, &FSpatialAnchorPlugin::OnEndPlay); } void FSpatialAnchorPlugin::Unregister() { - if (bIsAnchorPersistenceExtensionSupported) - { - XR_ENSURE_MSFT(xrDestroySpatialAnchorStoreConnectionMSFT(SpatialAnchorStoreMSFT)); - } - #if WINRT_ANCHOR_STORE_AVAILABLE { std::lock_guard lock(m_spatialAnchorStoreLock); @@ -38,6 +37,17 @@ namespace MicrosoftOpenXR #endif IModularFeatures::Get().UnregisterModularFeature(GetModularFeatureName(), this); + + FGameDelegates::Get().GetEndPlayMapDelegate().RemoveAll(this); + } + + void FSpatialAnchorPlugin::OnEndPlay() + { + if (SpatialAnchorStoreMSFT != XR_NULL_HANDLE) + { + XR_ENSURE_MSFT(xrDestroySpatialAnchorStoreConnectionMSFT(SpatialAnchorStoreMSFT)); + SpatialAnchorStoreMSFT = XR_NULL_HANDLE; + } } bool FSpatialAnchorPlugin::GetRequiredExtensions(TArray& OutExtensions) diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.h index 9a6d698..5a00b76 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/SpatialAnchorPlugin.h @@ -98,5 +98,7 @@ namespace MicrosoftOpenXR PFN_xrClearSpatialAnchorStoreMSFT xrClearSpatialAnchorStoreMSFT; XrSpatialAnchorStoreConnectionMSFT SpatialAnchorStoreMSFT = XR_NULL_HANDLE; + + void OnEndPlay(); }; } // namespace MicrosoftOpenXR diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.cpp b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.cpp index 8949495..83c6297 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.cpp +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.cpp @@ -15,15 +15,6 @@ namespace MicrosoftOpenXR } } - void TrackedGeometryCollision::UpdateVertices(const TArray& InVertices, const TArray& InIndices) - { - Vertices = InVertices; - Indices = InIndices; - - // Create a bounding box from the input vertices to reduce the number of full meshes that need to be hit-tested. - BoundingBox = Vertices.Num() > 0 ? FBox(&Vertices[0], Vertices.Num()) : FBox(); - } - bool TrackedGeometryCollision::Collides(const FVector Start, const FVector End, const FTransform MeshToWorld, FVector& OutHitPoint, FVector& OutHitNormal, float& OutHitDistance) { @@ -60,4 +51,78 @@ namespace MicrosoftOpenXR return false; } + + void TrackedGeometryCollision::CreateMeshDataForBoundingBox(FVector Center, FVector HalfExtents, TArray& OutVertices, TArray& OutIndices) + { + // Ensure output arrays are empty. + OutVertices.Empty(); + OutIndices.Empty(); + + // Top Vertices (+Z) + OutVertices.Add(Center + HalfExtents); + OutVertices.Add(Center + FVector(-HalfExtents.X, HalfExtents.Y, HalfExtents.Z)); + OutVertices.Add(Center + FVector(HalfExtents.X, -HalfExtents.Y, HalfExtents.Z)); + OutVertices.Add(Center + FVector(-HalfExtents.X, -HalfExtents.Y, HalfExtents.Z)); + + // Bottom Vertices (-Z) + OutVertices.Add(Center + FVector(HalfExtents.X, HalfExtents.Y, -HalfExtents.Z)); + OutVertices.Add(Center + FVector(-HalfExtents.X, HalfExtents.Y, -HalfExtents.Z)); + OutVertices.Add(Center + FVector(HalfExtents.X, -HalfExtents.Y, -HalfExtents.Z)); + OutVertices.Add(Center - HalfExtents); + + // Clockwise winding + //Top + OutIndices.Add(0); + OutIndices.Add(1); + OutIndices.Add(2); + + OutIndices.Add(2); + OutIndices.Add(1); + OutIndices.Add(3); + + // Front + OutIndices.Add(1); + OutIndices.Add(5); + OutIndices.Add(3); + + OutIndices.Add(3); + OutIndices.Add(5); + OutIndices.Add(7); + + // Bottom + OutIndices.Add(6); + OutIndices.Add(5); + OutIndices.Add(4); + + OutIndices.Add(5); + OutIndices.Add(6); + OutIndices.Add(7); + + // Back + OutIndices.Add(0); + OutIndices.Add(2); + OutIndices.Add(4); + + OutIndices.Add(2); + OutIndices.Add(6); + OutIndices.Add(4); + + // Left + OutIndices.Add(2); + OutIndices.Add(3); + OutIndices.Add(6); + + OutIndices.Add(3); + OutIndices.Add(7); + OutIndices.Add(6); + + // Right + OutIndices.Add(1); + OutIndices.Add(0); + OutIndices.Add(4); + + OutIndices.Add(1); + OutIndices.Add(4); + OutIndices.Add(5); + } } // namespace MicrosoftOpenXR diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.h index 038087f..fc7c756 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/TrackedGeometryCollision.h @@ -17,8 +17,6 @@ namespace MicrosoftOpenXR public: TrackedGeometryCollision(TArray InVertices, TArray InIndices); - void UpdateVertices(const TArray& InVertices, const TArray& InIndices); - /// /// Hit test a ray against tracked mesh data. /// @@ -31,6 +29,8 @@ namespace MicrosoftOpenXR /// True if the input ray collides with this mesh. bool Collides(const FVector Start, const FVector End, const FTransform MeshToWorld, FVector& OutHitPoint, FVector& OutHitNormal, float& OutHitDistance); + static void CreateMeshDataForBoundingBox(FVector Center, FVector HalfExtents, TArray& OutVertices, TArray& OutIndices); + private: TArray Vertices; TArray Indices; diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/WindowsMixedRealityInteropUtility.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/WindowsMixedRealityInteropUtility.h index 686a036..a0787ec 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/WindowsMixedRealityInteropUtility.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Private/WindowsMixedRealityInteropUtility.h @@ -169,11 +169,48 @@ namespace MicrosoftOpenXR static FORCEINLINE FGuid GUIDToFGuid(const winrt::guid& InGuid) { - check(sizeof(FGuid) == sizeof(winrt::guid)); - - FGuid OutGuid; - FMemory::Memcpy(&OutGuid, &InGuid, sizeof(FGuid)); - return OutGuid; + // Pack the FGuid correctly from the input winrt guid data, so the value is not lost in conversion. + // FGuids use 4 uint32's + // winrt guids use uint32, uint16, uint16, uint8[8] + // Do not simply memcpy guid to FGuid, or B, C, and D will be mismatched. + + uint32 A = InGuid.Data1; + uint32 B = (uint32)InGuid.Data2 << 16 | InGuid.Data3; + uint32 C = (uint32)InGuid.Data4[0] << 24 | + (uint32)InGuid.Data4[1] << 16 | + (uint16)InGuid.Data4[2] << 8 | + InGuid.Data4[3]; + uint32 D = (uint32)InGuid.Data4[4] << 24 | + (uint32)InGuid.Data4[5] << 16 | + (uint16)InGuid.Data4[6] << 8 | + InGuid.Data4[7]; + + return FGuid(A, B, C, D); + } + + static FORCEINLINE winrt::guid FGUIDToGuid(const FGuid& InGuid) + { + // Pack the winrt guid correctly from the input FGuid data, so the value is not lost in conversion. + // FGuids use 4 uint32's + // winrt guids use uint32, uint16, uint16, uint8[8] + // Do not simply memcpy FGuid to guid, or Data2, Data3, and Data4 will be mismatched. + + uint32_t Data1 = InGuid.A; + uint16_t Data2 = (uint16_t)((InGuid.B & 0xFFFF0000) >> 16); + uint16_t Data3 = (uint16_t)(InGuid.B & 0x0000FFFF); + + std::array Data4; + Data4[0] = (uint8_t)((InGuid.C & 0xFF000000) >> 24); + Data4[1] = (uint8_t)((InGuid.C & 0x00FF0000) >> 16); + Data4[2] = (uint8_t)((InGuid.C & 0x0000FF00) >> 8); + Data4[3] = (uint8_t)(InGuid.C & 0x000000FF); + + Data4[4] = (uint8_t)((InGuid.D & 0xFF000000) >> 24); + Data4[5] = (uint8_t)((InGuid.D & 0x00FF0000) >> 16); + Data4[6] = (uint8_t)((InGuid.D & 0x0000FF00) >> 8); + Data4[7] = (uint8_t)(InGuid.D & 0x000000FF); + + return winrt::guid(Data1, Data2, Data3, Data4); } }; } diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/AzureObjectAnchorTypes.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/AzureObjectAnchorTypes.h new file mode 100644 index 0000000..5dac383 --- /dev/null +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/AzureObjectAnchorTypes.h @@ -0,0 +1,102 @@ +// Copyright (c) 2022 Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once + +#include "Engine.h" +#include "CoreMinimal.h" +#include "UObject/ObjectMacros.h" + +#include "AzureObjectAnchorTypes.generated.h" + +UENUM(BlueprintType, Category = "MicrosoftOpenXR|Azure Object Anchors") +enum class EObjectInstanceTrackingMode : uint8 +{ + LowLatencyCoarsePosition, + HighLatencyAccuratePosition +}; + +/*How to render the tracked object with the MRMesh*/ +UENUM(BlueprintType, Category = "MicrosoftOpenXR|Azure Object Anchors") +enum class EObjectRenderMode : uint8 +{ + /*Do not render the mesh*/ + None, + /*Use the full model mesh data*/ + Mesh, + /*Render just the bounding box*/ + BoundingBox +}; + +UCLASS(BlueprintType, Blueprintable, ClassGroup = AzureObjectAnchors) +class MICROSOFTOPENXR_API UAzureObjectAnchorQueryModifiers : public UDataAsset +{ + GENERATED_BODY() + +public: + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (InlineEditConditionToggle)) + bool bUseExpectedMaxVerticalOrientationInDegrees = false; + + /*Expected maximum angle in degrees between up direction of an object instance and gravity, from 0 to 180. + Small value indicates object is expected to be up-right, while large value allows more variation on the layout.*/ + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "0.0", ClampMax = "180.0", EditCondition = "bUseExpectedMaxVerticalOrientationInDegrees")) + float ExpectedMaxVerticalOrientationInDegrees = 0.0f; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (InlineEditConditionToggle)) + bool bUseExpectedToBeStandingOnGroundPlane = false; + + /*If true, only look for objects on the ground.*/ + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (EditCondition = "bUseExpectedToBeStandingOnGroundPlane")) + bool ExpectedToBeStandingOnGroundPlane = true; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (InlineEditConditionToggle)) + bool bUseMaxScaleChange = false; + + /*Maximum scale change from 1*/ + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (EditCondition = "bUseMaxScaleChange")) + float MaxScaleChange = 0.0f; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (InlineEditConditionToggle)) + bool bUseMinSurfaceCoverage = false; + + /*Minimum required surface coverage ratio to consider an object instance as true positive, from 0 to 1.*/ + UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "0.0", ClampMax = "1.0", EditCondition = "bUseMinSurfaceCoverage")) + float MinSurfaceCoverage = 0.0f; +}; + +/*Configuration for Azure Object Anchors session.*/ +USTRUCT(BlueprintType, Category = "MicrosoftOpenXR|Azure Object Anchors") +struct FAzureObjectAnchorSessionConfiguration +{ + GENERATED_BODY() + + /*Object Anchors Account ID.*/ + UPROPERTY(BlueprintReadWrite, Category = "MicrosoftOpenXR|Azure Object Anchors") + FString AccountID; + + /*Object Anchors Account Key.*/ + UPROPERTY(BlueprintReadWrite, Category = "MicrosoftOpenXR|Azure Object Anchors") + FString AccountKey; + + /*Object Anchors Account Domain.*/ + UPROPERTY(BlueprintReadWrite, Category = "MicrosoftOpenXR|Azure Object Anchors") + FString AccountDomain; + + /*Radius around head to search for models.*/ + UPROPERTY(BlueprintReadWrite, AdvancedDisplay, Category = "MicrosoftOpenXR|Azure Object Anchors") + float SearchRadius = 500; + + /*Tracking mode for tracked objects.*/ + UPROPERTY(BlueprintReadWrite, AdvancedDisplay, Category = "MicrosoftOpenXR|Azure Object Anchors") + EObjectInstanceTrackingMode TrackingMode = EObjectInstanceTrackingMode::LowLatencyCoarsePosition; + + /*How to render the model with the MRMesh. BoundingBox or None can improve performance if the mesh is large.*/ + UPROPERTY(BlueprintReadWrite, AdvancedDisplay, Category = "MicrosoftOpenXR|Azure Object Anchors") + EObjectRenderMode ObjectRenderMode = EObjectRenderMode::Mesh; + + /*Optional query modifiers to use when locating objects.*/ + UPROPERTY(BlueprintReadWrite, AdvancedDisplay, Category = "MicrosoftOpenXR|Azure Object Anchors") + UAzureObjectAnchorQueryModifiers* QueryModifiers = nullptr; +}; + +DECLARE_LOG_CATEGORY_EXTERN(LogAOA, All, All); diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/MicrosoftOpenXR.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/MicrosoftOpenXR.h index d92270c..c6c27b9 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/MicrosoftOpenXR.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXR/Public/MicrosoftOpenXR.h @@ -8,6 +8,8 @@ #include "Kismet/BlueprintFunctionLibrary.h" #include "Components/InputComponent.h" +#include "AzureObjectAnchorTypes.h" + #include "MicrosoftOpenXR.generated.h" // Currently remoting only supports x64 Windows: Editor and Packaged Exe @@ -110,5 +112,33 @@ class MICROSOFTOPENXR_API UMicrosoftOpenXRFunctionLibrary : UFUNCTION(BlueprintPure, Category = "MicrosoftOpenXR|OpenXR") static bool CanDetectPlanes(); + + // Azure Object Anchors + /*Toggle Azure Object Anchor detection on or off. + @note After toggling on, InitAzureObjectAnchors must be called with a valid session configuration. + @param bOnOff Whether to turn on or off. + */ + UFUNCTION(BlueprintCallable, Category = "MicrosoftOpenXR|Azure Object Anchors") + static bool ToggleAzureObjectAnchors(const bool bOnOff); + + /*Initialize Azure Object Anchors with the input session config. This will start the Azure Object detection.*/ + UFUNCTION(BlueprintCallable, Category = "MicrosoftOpenXR|Azure Object Anchors") + static void InitAzureObjectAnchors(FAzureObjectAnchorSessionConfiguration AOAConfiguration); + + /*Clear any existing search areas and look for objects around the current pose, using the search radius from the initial session config.*/ + UFUNCTION(BlueprintCallable, Category = "MicrosoftOpenXR|Azure Object Anchors") + static void ResetObjectSearchAreaAroundHead(); + + /*Add a search area around a point in space and trigger new object detection. + @param Point Point in space to search around. + @param Radius Distance around point to search for objects. + @param ClearExistingSearchAreas If true, clear any existing search areas and only search around this point. + */ + UFUNCTION(BlueprintCallable, Category = "MicrosoftOpenXR|Azure Object Anchors") + static void ResetObjectSearchAreaAroundPoint(FVector Point, float Radius = 100, bool ClearExistingSearchAreas = false); + + /*Check for collisions against any tracked Azure Object Anchors along the input ray. */ + UFUNCTION(BlueprintCallable, Category = "MicrosoftOpenXR|Azure Object Anchors") + static TArray LineTraceTrackedAzureObjectAnchors(const FVector Start, const FVector End); }; diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXRRuntimeSettings/Public/MicrosoftOpenXRRuntimeSettings.h b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXRRuntimeSettings/Public/MicrosoftOpenXRRuntimeSettings.h index 336b02b..6880550 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXRRuntimeSettings/Public/MicrosoftOpenXRRuntimeSettings.h +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/MicrosoftOpenXRRuntimeSettings/Public/MicrosoftOpenXRRuntimeSettings.h @@ -32,7 +32,7 @@ namespace MicrosoftOpenXR { FString IP; uint32 Port = 8265; - int Bitrate = 8000; + int Bitrate = 20000; bool EnableAudio = false; RemotingConnectionType ConnectionType = RemotingConnectionType::Connect; RemotingCodec ConnectionCodec = RemotingCodec::Any; @@ -44,7 +44,7 @@ DECLARE_DELEGATE_OneParam(FMicrosoftOpenXRRemotingConnect, MicrosoftOpenXR::Remo DECLARE_DELEGATE(FMicrosoftOpenXRRemotingDisconnect); /** - * Implements the settings for the WindowsMixedReality runtime platform. + * Implements the settings for Microsoft OpenXR runtime platforms. */ UCLASS(config=EditorPerProjectUserSettings) class MICROSOFTOPENXRRUNTIMESETTINGS_API UMicrosoftOpenXRRuntimeSettings : public UObject @@ -67,15 +67,15 @@ class MICROSOFTOPENXRRUNTIMESETTINGS_API UMicrosoftOpenXRRuntimeSettings : publi UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (ConfigRestartRequired = true, DisplayName = "Enable Remoting For Editor (Requires Restart)", Tooltip = "If true, start with a valid HMD to enable connecting via remoting. Editor restart required.")) bool bEnableRemotingForEditor = false; - /** The IP of the HoloLens to remote to. */ - UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (EditCondition = "bEnableRemotingForEditor", DisplayName = "IP of HoloLens to remote to.")) + /** The IP of the HoloLens or WMR HMD to remote to. */ + UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (EditCondition = "bEnableRemotingForEditor", DisplayName = "Remote Device IP.")) FString RemoteHoloLensIP; UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (EditCondition = "bEnableRemotingForEditor", DisplayName = "Automatically connect to remote device.")) bool bAutoConnectRemoting = false; UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (EditCondition = "bEnableRemotingForEditor", DisplayName = "Max network transfer rate (kb/s).")) - unsigned int MaxBitrate = 8000; + unsigned int MaxBitrate = 20000; UPROPERTY(GlobalConfig, EditAnywhere, Category = "OpenXR Holographic Remoting", Meta = (EditCondition = "bEnableRemotingForEditor", DisplayName = "Use audio from PC when remoting.")) bool EnableAudio = false; diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/NuGetModule.Build.cs b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/NuGetModule.Build.cs index 0143074..1f45cea 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/NuGetModule.Build.cs +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/NuGetModule.Build.cs @@ -119,6 +119,38 @@ public NuGetModule(ReadOnlyTargetRules Target) : base(Target) WinMDFiles.Add(WinMDFile); } + string AOAPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Azure.ObjectAnchors.Runtime.WinRT")); + if (!string.IsNullOrEmpty(AOAPackage)) + { + string AOAFolderName = AOAPackage.Replace(" ", "."); + + // Copy dll and winmd binaries to our local binaries folder + string WinMDFile = Path.Combine(NugetFolder, AOAFolderName, @"lib\uap10.0\Microsoft.Azure.ObjectAnchors.winmd"); + SafeCopy(WinMDFile, Path.Combine(BinariesFolder, "Microsoft.Azure.ObjectAnchors.winmd")); + + String[] Binaries = { + "Microsoft.Azure.ObjectAnchors.dll", + "ObjectTrackerApi.dll", + "ObjectTrackerDiagnostics.dll", + "ObjectTrackerFusion.dll", + "ObjectTrackerRefinement.dll", + "VolumeFusionAPI.dll" + }; + + foreach (String Binary in Binaries) + { + SafeCopy(Path.Combine(NugetFolder, AOAFolderName, string.Format(@"runtimes\win10-{0}\native\{1}", Target.WindowsPlatform.Architecture.ToString(), Binary)), + Path.Combine(BinariesFolder, Binary)); + + RuntimeDependencies.Add(Path.Combine(BinariesFolder, Binary)); + } + + RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.Azure.ObjectAnchors.winmd")); + + // Add winmd file to the list for further processing using cppwinrt.exe + WinMDFiles.Add(WinMDFile); + } + if (Target.Platform == UnrealTargetPlatform.Win64) { // Microsoft.VCRTForwarders.140 is needed to run WinRT dlls in Win64 platforms diff --git a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/packages.config b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/packages.config index d05d97f..035e31a 100644 --- a/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/packages.config +++ b/MsftOpenXRGame/Plugins/MicrosoftOpenXR/Source/NuGetModule/packages.config @@ -3,6 +3,7 @@ - + +