|
|
@@ -0,0 +1,983 @@
|
|
|
+/*
|
|
|
+ Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
|
|
|
+
|
|
|
+ This software is provided 'as-is', without any express or implied
|
|
|
+ warranty. In no event will the authors be held liable for any damages
|
|
|
+ arising from the use of this software.
|
|
|
+
|
|
|
+ Permission is granted to anyone to use this software for any purpose,
|
|
|
+ including commercial applications, and to alter it and redistribute it
|
|
|
+ freely.
|
|
|
+*/
|
|
|
+
|
|
|
+/*
|
|
|
+ * testgpu_spinning_cube_xr.c - SDL3 GPU API OpenXR Spinning Cubes Test
|
|
|
+ *
|
|
|
+ * This is an XR-enabled version of testgpu_spinning_cube that renders
|
|
|
+ * spinning colored cubes in VR using OpenXR and SDL's GPU API.
|
|
|
+ *
|
|
|
+ * Rendering approach: Multi-pass stereo (one render pass per eye)
|
|
|
+ * This is the simplest and most compatible approach, working on all
|
|
|
+ * OpenXR-capable platforms (Desktop VR runtimes, Quest, etc.)
|
|
|
+ *
|
|
|
+ * For more information on stereo rendering techniques, see:
|
|
|
+ * - Multi-pass: Traditional, 2 render passes (used here)
|
|
|
+ * - Multiview (GL_OVR_multiview): Single pass with texture arrays
|
|
|
+ * - Single-pass instanced: GPU instancing to select eye
|
|
|
+ */
|
|
|
+
|
|
|
+#include <SDL3/SDL.h>
|
|
|
+#include <SDL3/SDL_main.h>
|
|
|
+
|
|
|
+/* Include OpenXR headers BEFORE SDL_openxr.h to get full type definitions */
|
|
|
+#ifdef HAVE_OPENXR_H
|
|
|
+#include <openxr/openxr.h>
|
|
|
+#else
|
|
|
+/* SDL includes a copy for building on systems without the OpenXR SDK */
|
|
|
+#include "../src/video/khronos/openxr/openxr.h"
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <SDL3/SDL_openxr.h>
|
|
|
+
|
|
|
+/* Standard library for exit() */
|
|
|
+#include <stdlib.h>
|
|
|
+
|
|
|
+/* Include compiled shader bytecode for all backends */
|
|
|
+#include "testgpu/cube.frag.dxil.h"
|
|
|
+#include "testgpu/cube.frag.spv.h"
|
|
|
+#include "testgpu/cube.vert.dxil.h"
|
|
|
+#include "testgpu/cube.vert.spv.h"
|
|
|
+
|
|
|
+#define CHECK_CREATE(var, thing) { if (!(var)) { SDL_Log("Failed to create %s: %s", thing, SDL_GetError()); return false; } }
|
|
|
+#define XR_CHECK(result, msg) do { if (XR_FAILED(result)) { SDL_Log("OpenXR Error: %s (result=%d)", msg, (int)(result)); return false; } } while(0)
|
|
|
+#define XR_CHECK_QUIT(result, msg) do { if (XR_FAILED(result)) { SDL_Log("OpenXR Error: %s (result=%d)", msg, (int)(result)); quit(2); return; } } while(0)
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Math Types and Functions
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+typedef struct { float x, y, z; } Vec3;
|
|
|
+typedef struct { float m[16]; } Mat4;
|
|
|
+
|
|
|
+static Mat4 Mat4_Multiply(Mat4 a, Mat4 b)
|
|
|
+{
|
|
|
+ Mat4 result = {{0}};
|
|
|
+ for (int i = 0; i < 4; i++) {
|
|
|
+ for (int j = 0; j < 4; j++) {
|
|
|
+ for (int k = 0; k < 4; k++) {
|
|
|
+ result.m[i * 4 + j] += a.m[i * 4 + k] * b.m[k * 4 + j];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static Mat4 Mat4_Translation(float x, float y, float z)
|
|
|
+{
|
|
|
+ return (Mat4){{ 1,0,0,0, 0,1,0,0, 0,0,1,0, x,y,z,1 }};
|
|
|
+}
|
|
|
+
|
|
|
+static Mat4 Mat4_Scale(float s)
|
|
|
+{
|
|
|
+ return (Mat4){{ s,0,0,0, 0,s,0,0, 0,0,s,0, 0,0,0,1 }};
|
|
|
+}
|
|
|
+
|
|
|
+static Mat4 Mat4_RotationY(float rad)
|
|
|
+{
|
|
|
+ float c = SDL_cosf(rad), s = SDL_sinf(rad);
|
|
|
+ return (Mat4){{ c,0,-s,0, 0,1,0,0, s,0,c,0, 0,0,0,1 }};
|
|
|
+}
|
|
|
+
|
|
|
+static Mat4 Mat4_RotationX(float rad)
|
|
|
+{
|
|
|
+ float c = SDL_cosf(rad), s = SDL_sinf(rad);
|
|
|
+ return (Mat4){{ 1,0,0,0, 0,c,s,0, 0,-s,c,0, 0,0,0,1 }};
|
|
|
+}
|
|
|
+
|
|
|
+/* Convert XrPosef to view matrix (inverted transform) */
|
|
|
+static Mat4 Mat4_FromXrPose(XrPosef pose)
|
|
|
+{
|
|
|
+ float x = pose.orientation.x, y = pose.orientation.y;
|
|
|
+ float z = pose.orientation.z, w = pose.orientation.w;
|
|
|
+
|
|
|
+ /* Quaternion to rotation matrix columns */
|
|
|
+ Vec3 right = { 1-2*(y*y+z*z), 2*(x*y+w*z), 2*(x*z-w*y) };
|
|
|
+ Vec3 up = { 2*(x*y-w*z), 1-2*(x*x+z*z), 2*(y*z+w*x) };
|
|
|
+ Vec3 fwd = { 2*(x*z+w*y), 2*(y*z-w*x), 1-2*(x*x+y*y) };
|
|
|
+ Vec3 pos = { pose.position.x, pose.position.y, pose.position.z };
|
|
|
+
|
|
|
+ /* Inverted transform for view matrix */
|
|
|
+ float dr = -(right.x*pos.x + right.y*pos.y + right.z*pos.z);
|
|
|
+ float du = -(up.x*pos.x + up.y*pos.y + up.z*pos.z);
|
|
|
+ float df = -(fwd.x*pos.x + fwd.y*pos.y + fwd.z*pos.z);
|
|
|
+
|
|
|
+ return (Mat4){{ right.x,up.x,fwd.x,0, right.y,up.y,fwd.y,0, right.z,up.z,fwd.z,0, dr,du,df,1 }};
|
|
|
+}
|
|
|
+
|
|
|
+/* Create asymmetric projection matrix from XR FOV */
|
|
|
+static Mat4 Mat4_Projection(XrFovf fov, float nearZ, float farZ)
|
|
|
+{
|
|
|
+ float tL = SDL_tanf(fov.angleLeft), tR = SDL_tanf(fov.angleRight);
|
|
|
+ float tU = SDL_tanf(fov.angleUp), tD = SDL_tanf(fov.angleDown);
|
|
|
+ float w = tR - tL, h = tU - tD;
|
|
|
+
|
|
|
+ return (Mat4){{
|
|
|
+ 2/w, 0, 0, 0,
|
|
|
+ 0, 2/h, 0, 0,
|
|
|
+ (tR+tL)/w, (tU+tD)/h, -farZ/(farZ-nearZ), -1,
|
|
|
+ 0, 0, -(farZ*nearZ)/(farZ-nearZ), 0
|
|
|
+ }};
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Vertex Data
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+typedef struct {
|
|
|
+ float x, y, z;
|
|
|
+ Uint8 r, g, b, a;
|
|
|
+} PositionColorVertex;
|
|
|
+
|
|
|
+/* Cube vertices - 0.25m half-size, each face a different color */
|
|
|
+static const float CUBE_HALF_SIZE = 0.25f;
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * OpenXR Function Pointers (loaded dynamically)
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static PFN_xrGetInstanceProcAddr pfn_xrGetInstanceProcAddr = NULL;
|
|
|
+static PFN_xrEnumerateViewConfigurationViews pfn_xrEnumerateViewConfigurationViews = NULL;
|
|
|
+static PFN_xrEnumerateSwapchainImages pfn_xrEnumerateSwapchainImages = NULL;
|
|
|
+static PFN_xrCreateReferenceSpace pfn_xrCreateReferenceSpace = NULL;
|
|
|
+static PFN_xrDestroySpace pfn_xrDestroySpace = NULL;
|
|
|
+static PFN_xrDestroySession pfn_xrDestroySession = NULL;
|
|
|
+static PFN_xrDestroyInstance pfn_xrDestroyInstance = NULL;
|
|
|
+static PFN_xrPollEvent pfn_xrPollEvent = NULL;
|
|
|
+static PFN_xrBeginSession pfn_xrBeginSession = NULL;
|
|
|
+static PFN_xrEndSession pfn_xrEndSession = NULL;
|
|
|
+static PFN_xrWaitFrame pfn_xrWaitFrame = NULL;
|
|
|
+static PFN_xrBeginFrame pfn_xrBeginFrame = NULL;
|
|
|
+static PFN_xrEndFrame pfn_xrEndFrame = NULL;
|
|
|
+static PFN_xrLocateViews pfn_xrLocateViews = NULL;
|
|
|
+static PFN_xrAcquireSwapchainImage pfn_xrAcquireSwapchainImage = NULL;
|
|
|
+static PFN_xrWaitSwapchainImage pfn_xrWaitSwapchainImage = NULL;
|
|
|
+static PFN_xrReleaseSwapchainImage pfn_xrReleaseSwapchainImage = NULL;
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Global State
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+/* OpenXR state */
|
|
|
+static XrInstance xr_instance = XR_NULL_HANDLE;
|
|
|
+static XrSystemId xr_system_id = XR_NULL_SYSTEM_ID;
|
|
|
+static XrSession xr_session = XR_NULL_HANDLE;
|
|
|
+static XrSpace xr_local_space = XR_NULL_HANDLE;
|
|
|
+static bool xr_session_running = false;
|
|
|
+static bool xr_should_quit = false;
|
|
|
+
|
|
|
+/* Swapchain state */
|
|
|
+typedef struct {
|
|
|
+ XrSwapchain swapchain;
|
|
|
+ SDL_GPUTexture **images;
|
|
|
+ SDL_GPUTexture *depth_texture; /* Local depth buffer for z-ordering */
|
|
|
+ XrExtent2Di size;
|
|
|
+ SDL_GPUTextureFormat format;
|
|
|
+ Uint32 image_count;
|
|
|
+} VRSwapchain;
|
|
|
+
|
|
|
+/* Depth buffer format - use D24 for wide compatibility */
|
|
|
+static const SDL_GPUTextureFormat DEPTH_FORMAT = SDL_GPU_TEXTUREFORMAT_D24_UNORM;
|
|
|
+
|
|
|
+static VRSwapchain *vr_swapchains = NULL;
|
|
|
+static XrView *xr_views = NULL;
|
|
|
+static Uint32 view_count = 0;
|
|
|
+
|
|
|
+/* SDL GPU state */
|
|
|
+static SDL_GPUDevice *gpu_device = NULL;
|
|
|
+static SDL_GPUGraphicsPipeline *pipeline = NULL;
|
|
|
+static SDL_GPUBuffer *vertex_buffer = NULL;
|
|
|
+static SDL_GPUBuffer *index_buffer = NULL;
|
|
|
+
|
|
|
+/* Animation time */
|
|
|
+static float anim_time = 0.0f;
|
|
|
+static Uint64 last_ticks = 0;
|
|
|
+
|
|
|
+/* Cube scene configuration */
|
|
|
+#define NUM_CUBES 5
|
|
|
+static Vec3 cube_positions[NUM_CUBES] = {
|
|
|
+ { 0.0f, 0.0f, -2.0f }, /* Center, in front */
|
|
|
+ { -1.2f, 0.4f, -2.5f }, /* Upper left */
|
|
|
+ { 1.2f, 0.3f, -2.5f }, /* Upper right */
|
|
|
+ { -0.6f, -0.4f, -1.8f }, /* Lower left close */
|
|
|
+ { 0.6f, -0.3f, -1.8f }, /* Lower right close */
|
|
|
+};
|
|
|
+static float cube_scales[NUM_CUBES] = { 1.0f, 0.6f, 0.6f, 0.5f, 0.5f };
|
|
|
+static float cube_speeds[NUM_CUBES] = { 1.0f, 1.5f, -1.2f, 2.0f, -0.8f };
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Cleanup and Quit
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static void quit(int rc)
|
|
|
+{
|
|
|
+ SDL_Log("Cleaning up...");
|
|
|
+
|
|
|
+ /* CRITICAL: Wait for GPU to finish before destroying resources
|
|
|
+ * Per PR #14837 discussion - prevents Vulkan validation errors */
|
|
|
+ if (gpu_device) {
|
|
|
+ SDL_WaitForGPUIdle(gpu_device);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Release GPU resources first */
|
|
|
+ if (pipeline) {
|
|
|
+ SDL_ReleaseGPUGraphicsPipeline(gpu_device, pipeline);
|
|
|
+ pipeline = NULL;
|
|
|
+ }
|
|
|
+ if (vertex_buffer) {
|
|
|
+ SDL_ReleaseGPUBuffer(gpu_device, vertex_buffer);
|
|
|
+ vertex_buffer = NULL;
|
|
|
+ }
|
|
|
+ if (index_buffer) {
|
|
|
+ SDL_ReleaseGPUBuffer(gpu_device, index_buffer);
|
|
|
+ index_buffer = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Release swapchains and depth textures */
|
|
|
+ if (vr_swapchains) {
|
|
|
+ for (Uint32 i = 0; i < view_count; i++) {
|
|
|
+ if (vr_swapchains[i].depth_texture) {
|
|
|
+ SDL_ReleaseGPUTexture(gpu_device, vr_swapchains[i].depth_texture);
|
|
|
+ }
|
|
|
+ if (vr_swapchains[i].swapchain) {
|
|
|
+ SDL_DestroyGPUXRSwapchain(gpu_device, vr_swapchains[i].swapchain, vr_swapchains[i].images);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ SDL_free(vr_swapchains);
|
|
|
+ vr_swapchains = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (xr_views) {
|
|
|
+ SDL_free(xr_views);
|
|
|
+ xr_views = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Destroy OpenXR resources */
|
|
|
+ if (xr_local_space && pfn_xrDestroySpace) {
|
|
|
+ pfn_xrDestroySpace(xr_local_space);
|
|
|
+ xr_local_space = XR_NULL_HANDLE;
|
|
|
+ }
|
|
|
+ if (xr_session && pfn_xrDestroySession) {
|
|
|
+ pfn_xrDestroySession(xr_session);
|
|
|
+ xr_session = XR_NULL_HANDLE;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Destroy GPU device (this also handles XR instance cleanup) */
|
|
|
+ if (gpu_device) {
|
|
|
+ SDL_DestroyGPUDevice(gpu_device);
|
|
|
+ gpu_device = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_Quit();
|
|
|
+ exit(rc);
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Shader Loading
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static SDL_GPUShader *load_shader(bool is_vertex, Uint32 sampler_count, Uint32 uniform_buffer_count)
|
|
|
+{
|
|
|
+ SDL_GPUShaderCreateInfo createinfo;
|
|
|
+ createinfo.num_samplers = sampler_count;
|
|
|
+ createinfo.num_storage_buffers = 0;
|
|
|
+ createinfo.num_storage_textures = 0;
|
|
|
+ createinfo.num_uniform_buffers = uniform_buffer_count;
|
|
|
+
|
|
|
+ SDL_GPUShaderFormat format = SDL_GetGPUShaderFormats(gpu_device);
|
|
|
+ if (format & SDL_GPU_SHADERFORMAT_DXIL) {
|
|
|
+ createinfo.format = SDL_GPU_SHADERFORMAT_DXIL;
|
|
|
+ if (is_vertex) {
|
|
|
+ createinfo.code = cube_vert_dxil;
|
|
|
+ createinfo.code_size = cube_vert_dxil_len;
|
|
|
+ createinfo.entrypoint = "main";
|
|
|
+ } else {
|
|
|
+ createinfo.code = cube_frag_dxil;
|
|
|
+ createinfo.code_size = cube_frag_dxil_len;
|
|
|
+ createinfo.entrypoint = "main";
|
|
|
+ }
|
|
|
+ } else if (format & SDL_GPU_SHADERFORMAT_SPIRV) {
|
|
|
+ createinfo.format = SDL_GPU_SHADERFORMAT_SPIRV;
|
|
|
+ if (is_vertex) {
|
|
|
+ createinfo.code = cube_vert_spv;
|
|
|
+ createinfo.code_size = cube_vert_spv_len;
|
|
|
+ createinfo.entrypoint = "main";
|
|
|
+ } else {
|
|
|
+ createinfo.code = cube_frag_spv;
|
|
|
+ createinfo.code_size = cube_frag_spv_len;
|
|
|
+ createinfo.entrypoint = "main";
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ SDL_Log("No supported shader format found!");
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ createinfo.stage = is_vertex ? SDL_GPU_SHADERSTAGE_VERTEX : SDL_GPU_SHADERSTAGE_FRAGMENT;
|
|
|
+ createinfo.props = 0;
|
|
|
+
|
|
|
+ return SDL_CreateGPUShader(gpu_device, &createinfo);
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * OpenXR Function Loading
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static bool load_xr_functions(void)
|
|
|
+{
|
|
|
+ pfn_xrGetInstanceProcAddr = (PFN_xrGetInstanceProcAddr)SDL_OpenXR_GetXrGetInstanceProcAddr();
|
|
|
+ if (!pfn_xrGetInstanceProcAddr) {
|
|
|
+ SDL_Log("Failed to get xrGetInstanceProcAddr");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+#define XR_LOAD(fn) \
|
|
|
+ if (XR_FAILED(pfn_xrGetInstanceProcAddr(xr_instance, #fn, (PFN_xrVoidFunction*)&pfn_##fn))) { \
|
|
|
+ SDL_Log("Failed to load " #fn); \
|
|
|
+ return false; \
|
|
|
+ }
|
|
|
+
|
|
|
+ XR_LOAD(xrEnumerateViewConfigurationViews);
|
|
|
+ XR_LOAD(xrEnumerateSwapchainImages);
|
|
|
+ XR_LOAD(xrCreateReferenceSpace);
|
|
|
+ XR_LOAD(xrDestroySpace);
|
|
|
+ XR_LOAD(xrDestroySession);
|
|
|
+ XR_LOAD(xrDestroyInstance);
|
|
|
+ XR_LOAD(xrPollEvent);
|
|
|
+ XR_LOAD(xrBeginSession);
|
|
|
+ XR_LOAD(xrEndSession);
|
|
|
+ XR_LOAD(xrWaitFrame);
|
|
|
+ XR_LOAD(xrBeginFrame);
|
|
|
+ XR_LOAD(xrEndFrame);
|
|
|
+ XR_LOAD(xrLocateViews);
|
|
|
+ XR_LOAD(xrAcquireSwapchainImage);
|
|
|
+ XR_LOAD(xrWaitSwapchainImage);
|
|
|
+ XR_LOAD(xrReleaseSwapchainImage);
|
|
|
+
|
|
|
+#undef XR_LOAD
|
|
|
+
|
|
|
+ SDL_Log("Loaded all XR functions successfully");
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Pipeline and Buffer Creation
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static bool create_pipeline(SDL_GPUTextureFormat color_format)
|
|
|
+{
|
|
|
+ SDL_GPUShader *vert_shader = load_shader(true, 0, 1);
|
|
|
+ SDL_GPUShader *frag_shader = load_shader(false, 0, 0);
|
|
|
+
|
|
|
+ if (!vert_shader || !frag_shader) {
|
|
|
+ if (vert_shader) SDL_ReleaseGPUShader(gpu_device, vert_shader);
|
|
|
+ if (frag_shader) SDL_ReleaseGPUShader(gpu_device, frag_shader);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_GPUGraphicsPipelineCreateInfo pipeline_info = {
|
|
|
+ .vertex_shader = vert_shader,
|
|
|
+ .fragment_shader = frag_shader,
|
|
|
+ .target_info = {
|
|
|
+ .num_color_targets = 1,
|
|
|
+ .color_target_descriptions = (SDL_GPUColorTargetDescription[]){{
|
|
|
+ .format = color_format
|
|
|
+ }},
|
|
|
+ .has_depth_stencil_target = true,
|
|
|
+ .depth_stencil_format = DEPTH_FORMAT
|
|
|
+ },
|
|
|
+ .depth_stencil_state = {
|
|
|
+ .enable_depth_test = true,
|
|
|
+ .enable_depth_write = true,
|
|
|
+ .compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL
|
|
|
+ },
|
|
|
+ .rasterizer_state = {
|
|
|
+ .cull_mode = SDL_GPU_CULLMODE_BACK,
|
|
|
+ .front_face = SDL_GPU_FRONTFACE_CLOCKWISE, /* Cube indices wind clockwise when viewed from outside */
|
|
|
+ .fill_mode = SDL_GPU_FILLMODE_FILL
|
|
|
+ },
|
|
|
+ .vertex_input_state = {
|
|
|
+ .num_vertex_buffers = 1,
|
|
|
+ .vertex_buffer_descriptions = (SDL_GPUVertexBufferDescription[]){{
|
|
|
+ .slot = 0,
|
|
|
+ .pitch = sizeof(PositionColorVertex),
|
|
|
+ .input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX
|
|
|
+ }},
|
|
|
+ .num_vertex_attributes = 2,
|
|
|
+ .vertex_attributes = (SDL_GPUVertexAttribute[]){{
|
|
|
+ .location = 0,
|
|
|
+ .buffer_slot = 0,
|
|
|
+ .format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3,
|
|
|
+ .offset = 0
|
|
|
+ }, {
|
|
|
+ .location = 1,
|
|
|
+ .buffer_slot = 0,
|
|
|
+ .format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM,
|
|
|
+ .offset = sizeof(float) * 3
|
|
|
+ }}
|
|
|
+ },
|
|
|
+ .primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST
|
|
|
+ };
|
|
|
+
|
|
|
+ pipeline = SDL_CreateGPUGraphicsPipeline(gpu_device, &pipeline_info);
|
|
|
+
|
|
|
+ SDL_ReleaseGPUShader(gpu_device, vert_shader);
|
|
|
+ SDL_ReleaseGPUShader(gpu_device, frag_shader);
|
|
|
+
|
|
|
+ if (!pipeline) {
|
|
|
+ SDL_Log("Failed to create pipeline: %s", SDL_GetError());
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_Log("Created graphics pipeline for format %d", color_format);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static bool create_cube_buffers(void)
|
|
|
+{
|
|
|
+ float s = CUBE_HALF_SIZE;
|
|
|
+
|
|
|
+ PositionColorVertex vertices[24] = {
|
|
|
+ /* Front face (red) */
|
|
|
+ {-s,-s,-s, 255,0,0,255}, {s,-s,-s, 255,0,0,255}, {s,s,-s, 255,0,0,255}, {-s,s,-s, 255,0,0,255},
|
|
|
+ /* Back face (green) */
|
|
|
+ {s,-s,s, 0,255,0,255}, {-s,-s,s, 0,255,0,255}, {-s,s,s, 0,255,0,255}, {s,s,s, 0,255,0,255},
|
|
|
+ /* Left face (blue) */
|
|
|
+ {-s,-s,s, 0,0,255,255}, {-s,-s,-s, 0,0,255,255}, {-s,s,-s, 0,0,255,255}, {-s,s,s, 0,0,255,255},
|
|
|
+ /* Right face (yellow) */
|
|
|
+ {s,-s,-s, 255,255,0,255}, {s,-s,s, 255,255,0,255}, {s,s,s, 255,255,0,255}, {s,s,-s, 255,255,0,255},
|
|
|
+ /* Top face (magenta) */
|
|
|
+ {-s,s,-s, 255,0,255,255}, {s,s,-s, 255,0,255,255}, {s,s,s, 255,0,255,255}, {-s,s,s, 255,0,255,255},
|
|
|
+ /* Bottom face (cyan) */
|
|
|
+ {-s,-s,s, 0,255,255,255}, {s,-s,s, 0,255,255,255}, {s,-s,-s, 0,255,255,255}, {-s,-s,-s, 0,255,255,255}
|
|
|
+ };
|
|
|
+
|
|
|
+ Uint16 indices[36] = {
|
|
|
+ 0,1,2, 0,2,3, /* Front */
|
|
|
+ 4,5,6, 4,6,7, /* Back */
|
|
|
+ 8,9,10, 8,10,11, /* Left */
|
|
|
+ 12,13,14, 12,14,15, /* Right */
|
|
|
+ 16,17,18, 16,18,19, /* Top */
|
|
|
+ 20,21,22, 20,22,23 /* Bottom */
|
|
|
+ };
|
|
|
+
|
|
|
+ SDL_GPUBufferCreateInfo vertex_buf_info = {
|
|
|
+ .usage = SDL_GPU_BUFFERUSAGE_VERTEX,
|
|
|
+ .size = sizeof(vertices)
|
|
|
+ };
|
|
|
+ vertex_buffer = SDL_CreateGPUBuffer(gpu_device, &vertex_buf_info);
|
|
|
+ CHECK_CREATE(vertex_buffer, "Vertex Buffer");
|
|
|
+
|
|
|
+ SDL_GPUBufferCreateInfo index_buf_info = {
|
|
|
+ .usage = SDL_GPU_BUFFERUSAGE_INDEX,
|
|
|
+ .size = sizeof(indices)
|
|
|
+ };
|
|
|
+ index_buffer = SDL_CreateGPUBuffer(gpu_device, &index_buf_info);
|
|
|
+ CHECK_CREATE(index_buffer, "Index Buffer");
|
|
|
+
|
|
|
+ /* Create transfer buffer and upload data */
|
|
|
+ SDL_GPUTransferBufferCreateInfo transfer_info = {
|
|
|
+ .usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD,
|
|
|
+ .size = sizeof(vertices) + sizeof(indices)
|
|
|
+ };
|
|
|
+ SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(gpu_device, &transfer_info);
|
|
|
+ CHECK_CREATE(transfer, "Transfer Buffer");
|
|
|
+
|
|
|
+ void *data = SDL_MapGPUTransferBuffer(gpu_device, transfer, false);
|
|
|
+ SDL_memcpy(data, vertices, sizeof(vertices));
|
|
|
+ SDL_memcpy((Uint8*)data + sizeof(vertices), indices, sizeof(indices));
|
|
|
+ SDL_UnmapGPUTransferBuffer(gpu_device, transfer);
|
|
|
+
|
|
|
+ SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(gpu_device);
|
|
|
+ SDL_GPUCopyPass *copy_pass = SDL_BeginGPUCopyPass(cmd);
|
|
|
+
|
|
|
+ SDL_GPUTransferBufferLocation src_vertex = { .transfer_buffer = transfer, .offset = 0 };
|
|
|
+ SDL_GPUBufferRegion dst_vertex = { .buffer = vertex_buffer, .offset = 0, .size = sizeof(vertices) };
|
|
|
+ SDL_UploadToGPUBuffer(copy_pass, &src_vertex, &dst_vertex, false);
|
|
|
+
|
|
|
+ SDL_GPUTransferBufferLocation src_index = { .transfer_buffer = transfer, .offset = sizeof(vertices) };
|
|
|
+ SDL_GPUBufferRegion dst_index = { .buffer = index_buffer, .offset = 0, .size = sizeof(indices) };
|
|
|
+ SDL_UploadToGPUBuffer(copy_pass, &src_index, &dst_index, false);
|
|
|
+
|
|
|
+ SDL_EndGPUCopyPass(copy_pass);
|
|
|
+ SDL_SubmitGPUCommandBuffer(cmd);
|
|
|
+ SDL_ReleaseGPUTransferBuffer(gpu_device, transfer);
|
|
|
+
|
|
|
+ SDL_Log("Created cube vertex (%u bytes) and index (%u bytes) buffers", (unsigned int)sizeof(vertices), (unsigned int)sizeof(indices));
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * XR Session Initialization
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static bool init_xr_session(void)
|
|
|
+{
|
|
|
+ XrResult result;
|
|
|
+
|
|
|
+ /* Create session */
|
|
|
+ XrSessionCreateInfo session_info = { XR_TYPE_SESSION_CREATE_INFO };
|
|
|
+ result = SDL_CreateGPUXRSession(gpu_device, &session_info, &xr_session);
|
|
|
+ XR_CHECK(result, "Failed to create XR session");
|
|
|
+
|
|
|
+ /* Create reference space */
|
|
|
+ XrReferenceSpaceCreateInfo space_info = { XR_TYPE_REFERENCE_SPACE_CREATE_INFO };
|
|
|
+ space_info.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
|
|
|
+ space_info.poseInReferenceSpace.orientation.w = 1.0f; /* Identity quaternion */
|
|
|
+
|
|
|
+ result = pfn_xrCreateReferenceSpace(xr_session, &space_info, &xr_local_space);
|
|
|
+ XR_CHECK(result, "Failed to create reference space");
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static bool create_swapchains(void)
|
|
|
+{
|
|
|
+ XrResult result;
|
|
|
+
|
|
|
+ /* Get view configuration */
|
|
|
+ result = pfn_xrEnumerateViewConfigurationViews(
|
|
|
+ xr_instance, xr_system_id,
|
|
|
+ XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO,
|
|
|
+ 0, &view_count, NULL);
|
|
|
+ XR_CHECK(result, "Failed to enumerate view config views (count)");
|
|
|
+
|
|
|
+ SDL_Log("View count: %" SDL_PRIu32, view_count);
|
|
|
+
|
|
|
+ XrViewConfigurationView *view_configs = SDL_calloc(view_count, sizeof(XrViewConfigurationView));
|
|
|
+ for (Uint32 i = 0; i < view_count; i++) {
|
|
|
+ view_configs[i].type = XR_TYPE_VIEW_CONFIGURATION_VIEW;
|
|
|
+ }
|
|
|
+
|
|
|
+ result = pfn_xrEnumerateViewConfigurationViews(
|
|
|
+ xr_instance, xr_system_id,
|
|
|
+ XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO,
|
|
|
+ view_count, &view_count, view_configs);
|
|
|
+ if (XR_FAILED(result)) {
|
|
|
+ SDL_free(view_configs);
|
|
|
+ SDL_Log("Failed to enumerate view config views");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Allocate swapchains and views */
|
|
|
+ vr_swapchains = SDL_calloc(view_count, sizeof(VRSwapchain));
|
|
|
+ xr_views = SDL_calloc(view_count, sizeof(XrView));
|
|
|
+
|
|
|
+ /* Query available swapchain formats
|
|
|
+ * Per PR #14837: format arrays are terminated with SDL_GPU_TEXTUREFORMAT_INVALID */
|
|
|
+ int num_formats = 0;
|
|
|
+ SDL_GPUTextureFormat *formats = SDL_GetGPUXRSwapchainFormats(gpu_device, xr_session, &num_formats);
|
|
|
+ if (!formats || num_formats == 0) {
|
|
|
+ SDL_Log("Failed to get XR swapchain formats");
|
|
|
+ SDL_free(view_configs);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Use first available format (typically sRGB)
|
|
|
+ * Note: Could iterate with: while (formats[i] != SDL_GPU_TEXTUREFORMAT_INVALID) */
|
|
|
+ SDL_GPUTextureFormat swapchain_format = formats[0];
|
|
|
+ SDL_Log("Using swapchain format: %d (of %d available)", swapchain_format, num_formats);
|
|
|
+
|
|
|
+ /* Log all available formats for debugging */
|
|
|
+ for (int f = 0; f < num_formats && formats[f] != SDL_GPU_TEXTUREFORMAT_INVALID; f++) {
|
|
|
+ SDL_Log(" Available format [%d]: %d", f, formats[f]);
|
|
|
+ }
|
|
|
+ SDL_free(formats);
|
|
|
+
|
|
|
+ for (Uint32 i = 0; i < view_count; i++) {
|
|
|
+ xr_views[i].type = XR_TYPE_VIEW;
|
|
|
+ xr_views[i].pose.orientation.w = 1.0f;
|
|
|
+
|
|
|
+ SDL_Log("Eye %" SDL_PRIu32 ": recommended %ux%u", i,
|
|
|
+ (unsigned int)view_configs[i].recommendedImageRectWidth,
|
|
|
+ (unsigned int)view_configs[i].recommendedImageRectHeight);
|
|
|
+
|
|
|
+ /* Create swapchain using OpenXR's XrSwapchainCreateInfo */
|
|
|
+ XrSwapchainCreateInfo swapchain_info = { XR_TYPE_SWAPCHAIN_CREATE_INFO };
|
|
|
+ swapchain_info.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT;
|
|
|
+ swapchain_info.format = 0; /* Ignored - SDL uses the format parameter */
|
|
|
+ swapchain_info.sampleCount = 1;
|
|
|
+ swapchain_info.width = view_configs[i].recommendedImageRectWidth;
|
|
|
+ swapchain_info.height = view_configs[i].recommendedImageRectHeight;
|
|
|
+ swapchain_info.faceCount = 1;
|
|
|
+ swapchain_info.arraySize = 1;
|
|
|
+ swapchain_info.mipCount = 1;
|
|
|
+
|
|
|
+ result = SDL_CreateGPUXRSwapchain(
|
|
|
+ gpu_device,
|
|
|
+ xr_session,
|
|
|
+ &swapchain_info,
|
|
|
+ swapchain_format,
|
|
|
+ &vr_swapchains[i].swapchain,
|
|
|
+ &vr_swapchains[i].images);
|
|
|
+
|
|
|
+ vr_swapchains[i].format = swapchain_format;
|
|
|
+
|
|
|
+ if (XR_FAILED(result)) {
|
|
|
+ SDL_Log("Failed to create swapchain %" SDL_PRIu32, i);
|
|
|
+ SDL_free(view_configs);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Get image count by enumerating swapchain images */
|
|
|
+ result = pfn_xrEnumerateSwapchainImages(vr_swapchains[i].swapchain, 0, &vr_swapchains[i].image_count, NULL);
|
|
|
+ if (XR_FAILED(result)) {
|
|
|
+ vr_swapchains[i].image_count = 3; /* Assume 3 if we can't query */
|
|
|
+ }
|
|
|
+
|
|
|
+ vr_swapchains[i].size.width = (int32_t)swapchain_info.width;
|
|
|
+ vr_swapchains[i].size.height = (int32_t)swapchain_info.height;
|
|
|
+
|
|
|
+ /* Create local depth texture for this eye
|
|
|
+ * Per PR #14837: Depth buffers are "really recommended" for XR apps.
|
|
|
+ * Using a local depth texture (not XR-managed) is the simplest approach
|
|
|
+ * for proper z-ordering without requiring XR_KHR_composition_layer_depth. */
|
|
|
+ SDL_GPUTextureCreateInfo depth_info = {
|
|
|
+ .type = SDL_GPU_TEXTURETYPE_2D,
|
|
|
+ .format = DEPTH_FORMAT,
|
|
|
+ .width = swapchain_info.width,
|
|
|
+ .height = swapchain_info.height,
|
|
|
+ .layer_count_or_depth = 1,
|
|
|
+ .num_levels = 1,
|
|
|
+ .sample_count = SDL_GPU_SAMPLECOUNT_1,
|
|
|
+ .usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET,
|
|
|
+ .props = 0
|
|
|
+ };
|
|
|
+ vr_swapchains[i].depth_texture = SDL_CreateGPUTexture(gpu_device, &depth_info);
|
|
|
+ if (!vr_swapchains[i].depth_texture) {
|
|
|
+ SDL_Log("Failed to create depth texture for eye %" SDL_PRIu32 ": %s", i, SDL_GetError());
|
|
|
+ SDL_free(view_configs);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_Log("Created swapchain %" SDL_PRIu32 ": %" SDL_PRIs32 "x%" SDL_PRIs32 ", %" SDL_PRIu32 " images, with depth buffer",
|
|
|
+ i, vr_swapchains[i].size.width, vr_swapchains[i].size.height,
|
|
|
+ vr_swapchains[i].image_count);
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_free(view_configs);
|
|
|
+
|
|
|
+ /* Create the pipeline using the swapchain format */
|
|
|
+ if (view_count > 0 && pipeline == NULL) {
|
|
|
+ if (!create_pipeline(vr_swapchains[0].format)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (!create_cube_buffers()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * XR Event Handling
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static void handle_xr_events(void)
|
|
|
+{
|
|
|
+ XrEventDataBuffer event_buffer = { XR_TYPE_EVENT_DATA_BUFFER };
|
|
|
+
|
|
|
+ while (pfn_xrPollEvent(xr_instance, &event_buffer) == XR_SUCCESS) {
|
|
|
+ switch (event_buffer.type) {
|
|
|
+ case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: {
|
|
|
+ XrEventDataSessionStateChanged *state_event =
|
|
|
+ (XrEventDataSessionStateChanged*)&event_buffer;
|
|
|
+
|
|
|
+ SDL_Log("Session state changed: %d", state_event->state);
|
|
|
+
|
|
|
+ switch (state_event->state) {
|
|
|
+ case XR_SESSION_STATE_READY: {
|
|
|
+ XrSessionBeginInfo begin_info = { XR_TYPE_SESSION_BEGIN_INFO };
|
|
|
+ begin_info.primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
|
|
|
+
|
|
|
+ XrResult result = pfn_xrBeginSession(xr_session, &begin_info);
|
|
|
+ if (XR_SUCCEEDED(result)) {
|
|
|
+ SDL_Log("XR Session begun!");
|
|
|
+ xr_session_running = true;
|
|
|
+
|
|
|
+ /* Create swapchains now that session is ready */
|
|
|
+ if (!create_swapchains()) {
|
|
|
+ SDL_Log("Failed to create swapchains");
|
|
|
+ xr_should_quit = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case XR_SESSION_STATE_STOPPING:
|
|
|
+ pfn_xrEndSession(xr_session);
|
|
|
+ xr_session_running = false;
|
|
|
+ break;
|
|
|
+ case XR_SESSION_STATE_EXITING:
|
|
|
+ case XR_SESSION_STATE_LOSS_PENDING:
|
|
|
+ xr_should_quit = true;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING:
|
|
|
+ xr_should_quit = true;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ event_buffer.type = XR_TYPE_EVENT_DATA_BUFFER;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Rendering
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+static void render_frame(void)
|
|
|
+{
|
|
|
+ if (!xr_session_running) return;
|
|
|
+
|
|
|
+ XrFrameState frame_state = { XR_TYPE_FRAME_STATE };
|
|
|
+ XrFrameWaitInfo wait_info = { XR_TYPE_FRAME_WAIT_INFO };
|
|
|
+
|
|
|
+ XrResult result = pfn_xrWaitFrame(xr_session, &wait_info, &frame_state);
|
|
|
+ if (XR_FAILED(result)) return;
|
|
|
+
|
|
|
+ XrFrameBeginInfo begin_info = { XR_TYPE_FRAME_BEGIN_INFO };
|
|
|
+ result = pfn_xrBeginFrame(xr_session, &begin_info);
|
|
|
+ if (XR_FAILED(result)) return;
|
|
|
+
|
|
|
+ XrCompositionLayerProjectionView *proj_views = NULL;
|
|
|
+ XrCompositionLayerProjection layer = { XR_TYPE_COMPOSITION_LAYER_PROJECTION };
|
|
|
+ Uint32 layer_count = 0;
|
|
|
+ const XrCompositionLayerBaseHeader *layers[1] = {0};
|
|
|
+
|
|
|
+ if (frame_state.shouldRender && view_count > 0 && vr_swapchains != NULL) {
|
|
|
+ /* Update animation time */
|
|
|
+ Uint64 now = SDL_GetTicks();
|
|
|
+ if (last_ticks == 0) last_ticks = now;
|
|
|
+ float delta = (float)(now - last_ticks) / 1000.0f;
|
|
|
+ last_ticks = now;
|
|
|
+ anim_time += delta;
|
|
|
+
|
|
|
+ /* Locate views */
|
|
|
+ XrViewState view_state = { XR_TYPE_VIEW_STATE };
|
|
|
+ XrViewLocateInfo locate_info = { XR_TYPE_VIEW_LOCATE_INFO };
|
|
|
+ locate_info.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
|
|
|
+ locate_info.displayTime = frame_state.predictedDisplayTime;
|
|
|
+ locate_info.space = xr_local_space;
|
|
|
+
|
|
|
+ Uint32 view_count_output;
|
|
|
+ result = pfn_xrLocateViews(xr_session, &locate_info, &view_state, view_count, &view_count_output, xr_views);
|
|
|
+ if (XR_FAILED(result)) {
|
|
|
+ SDL_Log("xrLocateViews failed");
|
|
|
+ goto endFrame;
|
|
|
+ }
|
|
|
+
|
|
|
+ proj_views = SDL_calloc(view_count, sizeof(XrCompositionLayerProjectionView));
|
|
|
+
|
|
|
+ SDL_GPUCommandBuffer *cmd_buf = SDL_AcquireGPUCommandBuffer(gpu_device);
|
|
|
+
|
|
|
+ /* Multi-pass stereo: render each eye separately */
|
|
|
+ for (Uint32 i = 0; i < view_count; i++) {
|
|
|
+ VRSwapchain *swapchain = &vr_swapchains[i];
|
|
|
+
|
|
|
+ /* Acquire swapchain image */
|
|
|
+ Uint32 image_index;
|
|
|
+ XrSwapchainImageAcquireInfo acquire_info = { XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO };
|
|
|
+ result = pfn_xrAcquireSwapchainImage(swapchain->swapchain, &acquire_info, &image_index);
|
|
|
+ if (XR_FAILED(result)) continue;
|
|
|
+
|
|
|
+ XrSwapchainImageWaitInfo wait_image_info = { XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO };
|
|
|
+ wait_image_info.timeout = XR_INFINITE_DURATION;
|
|
|
+ result = pfn_xrWaitSwapchainImage(swapchain->swapchain, &wait_image_info);
|
|
|
+ if (XR_FAILED(result)) {
|
|
|
+ XrSwapchainImageReleaseInfo release_info = { XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
|
|
|
+ pfn_xrReleaseSwapchainImage(swapchain->swapchain, &release_info);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Render the scene to this eye */
|
|
|
+ SDL_GPUTexture *target_texture = swapchain->images[image_index];
|
|
|
+
|
|
|
+ /* Build view and projection matrices from XR pose/fov */
|
|
|
+ Mat4 view_matrix = Mat4_FromXrPose(xr_views[i].pose);
|
|
|
+ Mat4 proj_matrix = Mat4_Projection(xr_views[i].fov, 0.05f, 100.0f);
|
|
|
+
|
|
|
+ SDL_GPUColorTargetInfo color_target = {0};
|
|
|
+ color_target.texture = target_texture;
|
|
|
+ color_target.load_op = SDL_GPU_LOADOP_CLEAR;
|
|
|
+ color_target.store_op = SDL_GPU_STOREOP_STORE;
|
|
|
+ /* Dark blue background */
|
|
|
+ color_target.clear_color.r = 0.05f;
|
|
|
+ color_target.clear_color.g = 0.05f;
|
|
|
+ color_target.clear_color.b = 0.15f;
|
|
|
+ color_target.clear_color.a = 1.0f;
|
|
|
+
|
|
|
+ /* Set up depth target for proper z-ordering */
|
|
|
+ SDL_GPUDepthStencilTargetInfo depth_target = {0};
|
|
|
+ depth_target.texture = swapchain->depth_texture;
|
|
|
+ depth_target.clear_depth = 1.0f; /* Far plane */
|
|
|
+ depth_target.load_op = SDL_GPU_LOADOP_CLEAR;
|
|
|
+ depth_target.store_op = SDL_GPU_STOREOP_DONT_CARE; /* We don't need to preserve depth */
|
|
|
+ depth_target.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE;
|
|
|
+ depth_target.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE;
|
|
|
+ depth_target.cycle = true; /* Allow GPU to cycle the texture for efficiency */
|
|
|
+
|
|
|
+ SDL_GPURenderPass *render_pass = SDL_BeginGPURenderPass(cmd_buf, &color_target, 1, &depth_target);
|
|
|
+
|
|
|
+ if (pipeline && vertex_buffer && index_buffer) {
|
|
|
+ SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
|
|
|
+
|
|
|
+ SDL_GPUViewport viewport = {0, 0, (float)swapchain->size.width, (float)swapchain->size.height, 0, 1};
|
|
|
+ SDL_SetGPUViewport(render_pass, &viewport);
|
|
|
+
|
|
|
+ SDL_Rect scissor = {0, 0, swapchain->size.width, swapchain->size.height};
|
|
|
+ SDL_SetGPUScissor(render_pass, &scissor);
|
|
|
+
|
|
|
+ SDL_GPUBufferBinding vertex_binding = {vertex_buffer, 0};
|
|
|
+ SDL_BindGPUVertexBuffers(render_pass, 0, &vertex_binding, 1);
|
|
|
+
|
|
|
+ SDL_GPUBufferBinding index_binding = {index_buffer, 0};
|
|
|
+ SDL_BindGPUIndexBuffer(render_pass, &index_binding, SDL_GPU_INDEXELEMENTSIZE_16BIT);
|
|
|
+
|
|
|
+ /* Draw each cube */
|
|
|
+ for (int cube_idx = 0; cube_idx < NUM_CUBES; cube_idx++) {
|
|
|
+ float rot = anim_time * cube_speeds[cube_idx];
|
|
|
+ Vec3 pos = cube_positions[cube_idx];
|
|
|
+
|
|
|
+ /* Build model matrix: scale -> rotateY -> rotateX -> translate */
|
|
|
+ Mat4 scale = Mat4_Scale(cube_scales[cube_idx]);
|
|
|
+ Mat4 rotY = Mat4_RotationY(rot);
|
|
|
+ Mat4 rotX = Mat4_RotationX(rot * 0.7f);
|
|
|
+ Mat4 trans = Mat4_Translation(pos.x, pos.y, pos.z);
|
|
|
+
|
|
|
+ Mat4 model = Mat4_Multiply(Mat4_Multiply(Mat4_Multiply(scale, rotY), rotX), trans);
|
|
|
+ Mat4 mv = Mat4_Multiply(model, view_matrix);
|
|
|
+ Mat4 mvp = Mat4_Multiply(mv, proj_matrix);
|
|
|
+
|
|
|
+ SDL_PushGPUVertexUniformData(cmd_buf, 0, &mvp, sizeof(mvp));
|
|
|
+ SDL_DrawGPUIndexedPrimitives(render_pass, 36, 1, 0, 0, 0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_EndGPURenderPass(render_pass);
|
|
|
+
|
|
|
+ /* Release swapchain image */
|
|
|
+ XrSwapchainImageReleaseInfo release_info = { XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
|
|
|
+ pfn_xrReleaseSwapchainImage(swapchain->swapchain, &release_info);
|
|
|
+
|
|
|
+ /* Set up projection view */
|
|
|
+ proj_views[i].type = XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
|
|
|
+ proj_views[i].pose = xr_views[i].pose;
|
|
|
+ proj_views[i].fov = xr_views[i].fov;
|
|
|
+ proj_views[i].subImage.swapchain = swapchain->swapchain;
|
|
|
+ proj_views[i].subImage.imageRect.offset.x = 0;
|
|
|
+ proj_views[i].subImage.imageRect.offset.y = 0;
|
|
|
+ proj_views[i].subImage.imageRect.extent = swapchain->size;
|
|
|
+ proj_views[i].subImage.imageArrayIndex = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_SubmitGPUCommandBuffer(cmd_buf);
|
|
|
+
|
|
|
+ layer.space = xr_local_space;
|
|
|
+ layer.viewCount = view_count;
|
|
|
+ layer.views = proj_views;
|
|
|
+ layers[0] = (XrCompositionLayerBaseHeader*)&layer;
|
|
|
+ layer_count = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+endFrame:;
|
|
|
+ XrFrameEndInfo end_info = { XR_TYPE_FRAME_END_INFO };
|
|
|
+ end_info.displayTime = frame_state.predictedDisplayTime;
|
|
|
+ end_info.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
|
|
|
+ end_info.layerCount = layer_count;
|
|
|
+ end_info.layers = layers;
|
|
|
+
|
|
|
+ pfn_xrEndFrame(xr_session, &end_info);
|
|
|
+
|
|
|
+ if (proj_views) SDL_free(proj_views);
|
|
|
+}
|
|
|
+
|
|
|
+/* ========================================================================
|
|
|
+ * Main
|
|
|
+ * ======================================================================== */
|
|
|
+
|
|
|
+int main(int argc, char *argv[])
|
|
|
+{
|
|
|
+ (void)argc;
|
|
|
+ (void)argv;
|
|
|
+
|
|
|
+ SDL_Log("SDL GPU OpenXR Spinning Cubes Test starting...");
|
|
|
+ SDL_Log("Stereo rendering mode: Multi-pass (one render pass per eye)");
|
|
|
+
|
|
|
+ if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) {
|
|
|
+ SDL_Log("SDL_Init failed: %s", SDL_GetError());
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_Log("SDL initialized");
|
|
|
+
|
|
|
+ /* Create GPU device with OpenXR enabled */
|
|
|
+ SDL_Log("Creating GPU device with OpenXR enabled...");
|
|
|
+
|
|
|
+ SDL_PropertiesID props = SDL_CreateProperties();
|
|
|
+ SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN, true);
|
|
|
+ SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN, true);
|
|
|
+ SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN, true);
|
|
|
+ /* Enable XR - SDL will create the OpenXR instance for us */
|
|
|
+ SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_XR_ENABLE_BOOLEAN, true);
|
|
|
+ SDL_SetPointerProperty(props, SDL_PROP_GPU_DEVICE_CREATE_XR_INSTANCE_POINTER, &xr_instance);
|
|
|
+ SDL_SetPointerProperty(props, SDL_PROP_GPU_DEVICE_CREATE_XR_SYSTEM_ID_POINTER, &xr_system_id);
|
|
|
+ SDL_SetStringProperty(props, SDL_PROP_GPU_DEVICE_CREATE_XR_APPLICATION_NAME_STRING, "SDL XR Spinning Cubes Test");
|
|
|
+ SDL_SetNumberProperty(props, SDL_PROP_GPU_DEVICE_CREATE_XR_APPLICATION_VERSION_NUMBER, 1);
|
|
|
+
|
|
|
+ gpu_device = SDL_CreateGPUDeviceWithProperties(props);
|
|
|
+ SDL_DestroyProperties(props);
|
|
|
+
|
|
|
+ if (!gpu_device) {
|
|
|
+ SDL_Log("Failed to create GPU device: %s", SDL_GetError());
|
|
|
+ SDL_Quit();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Load OpenXR function pointers */
|
|
|
+ if (!load_xr_functions()) {
|
|
|
+ SDL_Log("Failed to load XR functions");
|
|
|
+ quit(1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Initialize XR session */
|
|
|
+ if (!init_xr_session()) {
|
|
|
+ SDL_Log("Failed to init XR session");
|
|
|
+ quit(1);
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_Log("Entering main loop... Put on your VR headset!");
|
|
|
+
|
|
|
+ /* Main loop */
|
|
|
+ while (!xr_should_quit) {
|
|
|
+ SDL_Event event;
|
|
|
+ while (SDL_PollEvent(&event)) {
|
|
|
+ if (event.type == SDL_EVENT_QUIT) {
|
|
|
+ xr_should_quit = true;
|
|
|
+ }
|
|
|
+ if (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_ESCAPE) {
|
|
|
+ xr_should_quit = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ handle_xr_events();
|
|
|
+ render_frame();
|
|
|
+ }
|
|
|
+
|
|
|
+ quit(0);
|
|
|
+ return 0;
|
|
|
+}
|
Aaron Benjamin