From 274255556da8c419a54b76347ddd9c3d9f6d9ec2 Mon Sep 17 00:00:00 2001 From: Peter Li Date: Thu, 1 May 2025 22:20:32 -0700 Subject: [PATCH] I have a working skybox now --- engine/rend/build.zig | 3 + engine/rend/shaders/lit_mesh.frag.hlsl | 7 +- engine/rend/shaders/skybox.frag.hlsl | 8 ++ engine/rend/shaders/skybox.frag.json | 38 ++++++ engine/rend/shaders/skybox.vert.hlsl | 27 ++++ engine/rend/shaders/skybox.vert.json | 45 +++++++ engine/rend/src/camera/CameraComponent.zig | 4 + engine/rend/src/rend.zig | 2 + engine/rend/src/sgpu/TextureList.zig | 123 +++++++++++++++++- engine/rend/src/sgpu/renderer.zig | 116 ++++++++++++++++- engine/rend/src/texture/texture.zig | 1 + .../content/_shaders/dxil/lit_mesh.frag.dxil | Bin 6304 -> 6304 bytes .../content/_shaders/dxil/skybox.frag.dxil | Bin 0 -> 3768 bytes .../content/_shaders/dxil/skybox.vert.dxil | Bin 0 -> 3848 bytes .../content/_shaders/msl/lit_mesh.frag.msl | 2 +- projects/content/_shaders/msl/skybox.frag.msl | 22 ++++ projects/content/_shaders/msl/skybox.vert.msl | 29 +++++ .../content/_shaders/spv/lit_mesh.frag.spv | Bin 4900 -> 4900 bytes projects/content/_shaders/spv/skybox.frag.spv | Bin 0 -> 868 bytes projects/content/_shaders/spv/skybox.vert.spv | Bin 0 -> 880 bytes projects/sampleGame/main.zig | 17 +++ 21 files changed, 432 insertions(+), 12 deletions(-) create mode 100644 engine/rend/shaders/skybox.frag.hlsl create mode 100644 engine/rend/shaders/skybox.frag.json create mode 100644 engine/rend/shaders/skybox.vert.hlsl create mode 100644 engine/rend/shaders/skybox.vert.json create mode 100644 projects/content/_shaders/dxil/skybox.frag.dxil create mode 100644 projects/content/_shaders/dxil/skybox.vert.dxil create mode 100644 projects/content/_shaders/msl/skybox.frag.msl create mode 100644 projects/content/_shaders/msl/skybox.vert.msl create mode 100644 projects/content/_shaders/spv/skybox.frag.spv create mode 100644 projects/content/_shaders/spv/skybox.vert.spv diff --git a/engine/rend/build.zig b/engine/rend/build.zig index c1faebd..40a4efc 100644 --- a/engine/rend/build.zig +++ b/engine/rend/build.zig @@ -41,6 +41,9 @@ pub fn build(b: *std.Build) void { sdl3.shaderDefintion(b, mod, "../../lib/sdl3", optimize, "depthOnly.frag", b.path("shaders/depthOnly.frag.json")); + sdl3.shaderDefintion(b, mod, "../../lib/sdl3", optimize, "skybox.frag", b.path("shaders/skybox.frag.json")); + sdl3.shaderDefintion(b, mod, "../../lib/sdl3", optimize, "skybox.vert", b.path("shaders/skybox.vert.json")); + // ========== tests ========== const tests = b.addTest(.{ .target = target, diff --git a/engine/rend/shaders/lit_mesh.frag.hlsl b/engine/rend/shaders/lit_mesh.frag.hlsl index 9c4f539..1bf6b2e 100644 --- a/engine/rend/shaders/lit_mesh.frag.hlsl +++ b/engine/rend/shaders/lit_mesh.frag.hlsl @@ -4,6 +4,7 @@ SamplerState Sampler : register(s0, space2); Texture2D DirectionalShadowDepthMap : register(t1, space2); SamplerState DirectionalShadowSampler : register(s1, space2); + cbuffer Uniforms : register(b0, space3) { float4 viewPos; @@ -111,7 +112,7 @@ float shadowCalculationPCF(float3 fragPos, float4 DirectionalShadowFragPos) uv.y = -uv.y; float fragDepth = DirectionalShadowFragPos.z; float combinedShadow = 0.0; - float bias = 0.001; + float bias = 0.005; for (int y = -range ; y <= range ; y++) { for (int x = -range ; x <= range ; x++) { @@ -124,8 +125,8 @@ float shadowCalculationPCF(float3 fragPos, float4 DirectionalShadowFragPos) } } - combinedDepth = combinedDepth / count; - combinedShadow = combinedShadow / count; + combinedDepth = combinedDepth / (count); + combinedShadow = combinedShadow / (count); // float fragDepth = DirectionalShadowFragPos.z; // float shadow = fragDepth - bias > combinedDepth ? 1.0 : 0.0; diff --git a/engine/rend/shaders/skybox.frag.hlsl b/engine/rend/shaders/skybox.frag.hlsl new file mode 100644 index 0000000..012bb87 --- /dev/null +++ b/engine/rend/shaders/skybox.frag.hlsl @@ -0,0 +1,8 @@ +TextureCube SkyboxTexture : register(t0, space2); +SamplerState SkyboxSampler : register(s0, space2); + +float4 main(float3 TexCoord : TEXCOORD0) : SV_Target0 +{ + return pow(SkyboxTexture.Sample(SkyboxSampler, TexCoord), 1.0/2.2); +} + diff --git a/engine/rend/shaders/skybox.frag.json b/engine/rend/shaders/skybox.frag.json new file mode 100644 index 0000000..fcf3482 --- /dev/null +++ b/engine/rend/shaders/skybox.frag.json @@ -0,0 +1,38 @@ +{ + "entryPoints" : [ + { + "name" : "main", + "mode" : "frag" + } + ], + "inputs" : [ + { + "type" : "vec3", + "name" : "in.var.TEXCOORD0", + "location" : 0 + } + ], + "outputs" : [ + { + "type" : "vec4", + "name" : "out.var.SV_Target0", + "location" : 0 + } + ], + "separate_images" : [ + { + "type" : "textureCube", + "name" : "SkyboxTexture", + "set" : 2, + "binding" : 0 + } + ], + "separate_samplers" : [ + { + "type" : "sampler", + "name" : "SkyboxSampler", + "set" : 2, + "binding" : 0 + } + ] +} \ No newline at end of file diff --git a/engine/rend/shaders/skybox.vert.hlsl b/engine/rend/shaders/skybox.vert.hlsl new file mode 100644 index 0000000..16dfadc --- /dev/null +++ b/engine/rend/shaders/skybox.vert.hlsl @@ -0,0 +1,27 @@ +struct Input +{ + float3 Position : TEXCOORD0; + + uint Instance : SV_InstanceID; +}; + +cbuffer Uniforms : register(b0, space1) +{ + float4x4 ViewProjection : packoffset(c0); +}; + +struct Output +{ + float3 UVW : TEXCOORD0; + float4 Position : SV_Position; +}; + +Output main(Input input) +{ + Output output; + float4 pos = float4(input.Position, 1.0); + output.Position = mul(ViewProjection, pos); + output.UVW = input.Position; + + return output; +} diff --git a/engine/rend/shaders/skybox.vert.json b/engine/rend/shaders/skybox.vert.json new file mode 100644 index 0000000..7d31c04 --- /dev/null +++ b/engine/rend/shaders/skybox.vert.json @@ -0,0 +1,45 @@ +{ + "entryPoints" : [ + { + "name" : "main", + "mode" : "vert" + } + ], + "types" : { + "_5" : { + "name" : "type.Uniforms", + "members" : [ + { + "name" : "ViewProjection", + "type" : "mat4", + "offset" : 0, + "matrix_stride" : 16, + "row_major" : true + } + ] + } + }, + "inputs" : [ + { + "type" : "vec3", + "name" : "in.var.TEXCOORD0", + "location" : 0 + } + ], + "outputs" : [ + { + "type" : "vec3", + "name" : "out.var.TEXCOORD0", + "location" : 0 + } + ], + "ubos" : [ + { + "type" : "_5", + "name" : "type.Uniforms", + "block_size" : 64, + "set" : 1, + "binding" : 0 + } + ] +} \ No newline at end of file diff --git a/engine/rend/src/camera/CameraComponent.zig b/engine/rend/src/camera/CameraComponent.zig index bc44f11..3358551 100644 --- a/engine/rend/src/camera/CameraComponent.zig +++ b/engine/rend/src/camera/CameraComponent.zig @@ -26,6 +26,7 @@ roll: f32 = 0, finalPos: core.Vectorf = .{}, final: Mat = zm.identity(), finalAlt: Mat = zm.identity(), +noTranslate: Mat = zm.identity(), entity: core.Entity = undefined, @@ -90,6 +91,9 @@ pub fn resolve(self: *@This()) void { // self.transform = core.zm.identity(); self.transform = mul(core.zm.matFromQuat(rotation.quat), self.transform); + + self.noTranslate = mul(self.transform, self.projection); + self.transform = mul(core.zm.translationV(position.toZm()), self.transform); self.final = mul(self.transform, self.projection); // core.engine_log("{any}", .{self.final}); diff --git a/engine/rend/src/rend.zig b/engine/rend/src/rend.zig index 07d8f76..a6e6a6e 100644 --- a/engine/rend/src/rend.zig +++ b/engine/rend/src/rend.zig @@ -34,6 +34,8 @@ pub const getTexture = renderer.getTexture; pub const texture = @import("texture/texture.zig"); pub const Texture = texture.Texture; +pub const setSkyboxTexture = renderer.setSkyboxTexture; + var rendAllocator: std.mem.Allocator = undefined; pub fn getAllocator() std.mem.Allocator { return rendAllocator; diff --git a/engine/rend/src/sgpu/TextureList.zig b/engine/rend/src/sgpu/TextureList.zig index 559fb09..b118208 100644 --- a/engine/rend/src/sgpu/TextureList.zig +++ b/engine/rend/src/sgpu/TextureList.zig @@ -33,11 +33,132 @@ pub fn loadAsset(self: *@This(), assetRef: assets.AssetRef, propertiesBag: ?asse var name = assetRef.name; core.engine_log("loading texture {s}", .{name.utf8()}); if (propertiesBag) |bag| { - const installed = self.uploadTextureFromPath(name, bag.path) catch return error.UnableToLoad; + var installed: *Texture = undefined; + if (bag.textureCube) { + const pathList = bag.textureList.?; + core.engine_log("loading textures as a cubemap\n {s}\n {s}\n {s}\n {s}\n {s}\n {s}", .{ + pathList[0], + pathList[1], + pathList[2], + pathList[3], + pathList[4], + pathList[5], + }); + + installed = self.uploadCubeFromPaths(name, pathList) catch return error.UnableToLoad; + } else { + installed = self.uploadTextureFromPath(name, bag.path) catch return error.UnableToLoad; + } + self.map.put(self.allocator, name.handle(), installed) catch return error.UnableToLoad; } } +pub fn uploadCubeFromPaths(self: *@This(), name: core.Name, paths: []const []const u8) !*Texture { + if (paths.len != 6) { + return error.CubeNeedsSixFaces; + } + + var cubeList = std.ArrayList(core.png.PngContents).init(self.allocator); + defer cubeList.deinit(); + + var gpuTexture: *gpu.GPUTexture = undefined; + + var first: bool = true; + var textureSize: u32 = 0; + + for (paths) |path| { + try cubeList.append(try core.png.PngContents.initFromFS(core.fs(), self.allocator, path)); + const png = &cubeList.items[cubeList.items.len - 1]; + + const cmd = self.device.acquireGPUCommandBuffer(); + + const copyPass = cmd.beginGPUCopyPass(); + + if (first) { + first = false; + + textureSize = cubeList.items[0].size.x; + + var tci: gpu.GPUTextureCreateInfo = std.mem.zeroInit(gpu.GPUTextureCreateInfo, .{ + .type = .texturetypeCube, + .format = .textureformatR8g8b8a8UnormSrgb, + .usage = .{ .textureusageSampler = true }, + .width = textureSize, + .height = textureSize, + .layer_count_or_depth = 6, + .num_levels = 1, + }); + + gpuTexture = self.device.createGPUTexture(&tci); + + try core.assert(cubeList.items[0].size.x == cubeList.items[0].size.y); + } + + const transferBuffer = self.device.createGPUTransferBuffer(&.{ + .usage = .transferbufferusageUpload, + .size = textureSize * textureSize * @sizeOf(u32), + .props = 0, + }); + + defer self.device.releaseGPUTransferBuffer(transferBuffer); + + const gtti: gpu.GPUTextureTransferInfo = .{ + .transfer_buffer = transferBuffer, + .offset = 0, + .pixels_per_row = textureSize, + .rows_per_layer = textureSize, + }; + + const data: [*]u8 = @ptrCast(self.device.mapGPUTransferBuffer(transferBuffer, false)); + for (png.pixels, 0..) |pixel, i| { + data[i] = pixel; + } + + // todo + // TextureCube SkyboxTexture : register(t0, space2); + // SamplerState SkyboxSampler : register(s0, space2); + + const textureRegion = std.mem.zeroInit(gpu.GPUTextureRegion, .{ + .texture = gpuTexture, + .w = textureSize, + .h = textureSize, + .d = 1, + .layer = @as(u32, @intCast(cubeList.items.len - 1)), + }); + + copyPass.uploadToGPUTexture(>ti, &textureRegion, false); + + copyPass.endGPUCopyPass(); + + _ = cmd.submitGPUCommandBuffer(); + } + + // what the fuck do we even do here. + + // cubemapfacePositivex, right + // cubemapfaceNegativex, left + // cubemapfacePositivey, up + // cubemapfaceNegativey, down + // cubemapfacePositivez, forward + // cubemapfaceNegativez, backward + + for (cubeList.items) |*i| { + i.deinit(); + } + const tex = try self.allocator.create(Texture); + tex.* = .{ + .id = 0, + .format = .f32_rgba, + .usage = .{ .cube = true }, + .size = .{ .x = textureSize, .y = textureSize }, + .name = name, + .texture = gpuTexture, + }; + + return tex; +} + pub fn uploadTextureFromPath(self: *@This(), name: core.Name, path: []const u8) !*Texture { var png = try core.png.PngContents.initFromFS(core.fs(), self.allocator, path); defer png.deinit(); diff --git a/engine/rend/src/sgpu/renderer.zig b/engine/rend/src/sgpu/renderer.zig index a2477ae..3f6d606 100644 --- a/engine/rend/src/sgpu/renderer.zig +++ b/engine/rend/src/sgpu/renderer.zig @@ -44,6 +44,7 @@ pub const Renderer = struct { shadowMapProjection: core.Transform = core.zm.identity(), blockySampler: *gpu.GPUSampler = undefined, + cubeSampler: *gpu.GPUSampler = undefined, defaultTexture: *rend.Texture = undefined, lightPosition: core.Vectorf = .{}, @@ -65,6 +66,14 @@ pub const Renderer = struct { // transients DO NOT TOUCH swapchainTexture: ?*gpu.GPUTexture = undefined, + skyboxMesh: ?rend.IndexedMesh = null, + skyboxTexture: ?*rend.Texture = null, + skyboxTextureName: ?core.Name = null, + skyboxPipeline: *gpu.GPUGraphicsPipeline = undefined, + skyboxColor: core.colors.Color = .{ .r = 71.0 / 256.0, .g = 200.0 / 256.0, .b = 1.0, .a = 1.0 }, + + skyboxMeshName: core.Name = core.DefineName("m_skybox"), + pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This()); pub const MaxObjectCount = 50000; @@ -124,13 +133,12 @@ pub const Renderer = struct { .{ .path = "meshes/primitive_box.obj" }, ), ); - var defaultTextureName = core.MakeName("t_default"); self.defaultTexture = getTexture(&defaultTextureName).?; - self.debugDrawSys = try self.createRendererEngineObject(DebugDrawSystem); try self.createDirectionalShadowsPipeline(); + try self.setupSkybox(); } pub fn createDirectionalShadowsPipeline(self: *@This()) !void { @@ -138,6 +146,50 @@ pub const Renderer = struct { try self.createShadowCastingPipeline(); } + pub fn setupSkybox(self: *@This()) !void { + try assets.load( + assets.MakeImportRefOptions( + "Mesh", + "m_skybox", + .{ .path = "meshes/skybox.obj" }, + ), + ); + + try self.createSkyboxPipeline(); + } + + pub fn createSkyboxPipeline(self: *@This()) !void { + const vertex = try self.loadShader("skybox.vert", skybox_vert.LoadArgs); + const fragment = try self.loadShader("skybox.frag", skybox_frag.LoadArgs); + + var pci = std.mem.zeroes(gpu.GPUGraphicsPipelineCreateInfo); + pci.vertex_shader = vertex; + pci.fragment_shader = fragment; + + var attributes = try self.generateVertexAttributeList(); + defer attributes.deinit(); + + pci.vertex_input_state = .{ + .num_vertex_buffers = 1, + .vertex_buffer_descriptions = &[_]gpu.GPUVertexBufferDescription{ + .{ .slot = 0, .pitch = @sizeOf(rend.MeshVertex), .input_rate = .vertexinputrateVertex, .instance_step_rate = 0 }, + }, + .num_vertex_attributes = @intCast(attributes.items.len), + .vertex_attributes = @ptrCast(attributes.items.ptr), + }; + + pci.target_info.num_color_targets = 1; + pci.target_info.color_target_descriptions = &[_]gpu.GPUColorTargetDescription{ + .{ + .format = self.device.getGPUSwapchainTextureFormat(self.window), + .blend_state = std.mem.zeroes(gpu.GPUColorTargetBlendState), + }, + }; + + pci.rasterizer_state.fill_mode = .fillmodeFill; + self.skyboxPipeline = self.device.createGPUGraphicsPipeline(&pci); + } + pub fn createSamplers(self: *@This()) !void { core.engine_log("creating blocky sampler", .{}); self.blockySampler = self.device.createGPUSampler(&std.mem.zeroInit(gpu.GPUSamplerCreateInfo, .{ @@ -427,6 +479,17 @@ pub const Renderer = struct { return rv; } + pub fn uploadSkyboxUniforms(self: *@This(), cmd: *gpu.GPUCommandBuffer) void { + var data = std.mem.zeroes([@sizeOf(skybox_vert.Uniforms) / 8 + 1]usize); + const ptr: *skybox_vert.Uniforms = @ptrCast(@alignCast(&data)); + + if (self.activeCamera) |camera| { + ptr.ViewProjection = @bitCast(camera.noTranslate); + } + + cmd.pushGPUVertexUniformData(0, &data, @sizeOf(skybox_vert.Uniforms)); + } + pub fn uploadUniforms(self: *@This(), cmd: *gpu.GPUCommandBuffer) !void { { var data = std.mem.zeroes([@sizeOf(meshes_vert.Uniforms) / 8 + 1]usize); @@ -441,6 +504,7 @@ pub const Renderer = struct { cmd.pushGPUVertexUniformData(0, &data, @sizeOf(meshes_vert.Uniforms)); } + { var data = std.mem.zeroes([@sizeOf(lit_mesh_frag.Uniforms) / 8 + 1]usize); const ptr: *lit_mesh_frag.Uniforms = @ptrCast(@alignCast(&data)); @@ -589,13 +653,42 @@ pub const Renderer = struct { _ = cmd.submitGPUCommandBuffer(); return; } - try self.uploadUniforms(cmd); + // render the skybox + { + if (self.skyboxMesh == null) { + self.skyboxMesh = getMeshByName(&self.skyboxMeshName); + } + if (self.skyboxTexture == null) { + if (self.skyboxTextureName) |*name| { + self.skyboxTexture = getTexture(name); + } + } + + if (self.skyboxTexture) |skyboxTexture| { + if (self.skyboxMesh) |skyboxMesh| { + const targetInfo: gpu.GPUColorTargetInfo = std.mem.zeroInit(gpu.GPUColorTargetInfo, .{ + .texture = self.swapchainTexture.?, + .clear_color = self.skyboxColor, + .load_op = .loadopClear, + .store_op = .storeopStore, + }); + + const renderpass = cmd.beginGPURenderPass(&targetInfo, 1, null); + + self.uploadSkyboxUniforms(cmd); + renderpass.bindGPUGraphicsPipeline(self.skyboxPipeline); + renderpass.bindGPUFragmentSamplers(0, &.{ .texture = skyboxTexture.texture, .sampler = self.blockySampler }, 1); + renderpass.drawGPUIndexedPrimitives(skyboxMesh.index.size, 1, skyboxMesh.index.start, @intCast(skyboxMesh.vertex.start), 0); + renderpass.endGPURenderPass(); + } + } + } // can cache this const targetInfo: gpu.GPUColorTargetInfo = std.mem.zeroInit(gpu.GPUColorTargetInfo, .{ .texture = self.swapchainTexture.?, - .clear_color = .{ .r = 71.0 / 256.0, .g = 200.0 / 256.0, .b = 1.0, .a = 1.0 }, - .load_op = .loadopClear, + .clear_color = self.skyboxColor, + .load_op = .loadopLoad, .store_op = .storeopStore, }); @@ -612,16 +705,18 @@ pub const Renderer = struct { const renderpass = cmd.beginGPURenderPass(&targetInfo, 1, &depthTarget); //renderpass.bindGPUGraphicsPipeline(self.testPipeline); - renderpass.bindGPUGraphicsPipeline(self.meshPipe); - renderpass.bindGPUVertexStorageBuffers(0, &self.ssboScene, 1); renderpass.bindGPUVertexBuffers(0, &.{ .buffer = self.meshPool.vertexBuffer, .offset = 0 }, 1); renderpass.bindGPUIndexBuffer(&.{ .buffer = self.meshPool.indexBuffer, .offset = 0 }, .indexelementsize32bit); + + // render the meshes + renderpass.bindGPUGraphicsPipeline(self.meshPipe); renderpass.bindGPUFragmentSamplers(1, &.{ .texture = self.shadowDepthTexture, .sampler = self.blockySampler }, 1); // todo move into materials system renderpass.setGPUScissor(&self.scissor); + try self.uploadUniforms(cmd); //rendering each mesh { const container = rend.MeshComponent.BaseContainer; @@ -693,6 +788,9 @@ const lit_mesh_frag = @import("lit_mesh.frag"); const depthOnly = @import("depthOnly.frag"); const sample_vert = @import("sample.vert"); +const skybox_vert = @import("skybox.vert"); +const skybox_frag = @import("skybox.frag"); + const MeshVertices = meshes_vert.Scene; const MeshUniforms = meshes_vert.Uniforms; @@ -743,6 +841,10 @@ pub fn registerRendererObject(comptime T: type, object: *anyopaque) !void { return try gRenderer.registerRendererObject(T, object); } +pub fn setSkyboxTexture(name: []const u8) void { + gRenderer.skyboxTextureName = core.MakeName(name); +} + pub const getMesh = mesh_pool.getMesh; pub const getMeshByName = mesh_pool.getMeshByName; pub const pushMeshUpdate = mesh_pool.pushMeshUpdate; diff --git a/engine/rend/src/texture/texture.zig b/engine/rend/src/texture/texture.zig index 07b7e37..b10bf66 100644 --- a/engine/rend/src/texture/texture.zig +++ b/engine/rend/src/texture/texture.zig @@ -4,6 +4,7 @@ pub const TextureFormat = enum(u8) { }; pub const TextureUsage = struct { mesh: bool = false, + cube: bool = false, }; // handle to a texture resource in the engine. diff --git a/projects/content/_shaders/dxil/lit_mesh.frag.dxil b/projects/content/_shaders/dxil/lit_mesh.frag.dxil index 66c8b39c0d793ce276f11cb0e263301bf3c15950..222e252da5841875a51b0056e631767b81cc168a 100644 GIT binary patch delta 61 zcmV-D0K)&EF`zLNL|8&Y(`4tw&K&1KQbs346&q5Zu@vMB5C~|eM2ElZOi^>qD}&0w TgtG_?aR&q{UY~lieG?-E1;H39 delta 61 zcmV-D0K)&EF`zLNL|8&Y-!F-#I;wAPoVyo(E!}spu@vMB5L2=X(hrTznwPF4RSYcu T)UyZ-aR&tNOqyu3eG?-EByAZ` diff --git a/projects/content/_shaders/dxil/skybox.frag.dxil b/projects/content/_shaders/dxil/skybox.frag.dxil new file mode 100644 index 0000000000000000000000000000000000000000..0ddc117bd2bfc6b8335148e41d9107be06ebc75e GIT binary patch literal 3768 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 DirectionalShadowDepthMap.sample(DirectionalShadowSampler, (_142 + float2(float(_163) * 0.000244140625, float(_154) * 0.000244140625))).x); + _150 += float((in.in_var_TEXCOORD3.z - 0.004999999888241291046142578125) > DirectionalShadowDepthMap.sample(DirectionalShadowSampler, (_142 + float2(float(_163) * 0.000244140625, float(_154) * 0.000244140625))).x); _163++; continue; } diff --git a/projects/content/_shaders/msl/skybox.frag.msl b/projects/content/_shaders/msl/skybox.frag.msl new file mode 100644 index 0000000..2c457a3 --- /dev/null +++ b/projects/content/_shaders/msl/skybox.frag.msl @@ -0,0 +1,22 @@ +#include +#include + +using namespace metal; + +struct main0_out +{ + float4 out_var_SV_Target0 [[color(0)]]; +}; + +struct main0_in +{ + float3 in_var_TEXCOORD0 [[user(locn0)]]; +}; + +fragment main0_out main0(main0_in in [[stage_in]], texturecube SkyboxTexture [[texture(0)]], sampler SkyboxSampler [[sampler(0)]]) +{ + main0_out out = {}; + out.out_var_SV_Target0 = powr(SkyboxTexture.sample(SkyboxSampler, in.in_var_TEXCOORD0), float4(0.4545454680919647216796875)); + return out; +} + diff --git a/projects/content/_shaders/msl/skybox.vert.msl b/projects/content/_shaders/msl/skybox.vert.msl new file mode 100644 index 0000000..63e7121 --- /dev/null +++ b/projects/content/_shaders/msl/skybox.vert.msl @@ -0,0 +1,29 @@ +#include +#include + +using namespace metal; + +struct type_Uniforms +{ + float4x4 ViewProjection; +}; + +struct main0_out +{ + float3 out_var_TEXCOORD0 [[user(locn0)]]; + float4 gl_Position [[position]]; +}; + +struct main0_in +{ + float3 in_var_TEXCOORD0 [[attribute(0)]]; +}; + +vertex main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Uniforms [[buffer(0)]]) +{ + main0_out out = {}; + out.out_var_TEXCOORD0 = in.in_var_TEXCOORD0; + out.gl_Position = Uniforms.ViewProjection * float4(in.in_var_TEXCOORD0, 1.0); + return out; +} + diff --git a/projects/content/_shaders/spv/lit_mesh.frag.spv b/projects/content/_shaders/spv/lit_mesh.frag.spv index 22a91f3e6d485ff2c1e443d3d390622b836391ac..3c97632df2399b0ddf1bbec7ae5ac2007dc30f47 100644 GIT binary patch delta 17 ZcmZ3YwnS~i4OSMe>x->7-(mIO1pq+!2F?Hg delta 17 YcmZ3YwnS~i4OW(Xp=PVicUV1m0X=sHO#lD@ diff --git a/projects/content/_shaders/spv/skybox.frag.spv b/projects/content/_shaders/spv/skybox.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..cc5714877ca184ed1b670656bcb1382962611182 GIT binary patch literal 868 zcmYk3-%0{e5XMiMT4`EYni`>XS!`WY1d%rt-Uvd9c^7LgB4x?ChQ3-))FX5g^!<(+ zdti3v`@_tfv(dPn#&oY8jI-tEwZ4 zp*whoM}^x`1+M|Bq9&%?5fM{g>R>kVoR>-0a|T1V?^!-BzWF-qeoR~5G?@6FFn)Si z|JWUl-aKE>@@vX-fAe36$;}Rfcjwdfoz_F=uF-hBx4WaU+s7oZVzd3+a{ay+NR3Ge z-vjTuyrH?h#j2(zFEb7m958*un7bS)=!p)lC^%qt59{Eio>TV?;j-dHUh1Uc?CZOl z7fz{$W9F&$1aB(vgrlGv@YZ?@15AJJ40ok2^k3eI89zdM z%C~Z{Q%->w%*?!kd0_6euV7wVDti?ac;KJpDKFgSspFe`fNC-ifB30mJi`-sto zIkVTA%bM9InP_Is=FBW-HGMe+OL!*fFwwltPw&HiFajiGWTc!=T3Ws*GHn@mpL{$I zT6d%1F&qzH6w6rF@w(c5FnI5d!>7T+BnZ_l?W)XX(#2$*Mlfo<^~bH-%iejXb91pz zJu$Sy*U7(NS`#sIJZD>&8JA=nFtf+|g6TDjGs3$v`Va>X^Ei5Cv$Ap*e4H5fMVZ;>X+@Y_;OJY`cUc||T=P0`bulaQ zXrfJRPM%tJCZ3mP26!;D6N_=dWBM1>X-&SNjG{buYS!h^K=Vi#P2LO+j0Sgfz_A88 zU^JK=e4t6`OD+eUZ&jD%kCnw-Wf}dhmCG&_&&f@>s^{nv=WTe7+OGZpJ8jCSC!aX) qe5Stav?XH?{tMddw=IMJQV#VyGJ3$DXaja&KJM&9{72gy%6