dev

Arthapz · Arthapz · commit e69a5aba120a · 2026-03-06T15:15:37.000+01:00
diff --git a/game/xmake.lua b/game/xmake.lua
@@ -2,7 +2,7 @@ target("game", function()
     set_kind("binary")
     set_languages("cxxlatest", "clatest")
 
-    add_rules("compile.shaders")
+    add_rules("wgsl.compile.shaders")
 
     add_rules(stormkit_rule_prefix .. "stormkit::application")
     set_values("stormkit.components", { "stormkit", "log", "entities", "image", "wsi", "gpu", "lua" })
@@ -18,6 +18,8 @@ target("game", function()
 
     add_deps("stormkit::engine")
 
+    add_packages("slang")
+
     on_load(function(target)
         if get_config("devmode") then
             import("core.project.config")
diff --git a/shaders/sprite_renderer/quad_sprite.nzsl b/shaders/sprite_renderer/quad_sprite.nzsl
@@ -12,7 +12,7 @@ struct VertOut {
     [location(0)] uv: vec2[f32]
 }
 
-[layout(std140)]
+[layout(std140), spirv(RowMajor)]
 struct Camera {
     proj: mat4[f32],
     view: mat4[f32],
diff --git a/shaders/sprite_renderer/quad_sprite.slang b/shaders/sprite_renderer/quad_sprite.slang
@@ -0,0 +1,25 @@
+struct VertexOut {
+  float3 position: SV_Position;
+  float2 uv;
+};
+
+struct FragmentOut {
+    float4 color: SV_Target<0>;
+}
+
+[shader("vertex")]
+VertexOut vs_main() {
+   VertexOutput out;
+   out.color = float4(input.uv, 0., 1.);
+   out.uv = input.uv;
+
+   return out;
+}
+
+[shader("fragment")]
+FragmentOut frag_main(VertexOut in) {
+   FragmentOut out;
+   out.color = float4(input.uv, 0., 1.);
+
+   return out;
+}
diff --git a/shaders/sprite_renderer/quad_sprite.wgsl b/shaders/sprite_renderer/quad_sprite.wgsl
@@ -0,0 +1,42 @@
+struct VertIn {
+    @location(0) position: vec2f,
+    @location(1) uv: vec2f
+}
+
+struct VertOut {
+    @builtin(position) position: vec4f, 
+    @location(0) uv: vec2f
+}
+
+struct Camera {
+    proj: mat4x4f,
+    view: mat4x4f,
+}
+
+@binding(0) @group(0)
+var<uniform> camera: Camera;
+
+@vertex fn vert_main(input: VertIn) -> VertOut {
+    var output: VertOut;
+
+    output.position = camera.proj * camera.view * vec4f(input.position, 1., 1.);
+    output.uv    = input.uv;
+
+    return output;
+}
+
+struct FragIn {
+    @location(0) uv: vec2f
+}
+
+struct FragOut {
+    @location(0) color: vec4f
+}
+
+@fragment fn frag_main(input: FragIn) -> FragOut {
+    var output: FragOut;
+
+    output.color = vec4f(input.uv, 1., 1.);
+
+    return output;
+}
diff --git a/src/sprite_renderer.cpp b/src/sprite_renderer.cpp
@@ -131,6 +131,7 @@ namespace stormkit::engine {
                 .input_assembly_state = { gpu::PrimitiveTopology::TRIANGLE_STRIP },
                 .viewport_state       = { .viewports = { window_viewport },
                                          .scissors  = { scissor }, },
+                .rasterization_state = { .cull_mode = gpu::CullModeFlag::NONE, },
                 .color_blend_state = { .attachments = { { .blend_enable           = true,
                                        .src_color_blend_factor = gpu::BlendFactor::SRC_ALPHA,
                                        .dst_color_blend_factor = gpu::BlendFactor::ONE_MINUS_SRC_ALPHA,
@@ -142,14 +143,15 @@ namespace stormkit::engine {
                 .binding_descriptions = SPRITE_VERTEX_BINDING_DESCRIPTIONS | stdr::to<std::vector>(),
                 .input_attribute_descriptions= SPRITE_VERTEX_ATTRIBUTE_DESCRIPTIONS | stdr::to<std::vector>(),
             },
-        };
+}; // namespace stormkit::engine
 
         m_render_data.descriptor_set_layout = Try(gpu::DescriptorSetLayout::create(
           device,
           into_dyn_array<
             gpu::DescriptorSetLayoutBinding>(Camera::layout_binding()
                                              // gpu::DescriptorSetLayoutBinding {
-                                             //                                  1, gpu::DescriptorType::COMBINED_IMAGE_SAMPLER,
+                                             //                                  1,
+                                             //                                  gpu::DescriptorType::COMBINED_IMAGE_SAMPLER,
                                              //                                  gpu::ShaderStageFlag::FRAGMENT,
                                              //                                  1 }
                                              )));
@@ -171,10 +173,27 @@ namespace stormkit::engine {
         m_render_data
           .camera_descriptor_set = Try(m_render_data.descriptor_pool->create_descriptor_set(m_render_data.descriptor_set_layout));
 
-        m_camera.projection = math::orthographique(window_viewport.position.x,
-                                                   window_viewport.extent.width,
-                                                   window_viewport.position.y,
-                                                   window_viewport.extent.height);
+        const auto ortho = [](auto& out, f32 left, f32 right, f32 bottom, f32 top) {
+            out = math::fmat4::identity();
+
+            out[0, 0] = f32 { 2 } / (right - left);
+            out[1, 1] = f32 { 2 } / (top - bottom);
+            out[2, 2] = -f32 { 1 };
+
+            out[0, 3] = -(right + left) / (right - left);
+            out[1, 3] = -(top + bottom) / (top - bottom);
+            out[2, 3] = -f32 { 1 };
+        };
+
+        ortho(m_camera.projection,
+              window_viewport.position.x,
+              window_viewport.extent.width,
+              window_viewport.position.y,
+              window_viewport.extent.height);
+        // m_camera.projection = math::orthographique(window_viewport.position.x,
+        //                                            window_viewport.extent.width,
+        //                                            window_viewport.position.y,
+        //                                            window_viewport.extent.height);
         std::println("{}", m_camera.projection);
         Return {};
     }
@@ -276,8 +295,8 @@ namespace stormkit::engine {
 
                   std::array<SpriteVertex, 4> vertices = {
                       SpriteVertex { { 0.f, 0.f },     { 0.f, 0.f } },
-                      SpriteVertex { { 0.f, 100.f },   { 0.f, 1.f } },
                       SpriteVertex { { 100.f, 0.f },   { 1.f, 0.f } },
+                      SpriteVertex { { 0.f, 100.f },   { 0.f, 1.f } },
                       SpriteVertex { { 100.f, 100.f }, { 1.f, 1.f } },
                   };
                   vertex_staging_buffer.upload(as_bytes(vertices));
@@ -287,7 +306,10 @@ namespace stormkit::engine {
                   auto&       camera_staging_buffer = frame_resources.get_buffer(data.camera_staging_buffer_id);
                   const auto& camera_buffer         = frame_resources.get_buffer(data.camera_buffer_id);
 
-                  camera_staging_buffer.upload(as_bytes(m_camera));
+                  auto camera       = auto(m_camera);
+                  camera.projection = math::transpose(camera.projection);
+                  camera.view       = math::transpose(camera.view);
+                  camera_staging_buffer.upload(as_bytes(camera));
 
                   cmb.copy_buffer(camera_staging_buffer, camera_buffer, sizeof(Camera));
               });
diff --git a/xmake.lua b/xmake.lua
@@ -149,13 +149,13 @@ add_requires(stormkit_dep_name, {
 if is_mode("debug") or is_mode("reldbg") then add_cxflags("clang::-ggdb3") end
 
 namespace("stormkit", function()
-    includes("xmake/rules/*.xmake.lua")
+    includes("xmake/rules/slang.xmake.lua")
 
     target("engine", function()
         set_kind("$(kind)")
         set_languages("cxxlatest", "clatest")
 
-        add_rules("compile.shaders")
+        add_rules("wgsl.compile.shaders")
 
         set_basename("stormkit-engine")
 
@@ -166,12 +166,14 @@ namespace("stormkit", function()
 
         add_files("modules/stormkit/**.cppm", { public = true })
         add_files("src/**.cpp")
-        add_files("shaders/**.nzsl")
+        add_files("shaders/**.wgsl")
 
         add_defines("STORMKIT_ENGINE_BUILD", { public = false })
 
         add_embeddirs("$(builddir)/shaders")
         add_cxflags("--embed-dir=$(builddir)/shaders")
+
+        add_packages("slang")
     end)
 
     includes("game/xmake.lua")
diff --git a/xmake/rules/slang.xmake.lua b/xmake/rules/slang.xmake.lua
@@ -0,0 +1,85 @@
+add_requires("wgpu-native", {
+    system = false,
+    configs = {
+        naga = true,
+    },
+})
+
+rule("wgsl.find_naga", function()
+    on_config(function(target)
+        import("core.project.project")
+        import("core.tool.toolchain")
+        import("lib.detect.find_tool")
+
+        -- on windows+asan we need run envs because of .dll dependencies which may be not part of the PATH
+        local envs
+        if is_plat("windows") then
+            local msvc = target:toolchain("msvc")
+            if msvc and msvc:check() then envs = msvc:runenvs() end
+        end
+        target:data_set("wgsl_envs", envs)
+
+        -- find wgsl binaries
+        local wgsl = project.required_package("wgpu-native~host") or project.required_package("wgpu-native")
+        local wgsldir
+        if wgsl then
+            wgsldir = path.join(wgsl:installdir(), "bin")
+            local osenvs = os.getenvs()
+            envs = envs or {}
+            for env, values in pairs(wgsl:get("envs")) do
+                local flatval = path.joinenv(values)
+                local oldenv = envs[env] or osenvs[env]
+                if not oldenv or oldenv == "" then
+                    envs[env] = flatval
+                elseif not oldenv:startswith(flatval) then
+                    envs[env] = flatval .. path.envsep() .. oldenv
+                end
+            end
+        end
+
+        local naga = find_tool("naga", { version = false, paths = wgsldir, envs = envs, check = "--help" })
+        assert(naga, "naga not found! please install wgsl package with naga enabled")
+
+        target:data_set("naga", naga)
+        target:data_set("naga_runenv", envs)
+    end)
+end)
+
+-- Compile shaders to includables headers
+rule("wgsl.compile.shaders", function()
+    set_extensions(".wgsl")
+    add_deps("wgsl.find_naga")
+    before_buildcmd_file(function(target, batchcmds, shaderfile, opt)
+        import("lib.detect.find_tool")
+        import("utils.progress")
+
+        local outputdir = path.join(import("core.project.config").builddir(), "shaders")
+        local naga = target:data("naga")
+        local runenvs = target:data("naga_runenv")
+        assert(naga, "naga not found! please install wgsl package with naga enabled")
+
+        local outputfile = path.join(outputdir or path.directory(shaderfile), path.basename(shaderfile) .. ".spv")
+
+        -- add commands
+        if progress.apply_target then opt.progress = progress.apply_target(target, opt.progress) end
+        batchcmds:show_progress(opt.progress, "${color.build.object}compiling.shader %s", shaderfile)
+        local argv = {
+            "--spirv-version",
+            "1.3",
+            shaderfile,
+        }
+        if outputdir then
+            batchcmds:mkdir(outputdir)
+            local outputfile = path.join(outputdir, path.basename(shaderfile) .. ".spv")
+            table.insert(argv, outputfile)
+        end
+
+        batchcmds:vrunv(naga.program, argv, { curdir = ".", envs = runenvs })
+
+        -- add deps
+        batchcmds:add_depfiles(shaderfile)
+        batchcmds:add_depvalues(naga.version)
+        batchcmds:set_depmtime(os.mtime(outputfile))
+        batchcmds:set_depcache(target:dependfile(outputfile))
+    end)
+end)

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ struct VertOut {`
`12`	`12`	`[location(0)] uv: vec2[f32]`
`13`	`13`	`}`
`14`	`14`
`15`		`-[layout(std140)]`
	`15`	`+[layout(std140), spirv(RowMajor)]`
`16`	`16`	`struct Camera {`
`17`	`17`	`proj: mat4[f32],`
`18`	`18`	`view: mat4[f32],`