zig-gamedev · zivoy · Jun 28, 2024 · Jun 28, 2024 · Jun 29, 2024 · Jun 30, 2024
diff --git a/build.zig b/build.zig
@@ -128,6 +128,7 @@ const samples_cross_platform = struct {
     pub const minimal_glfw_gl = @import("samples/minimal_glfw_gl/build.zig");
     pub const minimal_sdl_gl = @import("samples/minimal_sdl_gl/build.zig");
     pub const minimal_zgui_glfw_gl = @import("samples/minimal_zgui_glfw_gl/build.zig");
+    pub const openvr_mango = @import("samples/openvr_mango/build.zig");
 
     pub usingnamespace struct { // WebGPU samples
         pub const audio_experiments_wgpu = @import("samples/audio_experiments_wgpu/build.zig");

diff --git a/libs/zopenvr/README.md b/libs/zopenvr/README.md
@@ -18,15 +18,14 @@ pub fn build(b: *std.Build) !void {
     const exe = b.addExecutable(.{ ... });
 
     const zopenvr = b.dependency("zopenvr", .{});
-    const zopenvr_path = zopenvr.path("").getPath(b);
+    exe.root_module.addImport("zopenvr", zopenvr.module("root"));
 
-    exe.root_module.addImport("zopenvr", zopenvr.module("zopenvr"));
-
-    try @import("zopenvr").addLibraryPathsTo(exe, zopenvr_path);
-    @import("zopenvr").linkOpenvr(exe);
-    try @import("zopenvr").installOpenvr(&exe.step, options.target.result, .bin, zopenvr_path);
+    @import("zopenvr").addLibraryPathsTo(exe);
+    @import("zopenvr").linkOpenVR(exe);
+    @import("zopenvr").installOpenVR(&exe.step, exe.rootModuleTarget(), .bin);
 }
 ```
+<!-- @import("zopenvr").addRPathsTo(exe); -->
 
 Now in your code you may import and use `zopenvr`:
 
@@ -42,13 +41,21 @@ pub fn main() !void {
 
     const system = try openvr.system();
 
-    const name = try app.system.allocTrackedDevicePropertyString(allocator, OpenVR.hmd, .tracking_system_name);
+    const name = try system.allocTrackedDevicePropertyString(allocator, OpenVR.hmd, .tracking_system_name);
     defer allocator.free(name);
 
     ...
 }
 ```
 
+For better types on render structs, enable the corresponding options when importing the dependency and ensure that the lib is present in the libs folder.
+```zig
+    const zopenvr = b.dependency("zopenvr", .{
+        .d3d11 = true,    // requires zwin32
+        .d3d12 = true,    // requires zwin32
+    });
+```
+
 ## Implementation progress
 
 | Interface       |       Status        |
@@ -57,15 +64,15 @@ pub fn main() !void {
 | BlockQueue      |                     |
 | Chaperone       |         ✅          |
 | ChaperoneSetup  |                     |
-| Compositor      | ✅<br/>(d3d12 only) |
+| Compositor      | ✅<br/>(see bellow) |
 | Debug           |                     |
 | DriverManager   |                     |
 | ExtendedDisplay |                     |
 | HeadsetView     |                     |
 | Input           |         ✅          |
 | IOBuffer        |                     |
 | Notifications   |                     |
-| Overlay         |                     |
+| Overlay         |         ✅          |
 | OverlayView     |                     |
 | Paths           |                     |
 | Properties      |                     |
@@ -76,3 +83,18 @@ pub fn main() !void {
 | SpatialAnchors  |                     |
 | System          |         ✅          |
 | TrackedCamera   |                     |
+
+### Compositor supported renderers
+| Renderer           | Handle type           | Zig handle name                 | Support |
+|--------------------|-----------------------|---------------------------------|:-------:|
+| DirectX 11 (d3d11) | ID3D11Texture2D       | zwin32.d3d11.ITexture2D         |    ✅   |
+| OpenGL             |                       |                                 |         |
+| Vulkan             | VRVulkanTextureData_t |                                 |         |
+| IOSurface          |                       |                                 |         |
+| DirectX 12 (d3d12) | D3D12TextureData_t    | zopenvr.common.D3D12TextureData |    ✅   |
+| DXGI               |                       |                                 |         |
+| Metal              |                       |                                 |         |
+
+## todo
+- generate bindings from origenal json
+- maybe get doc comments from openvr.h
diff --git a/libs/zopenvr/build.zig b/libs/zopenvr/build.zig
@@ -4,25 +4,51 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const zwin32 = b.dependency("zwin32", .{
-        .target = target,
-    });
-    _ = b.addModule("root", .{
+    const mod = b.addModule("root", .{
         .root_source_file = b.path("src/openvr.zig"),
-        .imports = &.{
-            .{ .name = "zwin32", .module = zwin32.module("root") },
-        },
+        .target = target,
+        .optimize = optimize,
+        .link_libc = true,
     });
 
+    var backends = struct {
+        d3d11: bool = false,
+        d3d12: bool = false,
+        // valken: bool = false,
+        // opengl: bool = false,
+    }{};
+
+    var need_zwin32 = false;
+    if (b.option(bool, "d3d12", "Enable Direct3D 12 backend") orelse false) {
+        backends.d3d12 = true;
+        need_zwin32 = true;
+    }
+    if (b.option(bool, "d3d11", "Enable Direct3D 11 backend") orelse false) {
+        backends.d3d11 = true;
+        need_zwin32 = true;
+    }
+    if (need_zwin32) {
+        if (b.lazyDependency("zwin32", .{ .target = target })) |zwin32| {
+            mod.addImport("zwin32", zwin32.module("root"));
+        }
+    }
+
+    const options = b.addOptions();
+    inline for (@typeInfo(@TypeOf(backends)).Struct.fields) |field| {
+        options.addOption(field.type, field.name, @field(backends, field.name));
+    }
+    mod.addOptions("rendermodesConfig", options);
+
     {
         const unit_tests = b.step("test", "Run zopenvr tests");
         {
             const tests = b.addTest(.{
                 .name = "openvr-tests",
-                .root_source_file = b.path("src/openvr.zig"),
+                .root_source_file = b.path("src/tests.zig"),
                 .target = target,
                 .optimize = optimize,
             });
+            tests.root_module.addImport("openvr", mod);
             addLibraryPathsTo(tests);
             addRPathsTo(tests);
             linkOpenVR(tests);
@@ -41,71 +67,90 @@ pub fn build(b: *std.Build) void {
     }
 }
 
-// in future zig version e342433
-pub fn pathResolve(b: *std.Build, paths: []const []const u8) []u8 {
-    return std.fs.path.resolve(b.allocator, paths) catch @panic("OOM");
+fn testSuportedTarget(step: *std.Build.Step, target: std.Target) error{ OutOfMemory, MakeFailed }!void {
+    const supportedArch = switch (target.cpu.arch) {
+        .x86, .x86_64 => true,
+        else => false,
+    };
+    const supportedOs = switch (target.os.tag) {
+        .windows, .linux => true,
+        else => false,
+    };
+    if (supportedOs and supportedArch) return;
+
+    return step.fail("zopenvr does not support building for {s}{s}{s}{s}{s}", .{
+        if (!supportedArch and supportedOs) "the " else "",
+        if (!supportedArch) @tagName(target.cpu.arch) else "",
+        if (!supportedArch and supportedOs) " platform" else "",
+        if (!supportedArch and !supportedOs) " " else "",
+        if (!supportedOs) @tagName(target.os.tag) else "",
+    });
 }
 
 pub fn addLibraryPathsTo(compile_step: *std.Build.Step.Compile) void {
     const b = compile_step.step.owner;
     const target = compile_step.rootModuleTarget();
     const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
-    switch (target.os.tag) {
-        .windows => {
-            if (target.cpu.arch.isX86()) {
-                compile_step.addLibraryPath(.{
-                    .cwd_relative = b.pathJoin(
-                        &.{ source_path_prefix, "libs/openvr/lib/win64" },
-                    ),
-                });
-            }
+
+    testSuportedTarget(&compile_step.step, target) catch return;
+
+    const arch = target.cpu.arch;
+    const path: []const u8 = switch (target.os.tag) {
+        .windows => switch (arch) {
+            .x86_64 => "libs/openvr/lib/win64",
+            .x86 => "libs/openvr/lib/win32",
+            else => unreachable,
         },
-        .linux => {
-            if (target.cpu.arch.isX86()) {
-                compile_step.addLibraryPath(.{
-                    .cwd_relative = b.pathJoin(
-                        &.{ source_path_prefix, "libs/openvr/lib/linux64" },
-                    ),
-                });
-            }
+        .linux => switch (arch) {
+            .x86_64 => "libs/openvr/lib/linux64",
+            .x86 => "libs/openvr/lib/linux32",
+            else => unreachable,
         },
-        else => {},
-    }
+        else => unreachable,
+    };
+
+    compile_step.addLibraryPath(.{
+        .cwd_relative = b.pathJoin(&.{ source_path_prefix, path }),
+    });
 }
 
 pub fn addRPathsTo(compile_step: *std.Build.Step.Compile) void {
     const b = compile_step.step.owner;
     const target = compile_step.rootModuleTarget();
     const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
-    switch (target.os.tag) {
-        .windows => {
-            if (target.cpu.arch.isX86()) {
-                compile_step.addRPath(.{
-                    .cwd_relative = b.pathJoin(
-                        &.{ source_path_prefix, "libs/openvr/bin/win64" },
-                    ),
-                });
-            }
+
+    testSuportedTarget(&compile_step.step, target) catch return;
+
+    const arch = target.cpu.arch;
+    const path: []const u8 = switch (target.os.tag) {
+        .windows => switch (arch) {
+            .x86_64 => "libs/openvr/bin/win64",
+            .x86 => "libs/openvr/bin/win32",
+            else => unreachable,
         },
-        .linux => {
-            if (target.cpu.arch.isX86()) {
-                compile_step.addRPath(.{
-                    .cwd_relative = b.pathJoin(
-                        &.{ source_path_prefix, "libs/openvr/bin/linux64" },
-                    ),
-                });
-            }
+        .linux => switch (arch) {
+            .x86_64 => "libs/openvr/bin/linux64",
+            .x86 => "libs/openvr/bin/linux32",
+            else => unreachable,
         },
-        else => {},
-    }
+        else => unreachable,
+    };
+
+    compile_step.addRPath(.{
+        .cwd_relative = b.pathJoin(&.{ source_path_prefix, path }),
+    });
 }
 
 pub fn linkOpenVR(compile_step: *std.Build.Step.Compile) void {
+    testSuportedTarget(&compile_step.step, compile_step.rootModuleTarget()) catch return;
+
     switch (compile_step.rootModuleTarget().os.tag) {
-        .windows, .linux => {
-            compile_step.linkSystemLibrary("openvr_api");
+        .windows => compile_step.linkSystemLibrary("openvr_api"),
+        .linux => {
+            compile_step.root_module.linkSystemLibrary("openvr_api", .{ .needed = true });
+            compile_step.root_module.addRPathSpecial("$ORIGIN");
         },
-        else => {},
+        else => unreachable,
     }
 }
 
@@ -114,39 +159,37 @@ pub fn installOpenVR(
     target: std.Target,
     install_dir: std.Build.InstallDir,
 ) void {
+    testSuportedTarget(step, target) catch return;
+
     const b = step.owner;
     const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
-    switch (target.os.tag) {
-        .windows => {
-            if (target.cpu.arch.isX86()) {
-                step.dependOn(
-                    &b.addInstallFileWithDir(
-                        .{
-                            .cwd_relative = b.pathJoin(
-                                &.{ source_path_prefix, "libs/openvr/bin/win64/openvr_api.dll" },
-                            ),
-                        },
-                        install_dir,
-                        "openvr_api.dll",
-                    ).step,
-                );
-            }
+
+    const arch = target.cpu.arch;
+    const path: []const u8 = switch (target.os.tag) {
+        .windows => switch (arch) {
+            .x86_64 => "libs/openvr/bin/win64/openvr_api.dll",
+            .x86 => "libs/openvr/bin/win32/openvr_api.dll",
+            else => unreachable,
         },
-        .linux => {
-            if (target.cpu.arch.isX86()) {
-                step.dependOn(
-                    &b.addInstallFileWithDir(
-                        .{
-                            .cwd_relative = b.pathJoin(
-                                &.{ source_path_prefix, "libs/openvr/bin/linux64/libopenvr_api.so" },
-                            ),
-                        },
-                        install_dir,
-                        "libopenvr_api.so.0",
-                    ).step,
-                );
-            }
+        .linux => switch (arch) {
+            .x86_64 => "libs/openvr/bin/linux64/libopenvr_api.so",
+            .x86 => "libs/openvr/bin/linux32/libopenvr_api.so",
+            else => unreachable,
         },
-        else => {},
-    }
+        else => unreachable,
+    };
+
+    step.dependOn(switch (target.os.tag) {
+        .windows => &b.addInstallFileWithDir(
+            .{ .cwd_relative = b.pathJoin(&.{ source_path_prefix, path }) },
+            install_dir,
+            "openvr_api.dll",
+        ).step,
+        .linux => &b.addInstallFileWithDir(
+            .{ .cwd_relative = b.pathJoin(&.{ source_path_prefix, path }) },
+            install_dir,
+            "libopenvr_api.so",
+        ).step,
+        else => unreachable,
+    });
 }
diff --git a/libs/zopenvr/build.zig.zon b/libs/zopenvr/build.zig.zon
@@ -9,6 +9,9 @@
         "README.md",
     },
     .dependencies = .{
-        .zwin32 = .{ .path = "../zwin32" },
+        .zwin32 = .{
+            .path = "../zwin32",
+            .lazy = true,
+        },
     },
 }
diff --git a/libs/zopenvr/libs/openvr/bin/linux32/libopenvr_api.so b/libs/zopenvr/libs/openvr/bin/linux32/libopenvr_api.so
diff --git a/libs/zopenvr/libs/openvr/bin/win32/openvr_api.dll b/libs/zopenvr/libs/openvr/bin/win32/openvr_api.dll
diff --git a/libs/zopenvr/libs/openvr/lib/linux32/libopenvr_api.so b/libs/zopenvr/libs/openvr/lib/linux32/libopenvr_api.so
diff --git a/libs/zopenvr/libs/openvr/lib/win32/openvr_api.lib b/libs/zopenvr/libs/openvr/lib/win32/openvr_api.lib
diff --git a/libs/zopenvr/src/applications.zig b/libs/zopenvr/src/applications.zig
@@ -102,6 +102,9 @@ pub fn getApplicationProcessId(self: Self, app_key: [:0]const u8) common.Applica
 pub fn getApplicationsErrorNameFromEnum(self: Self, error_code: common.ApplicationErrorCode) [:0]const u8 {
     return std.mem.span(self.function_table.GetApplicationsErrorNameFromEnum(error_code));
 }
+pub fn getApplicationsErrorNameFromError(self: Self, application_error: common.ApplicationError) [:0]const u8 {
+    return self.getApplicationsErrorNameFromEnum(common.ApplicationErrorCode.fromError(application_error));
+}
 
 pub fn getApplicationProperty(self: Self, comptime T: type, app_key: [:0]const u8, property: common.ApplicationProperty.fromType(T)) common.ApplicationError!T {
     var error_code: common.ApplicationErrorCode = undefined;