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 66c8b39..222e252 100644 Binary files a/projects/content/_shaders/dxil/lit_mesh.frag.dxil and b/projects/content/_shaders/dxil/lit_mesh.frag.dxil differ diff --git a/projects/content/_shaders/dxil/skybox.frag.dxil b/projects/content/_shaders/dxil/skybox.frag.dxil new file mode 100644 index 0000000..0ddc117 Binary files /dev/null and b/projects/content/_shaders/dxil/skybox.frag.dxil differ diff --git a/projects/content/_shaders/dxil/skybox.vert.dxil b/projects/content/_shaders/dxil/skybox.vert.dxil new file mode 100644 index 0000000..280990d Binary files /dev/null and b/projects/content/_shaders/dxil/skybox.vert.dxil differ diff --git a/projects/content/_shaders/msl/lit_mesh.frag.msl b/projects/content/_shaders/msl/lit_mesh.frag.msl index 74ddcd7..c12c93b 100644 --- a/projects/content/_shaders/msl/lit_mesh.frag.msl +++ b/projects/content/_shaders/msl/lit_mesh.frag.msl @@ -92,7 +92,7 @@ fragment main0_out main0(main0_in in [[stage_in]], constant type_Uniforms& Unifo for (int _163 = -4; _163 <= 4; ) { _153++; - _150 += float((in.in_var_TEXCOORD3.z - 0.001000000047497451305389404296875) > 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 22a91f3..3c97632 100644 Binary files a/projects/content/_shaders/spv/lit_mesh.frag.spv and b/projects/content/_shaders/spv/lit_mesh.frag.spv differ diff --git a/projects/content/_shaders/spv/skybox.frag.spv b/projects/content/_shaders/spv/skybox.frag.spv new file mode 100644 index 0000000..cc57148 Binary files /dev/null and b/projects/content/_shaders/spv/skybox.frag.spv differ diff --git a/projects/content/_shaders/spv/skybox.vert.spv b/projects/content/_shaders/spv/skybox.vert.spv new file mode 100644 index 0000000..ca2947a Binary files /dev/null and b/projects/content/_shaders/spv/skybox.vert.spv differ diff --git a/projects/sampleGame/main.zig b/projects/sampleGame/main.zig index 1699277..4cc7c04 100644 --- a/projects/sampleGame/main.zig +++ b/projects/sampleGame/main.zig @@ -51,6 +51,21 @@ const assetReferences = [_]assets.AssetImportReference{ "t_empire", .{ .path = "textures/lost_empire-RGBA.png" }, ), + assets.MakeImportRefOptions( + "Texture", + "t_skybox", + .{ + .textureCube = true, + .textureList = &.{ + "sky_air/cube_right.png", // cubemapfacePositivex, right + "sky_air/cube_left.png", // cubemapfacePositivex, right + "sky_air/cube_up.png", // cubemapfacePositivex, right + "sky_air/cube_down.png", // cubemapfacePositivex, right + "sky_air/cube_back.png", // cubemapfacePositivex, right + "sky_air/cube_front.png", // cubemapfacePositivex, right + }, + }, + ), }; pub fn prepare(self: *@This()) !void { @@ -63,6 +78,8 @@ pub fn prepare(self: *@This()) !void { try assets.loadList(assetReferences); + rend.setSkyboxTexture("t_skybox"); + const exitInput = try core.ActionBinding.create(core.MakeName("exit")); exitInput.addKey(.escape, .keyDown); _ = exitInput.data.addListener(null, onExit);