change from monorepo, zwin32->zwindows

Author: hazeycode

README.md

@@ -1,67 +1,167 @@
-# zwin32
+# zwindows
 
-Zig bindings for Win32 API
+Windows development SDK for Zig game developers.
 
-Can be used on Windows and Linux. Contains partial bindings for:
-* Win32 API
-* Direct3D 12
-* Direct3D 11
-* DXGI
-* DirectML
-* Direct2D
-* XAudio2
-* Wincodec (WIC)
-* WASAPI
-* Media Foundation
-* DirectWrite
+- Vendored DirectX Compiler binaries for Windows and Linux
+- Vendored DirectX and DirectML runtime libraries
+- Lightweight partial bindings for:
+    * Win32 API (extends std.os.windows)
+    * Direct3D 12
+    * Direct3D 11
+    * DXGI
+    * DirectML
+    * Direct2D
+    * XAudio2
+    * Wincodec (WIC)
+    * WASAPI
+    * Media Foundation
+    * DirectWrite
+- Optional D3D12 helper library (zd3d12)
+- Optional XAudio2 helper library (zxaudio2)
 
-## Getting started
+## Using the Zig package
 
-Add `zwin32` your build.zig.zon dependencies and in your `build.zig` add:
+Copy `zwindows` to a subdirectory of your project and add the following to your `build.zig.zon` .dependencies:
+```zig
+    .zwindows = .{ .path = "libs/zwindows" },
+```
 
+Example build.zig
 ```zig
 pub fn build(b: *std.Build) !void {
-    const exe = b.addExecutable(.{ ... });
 
-    const zwin32 = b.dependency("zwin32", .{});
-    const zwin32_path = zwin32.path("").getPath(b);
-    
-    exe.root_module.addImport("zwin32", zwin32.module("root"));
+    ...
+
+    const zwindows_dependency = b.dependency("zwindows", .{
+        .zxaudio2_debug_layer = (builtin.mode == .Debug),
+        .zd3d12_debug_layer = (builtin.mode == .Debug),
+        .zd3d12_gbv = b.option("zd3d12_gbv", "Enable GPU-Based Validation") orelse false,
+    });
     
-    try @import("zwin32").install_xaudio2(&tests.step, .bin, zwin32_path);
+    // Import the Windows API bindings
+    exe.root_module.addImport("zwindows", zwindows_dependency.module("zwindows"));
 
-    try @import("zwin32").install_d3d12(&tests.step, .bin, zwin32_path);
+    // Import the optional zd3d12 helper library
+    exe.root_module.addImport("zd3d12", zwindows_dependency.module("zd3d12"));
 
-    try @import("zwin32").install_directml(&tests.step, .bin, zwin32_path);
+    // Import the optional zxaudio2 helper library
+    exe.root_module.addImport("zxaudio2", zwindows_dependency.module("zxaudio2"));
+    
+    // Install vendored binaries
+    const zwindows = @import("zwindows");
+    try zwindows.install_xaudio2(&exe.step, .bin);
+    try zwindows.install_d3d12(&exe.step, .bin);
+    try zwindows.install_directml(&exe.step, .bin);
 }
 ```
 
-Now in your code you may import and use `zwin32`:
-
+### Bindings Usage Example
 ```zig
-const zwin32 = @import("zwin32");
-const w32 = zwin32.w32;
-const dwrite = zwin32.dwrite;
-const dxgi = zwin32.dxgi;
-const d3d12 = zwin32.d3d12;
-const d3d12d = zwin32.d3d12d;
-const dml = zwin32.directml;
+const zwindows = @import("zwindows");
+const windows = zwindows.windows;
+const dwrite = zwindows.dwrite;
+const dxgi = zwindows.dxgi;
+const d3d12 = zwindows.d3d12;
+const d3d12d = zwindows.d3d12d;
+const dml = zwindows.directml;
+// etc
 
 pub fn main() !void {
     ...
-    const winclass = w32.WNDCLASSEXA{
+    const winclass = windows.WNDCLASSEXA{
         .style = 0,
         .lpfnWndProc = processWindowMessage,
         .cbClsExtra = 0,
         .cbWndExtra = 0,
-        .hInstance = @ptrCast(w32.HINSTANCE, w32.GetModuleHandleA(null)),
+        .hInstance = @ptrCast(windows.HINSTANCE, windows.GetModuleHandleA(null)),
         .hIcon = null,
-        .hCursor = w32.LoadCursorA(null, @intToPtr(w32.LPCSTR, 32512)),
+        .hCursor = windows.LoadCursorA(null, @intToPtr(windows.LPCSTR, 32512)),
         .hbrBackground = null,
         .lpszMenuName = null,
         .lpszClassName = name,
         .hIconSm = null,
     };
-    _ = w32.RegisterClassExA(&winclass);
+    _ = windows.RegisterClassExA(&winclass);
+}
+```
+
+## zd3d12
+zd3d12 is an optional helper library for Direct3d 12 build ontop of the zwindows bindings
+
+### Features
+- Basic DirectX 12 context management (descriptor heaps, memory heaps, swapchain, CPU and GPU sync, etc.)
+- Basic DirectX 12 resource management (handle-based resources and pipelines)
+- Basic resource barriers management with simple state-tracking
+- Transient and persistent descriptor allocation
+- Fast image loading using WIC (Windows Imaging Component)
+- Helpers for uploading data to the GPU
+- Fast mipmap generator running on the GPU
+- Interop with Direct2D and DirectWrite for high-quality vector graphics and text rendering (optional)
+
+### Example applications
+- https://github.com/zig-gamedev/zig-gamedev/tree/main/samples/triangle
+- https://github.com/zig-gamedev/zig-gamedev/tree/main/samples/textured_quad
+- https://github.com/zig-gamedev/zig-gamedev/tree/main/samples/vector_graphics_test
+- https://github.com/zig-gamedev/zig-gamedev/blob/main/samples/rasterization
+- https://github.com/zig-gamedev/zig-gamedev/tree/main/samples/bindless
+- https://github.com/zig-gamedev/zig-gamedev/blob/main/samples/mesh_shader_test
+- https://github.com/zig-gamedev/zig-gamedev/blob/main/samples/directml_convolution_test
+
+### Usage Example
+```zig
+const zd3d12 = @import("zd3d12");
+
+// We need to export below symbols for DirectX 12 Agility SDK.
+pub export const D3D12SDKVersion: u32 = 610;
+pub export const D3D12SDKPath: [*:0]const u8 = ".\\d3d12\\";
+
+pub fn main() !void {
+    ...
+    var gctx = zd3d12.GraphicsContext.init(.{
+        .allocator = allocator, 
+        .window = win32_window,
+    });
+    defer gctx.deinit(allocator);
+
+    while (...) {
+        gctx.beginFrame();
+
+        const back_buffer = gctx.getBackBuffer();
+        gctx.addTransitionBarrier(back_buffer.resource_handle, .{ .RENDER_TARGET = true });
+        gctx.flushResourceBarriers();
+
+        gctx.cmdlist.OMSetRenderTargets(
+            1,
+            &.{back_buffer.descriptor_handle},
+            TRUE,
+            null,
+        );
+        gctx.cmdlist.ClearRenderTargetView(back_buffer.descriptor_handle, &.{ 0.2, 0.4, 0.8, 1.0 }, 0, null);
+
+        gctx.addTransitionBarrier(back_buffer.resource_handle, d3d12.RESOURCE_STATES.PRESENT);
+        gctx.flushResourceBarriers();
+
+        gctx.endFrame();
+    }
+}
+```
+
+## zxaudio2
+zxaudio2 is an optional helper library for XAudio2 build ontop of the zwindows bindings
+
+### Usage Example
+```zig
+const zxaudio2 = @import("zxaudio2");
+
+pub fn main() !void {
+    ...
+    var actx = zxaudio2.AudioContext.init(allocator);
+
+    const sound_handle = actx.loadSound("content/drum_bass_hard.flac");
+    actx.playSound(sound_handle, .{});
+
+    var music = zxaudio2.Stream.create(allocator, actx.device, "content/Broke For Free - Night Owl.mp3");
+    hrPanicOnFail(music.voice.Start(0, xaudio2.COMMIT_NOW));
+    ...
 }
 ```

build.zig

@@ -2,8 +2,49 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 pub fn build(b: *std.Build) !void {
-    _ = b.addModule("root", .{
-        .root_source_file = b.path("src/zwin32.zig"),
+    const options = .{
+        .zxaudio2_debug_layer = b.option(
+            bool,
+            "zxaudio2_debug_layer",
+            "Enable XAudio2 debug layer",
+        ) orelse false,
+        .zd3d12_debug_layer = b.option(
+            bool,
+            "zd3d12_debug_layer",
+            "Enable DirectX 12 debug layer",
+        ) orelse false,
+        .zd3d12_gbv = b.option(
+            bool,
+            "zd3d12_gbv",
+            "Enable DirectX 12 GPU-Based Validation (GBV)",
+        ) orelse false,
+    };
+
+    const options_step = b.addOptions();
+    inline for (std.meta.fields(@TypeOf(options))) |field| {
+        options_step.addOption(field.type, field.name, @field(options, field.name));
+    }
+
+    const zwindows_module = b.addModule("zwindows", .{
+        .root_source_file = b.path("src/zwindows.zig"),
+    });
+
+    const options_module = options_step.createModule();
+
+    _ = b.addModule("zd3d12", .{
+        .root_source_file = b.path("src/zd3d12.zig"),
+        .imports = &.{
+            .{ .name = "options", .module = options_module },
+            .{ .name = "zwindows", .module = zwindows_module },
+        },
+    });
+
+    _ = b.addModule("zxaudio2", .{
+        .root_source_file = b.path("src/zxaudio2.zig"),
+        .imports = &.{
+            .{ .name = "options", .module = options_module },
+            .{ .name = "zwindows", .module = zwindows_module },
+        },
     });
 }
 
@@ -12,13 +53,13 @@ pub fn install_xaudio2(
     install_dir: std.Build.InstallDir,
 ) void {
     const b = step.owner;
+    const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
     step.dependOn(
         &b.addInstallFileWithDir(
             .{
-                .dependency = .{
-                    .dependency = b.dependency("zwin32", .{}),
-                    .sub_path = "bin/x64/xaudio2_9redist.dll",
-                },
+                .cwd_relative = b.pathJoin(
+                    &.{ source_path_prefix, "bin/x64/xaudio2_9redist.dll" },
+                ),
             },
             install_dir,
             "xaudio2_9redist.dll",
@@ -31,14 +72,13 @@ pub fn install_d3d12(
     install_dir: std.Build.InstallDir,
 ) void {
     const b = step.owner;
-    const zwin32 = b.dependency("zwin32", .{});
+    const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
     step.dependOn(
         &b.addInstallFileWithDir(
             .{
-                .dependency = .{
-                    .dependency = zwin32,
-                    .sub_path = "bin/x64/D3D12Core.dll",
-                },
+                .cwd_relative = b.pathJoin(
+                    &.{ source_path_prefix, "bin/x64/D3D12Core.dll" },
+                ),
             },
             install_dir,
             "d3d12/D3D12Core.dll",
@@ -47,10 +87,9 @@ pub fn install_d3d12(
     step.dependOn(
         &b.addInstallFileWithDir(
             .{
-                .dependency = .{
-                    .dependency = zwin32,
-                    .sub_path = "bin/x64/D3D12SDKLayers.dll",
-                },
+                .cwd_relative = b.pathJoin(
+                    &.{ source_path_prefix, "bin/x64/D3D12SDKLayers.dll" },
+                ),
             },
             install_dir,
             "d3d12/D3D12SDKLayers.dll",
@@ -63,13 +102,13 @@ pub fn install_directml(
     install_dir: std.Build.InstallDir,
 ) void {
     const b = step.owner;
+    const source_path_prefix = comptime std.fs.path.dirname(@src().file) orelse ".";
     step.dependOn(
         &b.addInstallFileWithDir(
             .{
-                .dependency = .{
-                    .dependency = b.dependency("zwin32", .{}),
-                    .sub_path = "bin/x64/DirectML.dll",
-                },
+                .cwd_relative = b.pathJoin(
+                    &.{ source_path_prefix, "bin/x64/DirectML.dll" },
+                ),
             },
             install_dir,
             "DirectML.dll",
@@ -78,10 +117,9 @@ pub fn install_directml(
     step.dependOn(
         &b.addInstallFileWithDir(
             .{
-                .dependency = .{
-                    .dependency = b.dependency("zwin32", .{}),
-                    .sub_path = "bin/x64/DirectML.Debug.dll",
-                },
+                .cwd_relative = b.pathJoin(
+                    &.{ source_path_prefix, "bin/x64/DirectML.Debug.dll" },
+                ),
             },
             install_dir,
             "DirectML.Debug.dll",
@@ -166,11 +204,10 @@ pub const CompileShaders = struct {
     ) void {
         const b = self.step.owner;
 
-        const zwin32 = b.dependency("zwin32", .{});
-
+        const zwindows_path = comptime std.fs.path.dirname(@src().file) orelse ".";
         const dxc_path = switch (builtin.target.os.tag) {
-            .windows => zwin32.path("bin/x64/dxc.exe").getPath(b),
-            .linux => zwin32.path("bin/x64/dxc").getPath(b),
+            .windows => zwindows_path ++ "/bin/x64/dxc.exe",
+            .linux => zwindows_path ++ "/bin/x64/dxc",
             else => @panic("Unsupported target"),
         };
 
@@ -188,7 +225,10 @@ pub const CompileShaders = struct {
 
         const cmd_step = b.addSystemCommand(&dxc_command);
         if (builtin.target.os.tag == .linux) {
-            cmd_step.setEnvironmentVariable("LD_LIBRARY_PATH", zwin32.path("bin/x64").getPath(b));
+            cmd_step.setEnvironmentVariable(
+                "LD_LIBRARY_PATH",
+                zwindows_path ++ "/bin/x64",
+            );
         }
         self.step.dependOn(&cmd_step.step);
     }

build.zig.zon

@@ -1,7 +1,6 @@
 .{
-    .name = "zwin32",
-    .version = "0.10.0",
-    .minimum_zig_version = "0.13.0-dev.351+64ef45eb0",
+    .name = "zwindows",
+    .version = "0.1.0",
     .paths = .{
         "build.zig",
         "build.zig.zon",