implement skybox

Author: brambora69123

shaders/skybox.frag.hlsl

@@ -0,0 +1,14 @@
+struct VSOutput {
+    float4 position : SV_Position;
+    float3 texCoord : TEXCOORD0;
+};
+
+#pragma pack_matrix(column_major)
+
+// For SPIR-V Fragment Shaders, Sampled Textures are in Set 2 (space2)
+[[vk::binding(0, 2)]] SamplerState skySampler : register(s0, space2);
+[[vk::binding(0, 2)]] TextureCube skyTexture : register(t0, space2);
+
+float4 main(VSOutput input) : SV_Target {
+    return skyTexture.Sample(skySampler, input.texCoord);
+}

shaders/skybox.frag.spv

@@ -0,0 +1,24 @@
+struct VSInput {
+    [[vk::location(0)]] float3 position : TEXCOORD0;
+};
+
+struct VSOutput {
+    float4 position : SV_Position;
+    float3 texCoord : TEXCOORD0;
+};
+
+#pragma pack_matrix(column_major)
+
+// For SPIR-V Vertex Shaders, Uniform Buffers are in Set 1 (space1)
+cbuffer Uniforms : register(b0, space1) {
+    float4x4 mvp;
+};
+
+VSOutput main(VSInput input) {
+    VSOutput output;
+    output.position = mul(mvp, float4(input.position, 1.0));
+    // xyww trick to ensure skybox is at the far plane
+    output.position = output.position.xyww;
+    output.texCoord = input.position;
+    return output;
+}

shaders/skybox.vert.hlsl

@@ -16,12 +16,12 @@ namespace Nova {
     namespace Props {
         struct SkyProps {
             rfl::Flatten<InstanceProps> base;
-            std::string SkyboxBk = "rbxasset://textures/sky/sky_bk.png";
-            std::string SkyboxDn = "rbxasset://textures/sky/sky_dn.png";
-            std::string SkyboxFt = "rbxasset://textures/sky/sky_ft.png";
-            std::string SkyboxLf = "rbxasset://textures/sky/sky_lf.png";
-            std::string SkyboxRt = "rbxasset://textures/sky/sky_rt.png";
-            std::string SkyboxUp = "rbxasset://textures/sky/sky_up.png";
+            std::string SkyboxBk = "rbxasset://textures/sky/null_plainsky512_bk.jpg";
+            std::string SkyboxDn = "rbxasset://textures/sky/null_plainsky512_dn.jpg";
+            std::string SkyboxFt = "rbxasset://textures/sky/null_plainsky512_ft.jpg";
+            std::string SkyboxLf = "rbxasset://textures/sky/null_plainsky512_lf.jpg";
+            std::string SkyboxRt = "rbxasset://textures/sky/null_plainsky512_rt.jpg";
+            std::string SkyboxUp = "rbxasset://textures/sky/null_plainsky512_up.jpg";
             int StarCount = 3000;
         };
     }

shaders/skybox.vert.spv

@@ -72,6 +72,8 @@ namespace Nova {
     }
 
     Renderer::~Renderer() {
+        if (skyboxPipeline) SDL_ReleaseGPUGraphicsPipeline(device, skyboxPipeline);
+        if (skyboxTexture) SDL_ReleaseGPUTexture(device, skyboxTexture);
         SDL_ReleaseGPUGraphicsPipeline(device, basePipeline);
         SDL_ReleaseGPUBuffer(device, cubeBuffer);
         SDL_ReleaseGPUBuffer(device, instanceBuffer);
@@ -126,6 +128,7 @@ namespace Nova {
 
         if (SDL_WaitAndAcquireGPUSwapchainTexture(cmd, window, &swapchainTexture, &w, &h)) {
             fb.Refresh(device, w, h);
+            UpdateSkybox(workspace);
 
             float aspect = (float)w / (float)h;
             glm::mat4 proj = glm::perspectiveRH_ZO(glm::radians(70.0f), aspect, 0.1f, 10000.0f);
@@ -213,6 +216,26 @@ namespace Nova {
             depthTarget.store_op = SDL_GPU_STOREOP_DONT_CARE;
 
             auto pass = SDL_BeginGPURenderPass(cmd, &colorTarget, 1, &depthTarget);
+
+            if (skyboxPipeline && skyboxTexture) {
+                SDL_BindGPUGraphicsPipeline(pass, skyboxPipeline);
+                
+                // View matrix without translation
+                // HLSL mul(mvp, pos) with column_major expects the same layout as GLM
+                glm::mat4 skyView = glm::mat4(glm::mat3(view));
+                glm::mat4 skyMVP = proj * skyView;
+                
+                SDL_PushGPUVertexUniformData(cmd, 0, &skyMVP, sizeof(glm::mat4));
+                
+                SDL_GPUTextureSamplerBinding skyBinding = { .texture = skyboxTexture, .sampler = surfaceSampler };
+                SDL_BindGPUFragmentSamplers(pass, 0, &skyBinding, 1);
+
+                SDL_GPUBufferBinding vBinding = { .buffer = cubeBuffer, .offset = 0 };
+                SDL_BindGPUVertexBuffers(pass, 0, &vBinding, 1);
+                
+                SDL_DrawGPUPrimitives(pass, 36, 1, 0, 0);
+            }
+
             if (!instances.empty()) {
                 SDL_BindGPUGraphicsPipeline(pass, basePipeline);
                 SDL_GPUBufferBinding vBinding = { .buffer = cubeBuffer, .offset = 0 };

src/Engine/Objects/Sky.hpp

@@ -45,16 +45,23 @@ namespace Nova {
             const Frustum& frustum,
             std::vector<InstanceData>& outData);
 
+        void UpdateSkybox(std::shared_ptr<Workspace> workspace);
+        void LoadSkyboxTexture(const std::vector<std::string>& paths);
+
         SDL_GPUDevice* device;
         SDL_Window* window;
         SDL_GPUGraphicsPipeline* basePipeline;
+        SDL_GPUGraphicsPipeline* skyboxPipeline;
         SDL_GPUBuffer* cubeBuffer;
         SDL_GPUBuffer* instanceBuffer;
         SDL_GPUTransferBuffer* instanceTransferBuffer = nullptr;
 
         SDL_GPUTexture* surfaceTexture = nullptr;
         SDL_GPUSampler* surfaceSampler = nullptr;
 
+        SDL_GPUTexture* skyboxTexture = nullptr;
+        std::string currentSkyboxPaths[6];
+
         Framebuffer fb;
 
         std::vector<uint8_t> LoadSPIRV(const std::string& path);

src/Engine/Rendering/Renderer.cpp

@@ -84,5 +84,53 @@ namespace Nova {
         basePipeline = SDL_CreateGPUGraphicsPipeline(device, &pInfo);
         SDL_ReleaseGPUShader(device, vShader);
         SDL_ReleaseGPUShader(device, fShader);
+        SDL_Log("Base pipeline initialized.");
+
+        // Skybox Pipeline
+        auto skyVCode = LoadSPIRV("shaders/skybox.vert.spv");
+        auto skyFCode = LoadSPIRV("shaders/skybox.frag.spv");
+
+        if (!skyVCode.empty() && !skyFCode.empty()) {
+            SDL_Log("Skybox shaders loaded (%zu, %zu bytes).", skyVCode.size(), skyFCode.size());
+            SDL_GPUShaderCreateInfo skyVInfo = {
+                .code_size = skyVCode.size(),
+                .code = skyVCode.data(),
+                .entrypoint = "main",
+                .format = SDL_GPU_SHADERFORMAT_SPIRV,
+                .stage = SDL_GPU_SHADERSTAGE_VERTEX,
+                .num_uniform_buffers = 1 // MVP
+            };
+            SDL_GPUShaderCreateInfo skyFInfo = {
+                .code_size = skyFCode.size(),
+                .code = skyFCode.data(),
+                .entrypoint = "main",
+                .format = SDL_GPU_SHADERFORMAT_SPIRV,
+                .stage = SDL_GPU_SHADERSTAGE_FRAGMENT,
+                .num_samplers = 1 // Cubemap
+            };
+
+            SDL_GPUShader* skyVShader = SDL_CreateGPUShader(device, &skyVInfo);
+            SDL_GPUShader* skyFShader = SDL_CreateGPUShader(device, &skyFInfo);
+
+            SDL_GPUGraphicsPipelineCreateInfo skyPInfo = pInfo;
+            skyPInfo.vertex_shader = skyVShader;
+            skyPInfo.fragment_shader = skyFShader;
+            skyPInfo.depth_stencil_state.enable_depth_write = false;
+            skyPInfo.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_ALWAYS;
+            skyPInfo.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
+
+            skyboxPipeline = SDL_CreateGPUGraphicsPipeline(device, &skyPInfo);
+            if (skyboxPipeline) {
+                SDL_Log("Skybox pipeline created successfully.");
+            } else {
+                SDL_Log("Failed to create skybox pipeline: %s", SDL_GetError());
+            }
+
+            SDL_ReleaseGPUShader(device, skyVShader);
+            SDL_ReleaseGPUShader(device, skyFShader);
+        } else {
+            skyboxPipeline = nullptr;
+            SDL_Log("Skybox shaders not found (expected shaders/skybox.vert.spv and shaders/skybox.frag.spv). Skybox will be disabled.");
+        }
     }
 }

src/Engine/Rendering/Renderer.hpp

@@ -99,4 +99,144 @@ namespace Nova {
         SDL_ReleaseGPUTransferBuffer(device, tBuf);
         SDL_ReleaseGPUTransferBuffer(device, ltBuf);
     }
+
+    void Renderer::UpdateSkybox(std::shared_ptr<Workspace> workspace) {
+        std::shared_ptr<Sky> sky = nullptr;
+        
+        // Find Sky in Lighting (standard location)
+        if (auto parent = workspace->GetParent()) {
+            for (auto& child : parent->GetChildren()) {
+                if (auto lighting = std::dynamic_pointer_cast<Lighting>(child)) {
+                    for (auto& lChild : lighting->GetChildren()) {
+                        if (auto s = std::dynamic_pointer_cast<Sky>(lChild)) {
+                            sky = s;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!sky) {
+            return;
+        }
+
+        bool changed = false;
+        std::string newPaths[6] = {
+            sky->props.SkyboxRt, sky->props.SkyboxLf,
+            sky->props.SkyboxUp, sky->props.SkyboxDn,
+            sky->props.SkyboxBk, sky->props.SkyboxFt
+        };
+
+        if (currentSkyboxPaths[0].empty()) changed = true; // Initial load
+
+        for (int i = 0; i < 6; i++) {
+            if (newPaths[i] != currentSkyboxPaths[i]) {
+                changed = true;
+                break;
+            }
+        }
+
+        if (changed) {
+            SDL_Log("Skybox changed or initializing...");
+            std::vector<std::string> paths;
+            for (int i = 0; i < 6; i++) {
+                currentSkyboxPaths[i] = newPaths[i];
+                std::string path = newPaths[i];
+                if (path.starts_with("rbxasset://textures/sky/")) {
+                    path = "resources/sky/" + path.substr(24);
+                }
+                paths.push_back(path);
+                SDL_Log("  Face %d: %s", i, path.c_str());
+            }
+            LoadSkyboxTexture(paths);
+        }
+    }
+
+    void Renderer::LoadSkyboxTexture(const std::vector<std::string>& paths) {
+        if (paths.size() < 6) return;
+
+        SDL_Surface* surfaces[6];
+        bool success = true;
+        for (int i = 0; i < 6; i++) {
+            surfaces[i] = IMG_Load(paths[i].c_str());
+            if (!surfaces[i]) {
+                SDL_Log("Failed to load skybox texture %s: %s", paths[i].c_str(), SDL_GetError());
+                success = false;
+            } else {
+                SDL_Surface* rgba = SDL_ConvertSurface(surfaces[i], SDL_PIXELFORMAT_RGBA32);
+                SDL_DestroySurface(surfaces[i]);
+                surfaces[i] = rgba;
+            }
+        }
+
+        if (!success) {
+            SDL_Log("Skybox loading failed due to missing textures.");
+            for (int i = 0; i < 6; i++) if (surfaces[i]) SDL_DestroySurface(surfaces[i]);
+            return;
+        }
+
+        if (skyboxTexture) SDL_ReleaseGPUTexture(device, skyboxTexture);
+
+        SDL_GPUTextureCreateInfo texInfo = {
+            .type = SDL_GPU_TEXTURETYPE_CUBE,
+            .format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM,
+            .usage = SDL_GPU_TEXTUREUSAGE_SAMPLER,
+            .width = (uint32_t)surfaces[0]->w,
+            .height = (uint32_t)surfaces[0]->h,
+            .layer_count_or_depth = 6,
+            .num_levels = 1
+        };
+        skyboxTexture = SDL_CreateGPUTexture(device, &texInfo);
+
+        uint32_t layerSize = surfaces[0]->w * surfaces[0]->h * 4;
+        SDL_GPUTransferBufferCreateInfo ltInfo = { .usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = layerSize * 6 };
+        auto ltBuf = SDL_CreateGPUTransferBuffer(device, &ltInfo);
+        uint8_t* texData = (uint8_t*)SDL_MapGPUTransferBuffer(device, ltBuf, false);
+
+        uint32_t width = (uint32_t)surfaces[0]->w;
+        uint32_t height = (uint32_t)surfaces[0]->h;
+
+        for (int i = 0; i < 6; i++) {
+            std::memcpy(texData + (i * layerSize), surfaces[i]->pixels, layerSize);
+            
+            if (i == 2 || i == 3) {
+                uint32_t* pixels = (uint32_t*)(texData + (i * layerSize));
+                std::vector<uint32_t> temp(width * height);
+                std::memcpy(temp.data(), pixels, layerSize);
+                
+                for (uint32_t y = 0; y < height; y++) {
+                    for (uint32_t x = 0; x < width; x++) {
+                        uint32_t srcIdx = y * width + x;
+                        uint32_t dstIdx;
+                        
+                        if (i == 3) { // Bottom: 90 degrees clockwise
+                            dstIdx = x * width + (width - 1 - y);
+                        } else { // Top: 90 degrees counter-clockwise
+                            dstIdx = (width - 1 - x) * width + y;
+                        }
+                        
+                        pixels[dstIdx] = temp[srcIdx];
+                    }
+                }
+            }
+            
+            SDL_DestroySurface(surfaces[i]);
+        }
+        SDL_UnmapGPUTransferBuffer(device, ltBuf);
+
+        auto cmd = SDL_AcquireGPUCommandBuffer(device);
+        auto copy = SDL_BeginGPUCopyPass(cmd);
+        for (uint32_t i = 0; i < 6; i++) {
+            SDL_GPUTextureTransferInfo texSrc = { ltBuf, layerSize * i };
+            SDL_GPUTextureRegion texDst = { skyboxTexture, 0, i, 0, 0, 0, width, height, 1 };
+            SDL_UploadToGPUTexture(copy, &texSrc, &texDst, false);
+        }
+        SDL_EndGPUCopyPass(copy);
+        auto fence = SDL_SubmitGPUCommandBufferAndAcquireFence(cmd);
+        SDL_WaitForGPUFences(device, true, &fence, 1);
+        SDL_ReleaseGPUFence(device, fence);
+        SDL_ReleaseGPUTransferBuffer(device, ltBuf);
+        SDL_Log("Skybox cubemap created successfully (%dx%d).", width, height);
+    }
 }

src/Engine/Rendering/Renderer_Pipeline.cpp

@@ -4,7 +4,7 @@
 #include "Engine/TaskScheduler.hpp"
 #include "Engine/Nova.hpp"
 #include "Engine/Reflection/LevelLoader.hpp"
-#include "Engine/Services/PhysicsService.hpp"
+#include "Engine/Objects/Sky.hpp"
 #include <SDL3_image/SDL_image.h>
 #include <tracy/Tracy.hpp>
 
@@ -33,6 +33,20 @@ int main(int argc, char* argv[]) {
             lighting->props.TopAmbientV9 = { 0.5f, 0.5f, 0.5f };
             lighting->props.BottomAmbientV9 = { 0.2f, 0.2f, 0.2f };
         }
+
+        // Add default Sky if none exists
+        bool hasSky = false;
+        for (auto& child : lighting->GetChildren()) {
+            if (std::dynamic_pointer_cast<Nova::Sky>(child)) {
+                hasSky = true;
+                break;
+            }
+        }
+        if (!hasSky) {
+            auto sky = std::make_shared<Nova::Sky>();
+            sky->SetParent(lighting);
+            SDL_Log("Added default Sky instance.");
+        }
     }
 
     // MOVE CAMERA OUT OF THE FLOOR