files from monorepo @ 613d847104a072fc1d4442f58d5f50b3f9c3f27c

Author: hazeycode

.gitignore

@@ -0,0 +1,6 @@
+# Ignore some special directories
+*zig-cache
+*zig-out
+
+# Ignore some special OS files
+*.DS_Store

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Michal Ziulek
+Copyright (c) 2024 zig-gamedev contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,135 @@
+# [zmath](https://github.com/michal-z/zig-gamedev/zmath)
+
+SIMD math library for game developers
+
+Tested on x86_64 and AArch64.
+
+Provides ~140 optimized routines and ~70 extensive tests.
+
+Can be used with any graphics API.
+
+Documentation can be found [here](https://github.com/michal-z/zig-gamedev/zmath/src/zmath.zig).
+
+Benchamrks can be found [here](https://github.com/michal-z/zig-gamedev/zmath/src/benchmark.zig).
+
+An intro article can be found [here](https://zig.news/michalz/fast-multi-platform-simd-math-library-in-zig-2adn).
+
+## Getting started
+
+Copy `zmath` into a subdirectory of your project and add the following to your `build.zig.zon` .dependencies:
+```zig
+    .zmath = .{ .path = "libs/zmath" },
+```
+
+Then in your `build.zig` add:
+
+```zig
+pub fn build(b: *std.Build) void {
+    const exe = b.addExecutable(.{ ... });
+
+    const zmath = b.dependency("zmath", .{});
+    exe.root_module.addImport("zmath", zmath.module("root"));
+}
+```
+
+Now in your code you may import and use zmath:
+
+```zig
+const zm = @import("zmath");
+
+pub fn main() !void {
+    //
+    // OpenGL/Vulkan example
+    //
+    const object_to_world = zm.rotationY(..);
+    const world_to_view = zm.lookAtRh(
+        zm.f32x4(3.0, 3.0, 3.0, 1.0), // eye position
+        zm.f32x4(0.0, 0.0, 0.0, 1.0), // focus point
+        zm.f32x4(0.0, 1.0, 0.0, 0.0), // up direction ('w' coord is zero because this is a vector not a point)
+    );
+    // `perspectiveFovRhGl` produces Z values in [-1.0, 1.0] range (Vulkan app should use `perspectiveFovRh`)
+    const view_to_clip = zm.perspectiveFovRhGl(0.25 * math.pi, aspect_ratio, 0.1, 20.0);
+
+    const object_to_view = zm.mul(object_to_world, world_to_view);
+    const object_to_clip = zm.mul(object_to_view, view_to_clip);
+
+    // Transposition is needed because GLSL uses column-major matrices by default
+    gl.uniformMatrix4fv(0, 1, gl.TRUE, zm.arrNPtr(&object_to_clip));
+    
+    // In GLSL: gl_Position = vec4(in_position, 1.0) * object_to_clip;
+    
+    //
+    // DirectX example
+    //
+    const object_to_world = zm.rotationY(..);
+    const world_to_view = zm.lookAtLh(
+        zm.f32x4(3.0, 3.0, -3.0, 1.0), // eye position
+        zm.f32x4(0.0, 0.0, 0.0, 1.0), // focus point
+        zm.f32x4(0.0, 1.0, 0.0, 0.0), // up direction ('w' coord is zero because this is a vector not a point)
+    );
+    const view_to_clip = zm.perspectiveFovLh(0.25 * math.pi, aspect_ratio, 0.1, 20.0);
+
+    const object_to_view = zm.mul(object_to_world, world_to_view);
+    const object_to_clip = zm.mul(object_to_view, view_to_clip);
+    
+    // Transposition is needed because HLSL uses column-major matrices by default
+    const mem = allocateUploadMemory(...);
+    zm.storeMat(mem, zm.transpose(object_to_clip));
+    
+    // In HLSL: out_position_sv = mul(float4(in_position, 1.0), object_to_clip);
+    
+    //
+    // 'WASD' camera movement example
+    //
+    {
+        const speed = zm.f32x4s(10.0);
+        const delta_time = zm.f32x4s(demo.frame_stats.delta_time);
+        const transform = zm.mul(zm.rotationX(demo.camera.pitch), zm.rotationY(demo.camera.yaw));
+        var forward = zm.normalize3(zm.mul(zm.f32x4(0.0, 0.0, 1.0, 0.0), transform));
+
+        zm.storeArr3(&demo.camera.forward, forward);
+
+        const right = speed * delta_time * zm.normalize3(zm.cross3(zm.f32x4(0.0, 1.0, 0.0, 0.0), forward));
+        forward = speed * delta_time * forward;
+
+        var cam_pos = zm.loadArr3(demo.camera.position);
+
+        if (keyDown('W')) {
+            cam_pos += forward;
+        } else if (keyDown('S')) {
+            cam_pos -= forward;
+        }
+        if (keyDown('D')) {
+            cam_pos += right;
+        } else if (keyDown('A')) {
+            cam_pos -= right;
+        }
+
+        zm.storeArr3(&demo.camera.position, cam_pos);
+    }
+   
+    //
+    // SIMD wave equation solver example (works with vector width 4, 8 and 16)
+    // 'T' can be F32x4, F32x8 or F32x16
+    //
+    var z_index: i32 = 0;
+    while (z_index < grid_size) : (z_index += 1) {
+        const z = scale * @intToFloat(f32, z_index - grid_size / 2);
+        const vz = zm.splat(T, z);
+
+        var x_index: i32 = 0;
+        while (x_index < grid_size) : (x_index += zm.veclen(T)) {
+            const x = scale * @intToFloat(f32, x_index - grid_size / 2);
+            const vx = zm.splat(T, x) + voffset * zm.splat(T, scale);
+
+            const d = zm.sqrt(vx * vx + vz * vz);
+            const vy = zm.sin(d - vtime);
+
+            const index = @intCast(usize, x_index + z_index * grid_size);
+            zm.store(xslice[index..], vx, 0);
+            zm.store(yslice[index..], vy, 0);
+            zm.store(zslice[index..], vz, 0);
+        }
+    }
+}
+```

build.zig

@@ -0,0 +1,62 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+
+    const options = .{
+        .optimize = b.option(
+            std.builtin.OptimizeMode,
+            "optimize",
+            "Select optimization mode",
+        ) orelse b.standardOptimizeOption(.{
+            .preferred_optimize_mode = .ReleaseFast,
+        }),
+        .enable_cross_platform_determinism = b.option(
+            bool,
+            "enable_cross_platform_determinism",
+            "Enable cross-platform determinism",
+        ) orelse true,
+    };
+
+    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 options_module = options_step.createModule();
+
+    const zmath = b.addModule("root", .{
+        .root_source_file = b.path("src/main.zig"),
+        .imports = &.{
+            .{ .name = "zmath_options", .module = options_module },
+        },
+    });
+
+    const test_step = b.step("test", "Run zmath tests");
+
+    const tests = b.addTest(.{
+        .name = "zmath-tests",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = options.optimize,
+    });
+    b.installArtifact(tests);
+
+    tests.root_module.addImport("zmath_options", options_module);
+
+    test_step.dependOn(&b.addRunArtifact(tests).step);
+
+    const benchmark_step = b.step("benchmark", "Run zmath benchmarks");
+
+    const benchmarks = b.addExecutable(.{
+        .name = "zmath-benchmarks",
+        .root_source_file = b.path("src/benchmark.zig"),
+        .target = target,
+        .optimize = options.optimize,
+    });
+    b.installArtifact(benchmarks);
+
+    benchmarks.root_module.addImport("zmath", zmath);
+
+    benchmark_step.dependOn(&b.addRunArtifact(benchmarks).step);
+}

build.zig.zon

@@ -0,0 +1,11 @@
+.{
+    .name = "zmath",
+    .version = "0.11.0-dev",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "README.md",
+        "LICENSE",
+    },
+}