Fix xref navigation paths across OpenXR Vulkan Spatial Computing guide and update XrGuidMSFT to XrUuidMSFT

Author: gpx1000

attachments/openxr_engine/renderer_core.cpp

@@ -718,7 +718,7 @@ bool Renderer::pickPhysicalDevice() {
         vk::PhysicalDeviceIDProperties idProps;
         vk::PhysicalDeviceProperties2 props2;
         props2.pNext = &idProps;
-        props2 = _device.getProperties2();
+        _device.getProperties2(&props2);
 
         const uint8_t* requiredLuid = xrContext.getRequiredLUID();
         if (requiredLuid && std::memcmp(idProps.deviceLUID, requiredLuid, VK_LUID_SIZE) != 0) {

en/Building_a_Simple_Engine/Tooling/index.adoc

@@ -12,4 +12,4 @@ This chapter covers essential tooling and techniques for developing, debugging,
 * xref:Building_a_Simple_Engine/Tooling/06_packaging_and_distribution.adoc[Packaging and Distribution]
 * xref:Building_a_Simple_Engine/Tooling/07_conclusion.adoc[Conclusion]
 
-xref:Subsystems/06_conclusion.adoc[Previous: Subsystems Conclusion] | xref:../index.adoc[Back to Building a Simple Engine]
+xref:Building_a_Simple_Engine/Subsystems/06_conclusion.adoc[Previous: Subsystems Conclusion] | xref:Building_a_Simple_Engine/introduction.adoc[Back to Building a Simple Engine]

en/OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/01_introduction.adoc

@@ -23,4 +23,4 @@ If you don't perform this handshake correctly, you might find that you can't ini
 
 By the end of this chapter, you will have modified your engine's initialization code to be fully spatial-aware, laying the groundwork for the predictive frame loop and runtime-owned swapchains that follow.
 
-xref:../introduction.adoc[Previous] | xref:02_system_integration.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/introduction.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/02_system_integration.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/02_system_integration.adoc

@@ -78,4 +78,4 @@ By following the `XR_KHR_vulkan_enable2` protocol, we guarantee that our frames
 
 In the next section, we will look at **Hardware Alignment**, where we ensure that the `VkPhysicalDevice` we select is the exact same one the headset is physically connected to.
 
-xref:01_introduction.adoc[Previous] | xref:03_hardware_alignment_luid.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/01_introduction.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/03_hardware_alignment_luid.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/03_hardware_alignment_luid.adoc

@@ -40,12 +40,14 @@ To find the LUID of a Vulkan physical device, we query the `VkPhysicalDeviceIDPr
 ----
 // Iterating through physical devices to find a match
 for (const auto& physicalDevice : instance.enumeratePhysicalDevices()) {
-    auto props2 = physicalDevice.getProperties2<vk::PhysicalDeviceProperties2, vk::PhysicalDeviceIDProperties>();
-    auto idProps = props2.get<vk::PhysicalDeviceIDProperties>();
+    vk::PhysicalDeviceIDProperties idProps;
+    vk::PhysicalDeviceProperties2 props2;
+    props2.pNext = &idProps;
+    physicalDevice.getProperties2(&props2);
 
     if (idProps.deviceLUIDValid) {
         // Compare the 8-byte LUID against the target from OpenXR
-        if (memcmp(idProps.deviceLUID.data(), targetLUID, 8) == 0) {
+        if (std::memcmp(idProps.deviceLUID, targetLUID, VK_LUID_SIZE) == 0) {
             return physicalDevice;
         }
     }
@@ -60,4 +62,4 @@ Vulkan 1.4 makes this easier by standardizing external memory handles, but these
 
 In the final part of our handshake, we will ensure that our selected device is configured with the mandatory **Vulkan 1.4 features** required for a modern spatial pipeline.
 
-xref:02_system_integration.adoc[Previous] | xref:04_vulkan_1_4_feature_requirements.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/02_system_integration.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/04_vulkan_1_4_feature_requirements.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/04_vulkan_1_4_feature_requirements.adoc

@@ -69,4 +69,4 @@ We have now successfully:
 
 With the handshake complete, we are ready to tackle the most significant architectural change in an XR engine: moving from engine-owned swapchains to **Runtime-Owned Swapchains**.
 
-xref:03_hardware_alignment_luid.adoc[Previous] | xref:05_incorporating_into_the_engine.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/03_hardware_alignment_luid.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/05_incorporating_into_the_engine.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/05_incorporating_into_the_engine.adoc

@@ -49,17 +49,17 @@ public:
 
     // Swapchain Management (Chapter 3)
     void createSwapchains(vk::Device device, vk::Format format, vk::Extent2D extent);
-    std::vector<vk::Image> enumerateSwapchainImages(uint32_t eye);
+    std::vector<vk::Image> enumerateSwapchainImages();
     vk::Extent2D getSwapchainExtent();
     vk::Format getSwapchainFormat();
     void waitSwapchainImage();
-    uint32_t acquireSwapchainImage(uint32_t eye);
-    void releaseSwapchainImage(uint32_t eye);
+    uint32_t acquireSwapchainImage();
+    void releaseSwapchainImage();
 
     // Frame Lifecycle (Chapter 5)
     XrFrameState waitFrame();
     void beginFrame();
-    void endFrame(const std::array<std::vector<vk::raii::ImageView>, 2>& views);
+    void endFrame(const std::array<std::vector<vk::ImageView>, 2>& eyeViews);
 
     // View & Projection (Chapter 4 & 11)
     void locateViews(XrTime predictedTime);
@@ -131,16 +131,16 @@ In `Renderer::pickPhysicalDevice`, we must ensure we select the GPU that OpenXR
 bool Renderer::pickPhysicalDevice() {
     // ... enumerate devices ...
 
-    vk::PhysicalDeviceIDProperties idProps;
-    vk::PhysicalDeviceProperties2 props2;
-    props2.pNext = &idProps;
-
     for (auto& _device : devices) {
-        _device.getProperties2(&props2);
-
         if (xrMode) {
             // Match the LUID provided by OpenXR
-            if (std::memcmp(idProps.deviceLUID, xrContext.getRequiredLUID(), VK_LUID_SIZE) != 0) {
+            vk::PhysicalDeviceIDProperties idProps;
+            vk::PhysicalDeviceProperties2 props2;
+            props2.pNext = &idProps;
+            _device.getProperties2(&props2);
+
+            const uint8_t* requiredLuid = xrContext.getRequiredLUID();
+            if (requiredLuid && std::memcmp(idProps.deviceLUID, requiredLuid, VK_LUID_SIZE) != 0) {
                 continue; // Not the right GPU for XR!
             }
         }
@@ -149,31 +149,31 @@ bool Renderer::pickPhysicalDevice() {
 }
 ----
 
-=== 3. Enabling Vulkan 1.4 Features
+=== 3. Enabling Vulkan 1.3/1.4 Features
 
-In `Renderer::createLogicalDevice`, we must explicitly enable the 1.4 features required for spatial computing:
+In `Renderer::createLogicalDevice`, we must explicitly enable the Vulkan 1.3 features required for spatial computing, particularly **Dynamic Rendering** and **Synchronization 2**:
 
 [source,cpp]
 ----
 // renderer_core.cpp
 bool Renderer::createLogicalDevice(bool enableValidationLayers) {
     // ...
+    // Enable Vulkan 1.3 features
     vk::PhysicalDeviceVulkan13Features vulkan13Features;
     vulkan13Features.dynamicRendering = vk::True;
     vulkan13Features.synchronization2 = vk::True;
 
-    // NEW: OpenXR requires Timeline Semaphores (often a 1.2 feature, standard in 1.4)
-    vk::PhysicalDeviceTimelineSemaphoreFeatures timelineFeatures;
-    timelineFeatures.timelineSemaphore = vk::True;
-
-    vulkan13Features.pNext = &timelineFeatures;
+    // Enable Multiview (if in XR mode)
+    vk::PhysicalDeviceMultiviewFeatures multiviewFeatures;
+    multiviewFeatures.multiview = xrMode ? vk::True : vk::False;
+    multiviewFeatures.pNext = &vulkan13Features;
 
-    // ... create vk::raii::Device ...
+    // ... create vk::raii::Device with multiviewFeatures in pNext ...
 }
 ----
 
 == Why These Changes?
 
 By referencing the specific locations in `renderer_core.cpp`, we can see that OpenXR isn't just an "add-on"—it's a **collaborator** in the Vulkan lifecycle. Without the LUID matching in `pickPhysicalDevice`, our engine might initialize on a discrete GPU while the VR headset is tethered to an integrated one, leading to a complete failure to display. Similarly, the extension negotiation ensures that the XR compositor and our engine speak the same "dialect" of Vulkan.
 
-xref:04_vulkan_1_4_feature_requirements.adoc[Previous] | xref:../03_Runtime_Owned_Swapchains/01_introduction.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/04_vulkan_1_4_feature_requirements.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/01_introduction.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/01_introduction.adoc

@@ -23,4 +23,4 @@ This rhythm ensures that we never render into an image that is currently being d
 
 By the end of this chapter, your engine will be able to render its spatial views directly into the headset's compositor buffers, using our existing RAII wrappers while respecting the runtime's ownership.
 
-xref:../02_OpenXR_Vulkan_Handshake/05_incorporating_into_the_engine.adoc[Previous] | xref:02_external_image_negotiation.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/02_OpenXR_Vulkan_Handshake/05_incorporating_into_the_engine.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/02_external_image_negotiation.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/02_external_image_negotiation.adoc

@@ -71,4 +71,4 @@ By negotiating the images this way, we ensure a **Zero-Copy** hand-off. When we
 
 This efficiency is the difference between a high-performance 90Hz experience and a laggy, uncomfortable one. In the next section, we'll see how to wrap these raw Vulkan handles into the engine's `vk::raii` abstractions.
 
-xref:01_introduction.adoc[Previous] | xref:03_raii_resource_integration.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/01_introduction.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/03_raii_resource_integration.adoc[Next]

en/OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/03_raii_resource_integration.adoc

@@ -72,4 +72,4 @@ This hybrid approach—using raw handles for external resources and RAII for int
 
 In the next section, we will look at the **Memory Ownership Lifecycle**, where we master the delicate dance of waiting, acquiring, and releasing these images during our frame loop.
 
-xref:02_external_image_negotiation.adoc[Previous] | xref:04_memory_ownership_lifecycle.adoc[Next]
+xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/02_external_image_negotiation.adoc[Previous] | xref:OpenXR_Vulkan_Spatial_Computing/03_Runtime_Owned_Swapchains/04_memory_ownership_lifecycle.adoc[Next]