Remove shadows for now. We'll concentrate on them in the samples version.

Add ability to set time of day so can experience the night with nice lights.  Still have a bug in the emissive light textures as it looks like the bulbs aren't quite working right.

Author: gpx1000

attachments/simple_engine/CMakeLists.txt

@@ -102,7 +102,6 @@ set(SOURCES
     renderer_compute.cpp
     renderer_utils.cpp
     renderer_resources.cpp
-    renderer_shadows.cpp
     memory_pool.cpp
     resource_manager.cpp
     entity.cpp

attachments/simple_engine/imgui_system.cpp

@@ -169,22 +169,28 @@ void ImGuiSystem::NewFrame() {
             std::cout << "Exposure reset to: " << exposure << std::endl;
         }
 
-        // Shadow toggle
-        static bool shadowsEnabled = true; // Default shadows on
-        if (ImGui::Checkbox("Enable Shadows", &shadowsEnabled)) {
-            // Update shadows in renderer
-            if (renderer) {
-                renderer->SetShadowsEnabled(shadowsEnabled);
-            }
-            std::cout << "Shadows " << (shadowsEnabled ? "enabled" : "disabled") << std::endl;
-        }
-
         ImGui::Text("Tip: Adjust gamma if scene looks too dark/bright");
         ImGui::Text("Tip: Adjust exposure if scene looks washed out");
     } else {
         ImGui::Text("Note: Quality controls affect BRDF rendering only");
     }
 
+    ImGui::Separator();
+
+    // Sun position control (punctual light in GLTF)
+    ImGui::Text("Sun Position in Sky:");
+    if (renderer) {
+        float sun = renderer->GetSunPosition();
+        if (ImGui::SliderFloat("Sun Position", &sun, 0.0f, 1.0f, "%.2f")) {
+            renderer->SetSunPosition(sun);
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Noon")) { sun = 0.5f; renderer->SetSunPosition(sun); }
+        ImGui::SameLine();
+        if (ImGui::Button("Night")) { sun = 0.0f; renderer->SetSunPosition(sun); }
+        ImGui::Text("Tip: 0/1 = Night, 0.5 = Noon. Warmer tint near horizon simulates evening.");
+    }
+
     ImGui::Separator();
     ImGui::Text("3D Audio Position Control");
 

attachments/simple_engine/model_loader.cpp

@@ -215,7 +215,7 @@ bool ModelLoader::ParseGLTF(const std::string& filename, Model* model) {
                 gltfMaterial.emissiveFactor[0],
                 gltfMaterial.emissiveFactor[1],
                 gltfMaterial.emissiveFactor[2]
-            ) * light_scale;
+            );
         }
 
         // Parse KHR_materials_emissive_strength extension
@@ -1327,21 +1327,46 @@ std::vector<ExtractedLight> ModelLoader::GetExtractedLights(const std::string& m
                         avgNormal = glm::vec3(0.0f, -1.0f, 0.0f); // Default downward direction
                     }
 
-                    // Create an emissive light source
-                    ExtractedLight emissiveLight;
-                    emissiveLight.type = ExtractedLight::Type::Emissive;
-                    emissiveLight.position = center;
-                    emissiveLight.color = material->emissive;
-                    emissiveLight.intensity = material->emissiveStrength;
-                    emissiveLight.range = 1.0f; // Default range for emissive lights
-                    emissiveLight.sourceMaterial = material->GetName();
-                    emissiveLight.direction = avgNormal;
-
-                    lights.push_back(emissiveLight);
-
-                    std::cout << "Created emissive light from material '" << material->GetName()
-                              << "' at position (" << center.x << ", " << center.y << ", " << center.z
-                              << ") with intensity " << emissiveIntensity << std::endl;
+                    // Create emissive light(s) transformed by each instance's model matrix
+                    if (!materialMesh.instances.empty()) {
+                        for (const auto& inst : materialMesh.instances) {
+                            glm::mat4 M = inst.getModelMatrix();
+                            glm::vec3 worldCenter = glm::vec3(M * glm::vec4(center, 1.0f));
+                            glm::mat3 normalMat = glm::transpose(glm::inverse(glm::mat3(M)));
+                            glm::vec3 worldNormal = glm::normalize(normalMat * avgNormal);
+
+                            ExtractedLight emissiveLight;
+                            emissiveLight.type = ExtractedLight::Type::Emissive;
+                            emissiveLight.position = worldCenter;
+                            emissiveLight.color = material->emissive;
+                            emissiveLight.intensity = material->emissiveStrength;
+                            emissiveLight.range = 1.0f; // Default range for emissive lights
+                            emissiveLight.sourceMaterial = material->GetName();
+                            emissiveLight.direction = worldNormal;
+
+                            lights.push_back(emissiveLight);
+
+                            std::cout << "Created emissive light from material '" << material->GetName()
+                                      << "' at world position (" << worldCenter.x << ", " << worldCenter.y << ", " << worldCenter.z
+                                      << ") with intensity " << emissiveIntensity << std::endl;
+                        }
+                    } else {
+                        // No explicit instances; use identity transform
+                        ExtractedLight emissiveLight;
+                        emissiveLight.type = ExtractedLight::Type::Emissive;
+                        emissiveLight.position = center;
+                        emissiveLight.color = material->emissive;
+                        emissiveLight.intensity = material->emissiveStrength;
+                        emissiveLight.range = 1.0f; // Default range for emissive lights
+                        emissiveLight.sourceMaterial = material->GetName();
+                        emissiveLight.direction = avgNormal;
+
+                        lights.push_back(emissiveLight);
+
+                        std::cout << "Created emissive light from material '" << material->GetName()
+                                  << "' at position (" << center.x << ", " << center.y << ", " << center.z
+                                  << ") with intensity " << emissiveIntensity << std::endl;
+                    }
                 }
             }
         }
@@ -1446,35 +1471,90 @@ bool ModelLoader::ExtractPunctualLights(const tinygltf::Model& gltfModel, const
         std::cout << "  No KHR_lights_punctual extension found" << std::endl;
     }
 
-    // Now find light nodes in the scene to get positions and directions
-    for (const auto& node : gltfModel.nodes) {
+    // Compute world transforms for all nodes in the default scene
+    std::vector<glm::mat4> nodeWorldTransforms(gltfModel.nodes.size(), glm::mat4(1.0f));
+
+    auto calcLocal = [](const tinygltf::Node& n) -> glm::mat4 {
+        // If matrix is provided, use it
+        if (n.matrix.size() == 16) {
+            glm::mat4 m(1.0f);
+            for (int r = 0; r < 4; ++r) {
+                for (int c = 0; c < 4; ++c) {
+                    m[c][r] = static_cast<float>(n.matrix[r * 4 + c]);
+                }
+            }
+            return m;
+        }
+        // Otherwise compose TRS
+        glm::mat4 T(1.0f), R(1.0f), S(1.0f);
+        if (n.translation.size() == 3) {
+            T = glm::translate(glm::mat4(1.0f), glm::vec3(
+                static_cast<float>(n.translation[0]),
+                static_cast<float>(n.translation[1]),
+                static_cast<float>(n.translation[2])));
+        }
+        if (n.rotation.size() == 4) {
+            glm::quat q(
+                static_cast<float>(n.rotation[3]),
+                static_cast<float>(n.rotation[0]),
+                static_cast<float>(n.rotation[1]),
+                static_cast<float>(n.rotation[2]));
+            R = glm::mat4_cast(q);
+        }
+        if (n.scale.size() == 3) {
+            S = glm::scale(glm::mat4(1.0f), glm::vec3(
+                static_cast<float>(n.scale[0]),
+                static_cast<float>(n.scale[1]),
+                static_cast<float>(n.scale[2])));
+        }
+        return T * R * S;
+    };
+
+    std::function<void(int, const glm::mat4&)> traverseNode = [&](int nodeIndex, const glm::mat4& parent) {
+        if (nodeIndex < 0 || nodeIndex >= static_cast<int>(gltfModel.nodes.size())) return;
+        const tinygltf::Node& n = gltfModel.nodes[nodeIndex];
+        glm::mat4 local = calcLocal(n);
+        glm::mat4 world = parent * local;
+        nodeWorldTransforms[nodeIndex] = world;
+        for (int child : n.children) {
+            traverseNode(child, world);
+        }
+    };
+
+    if (!gltfModel.scenes.empty()) {
+        int sceneIndex = gltfModel.defaultScene >= 0 ? gltfModel.defaultScene : 0;
+        if (sceneIndex < static_cast<int>(gltfModel.scenes.size())) {
+            const tinygltf::Scene& scene = gltfModel.scenes[sceneIndex];
+            for (int root : scene.nodes) {
+                traverseNode(root, glm::mat4(1.0f));
+            }
+        }
+    } else {
+        // Fallback: traverse all nodes as roots
+        for (int i = 0; i < static_cast<int>(gltfModel.nodes.size()); ++i) {
+            traverseNode(i, glm::mat4(1.0f));
+        }
+    }
+
+    // Now assign positions and directions using world transforms
+    for (size_t nodeIndex = 0; nodeIndex < gltfModel.nodes.size(); ++nodeIndex) {
+        const auto& node = gltfModel.nodes[nodeIndex];
         if (node.extensions.contains("KHR_lights_punctual")) {
             const tinygltf::Value& nodeExtension = node.extensions.at("KHR_lights_punctual");
             if (nodeExtension.Has("light") && nodeExtension.Get("light").IsInt()) {
                 int lightIndex = nodeExtension.Get("light").Get<int>();
                 if (lightIndex >= 0 && lightIndex < static_cast<int>(lights.size())) {
-                    // Extract position from node transform
-                    if (node.translation.size() >= 3) {
-                        lights[lightIndex].position = glm::vec3(
-                            static_cast<float>(node.translation[0]),
-                            static_cast<float>(node.translation[1]),
-                            static_cast<float>(node.translation[2])
-                        );
-                    }
-
-                    // Extract direction from node rotation (for directional and spotlights)
-                    if (node.rotation.size() >= 4 &&
-                        (lights[lightIndex].type == ExtractedLight::Type::Directional ||
-                         lights[lightIndex].type == ExtractedLight::Type::Spot)) {
-                        // Convert quaternion to a direction vector
-                        glm::quat rotation(
-                            static_cast<float>(node.rotation[3]), // w
-                            static_cast<float>(node.rotation[0]), // x
-                            static_cast<float>(node.rotation[1]), // y
-                            static_cast<float>(node.rotation[2])  // z
-                        );
-                        // Default forward direction in glTF is -Z
-                        lights[lightIndex].direction = rotation * glm::vec3(0.0f, 0.0f, -1.0f);
+                    const glm::mat4& W = nodeWorldTransforms[nodeIndex];
+                    // Position from world transform origin
+                    glm::vec3 pos = glm::vec3(W * glm::vec4(0, 0, 0, 1));
+                    lights[lightIndex].position = pos;
+
+                    // Direction for directional/spot: transform -Z
+                    if (lights[lightIndex].type == ExtractedLight::Type::Directional ||
+                        lights[lightIndex].type == ExtractedLight::Type::Spot) {
+                        glm::mat3 rot = glm::mat3(W);
+                        glm::vec3 dir = glm::normalize(rot * glm::vec3(0.0f, 0.0f, -1.0f));
+                        lights[lightIndex].direction = dir;
                     }
 
                     std::cout << "    Light " << lightIndex << " positioned at ("

attachments/simple_engine/renderer.h

@@ -8,6 +8,7 @@
 #include <optional>
 #include <unordered_map>
 #include <mutex>
+#include <algorithm>
 
 #include "platform.h"
 #include "entity.h"
@@ -67,13 +68,13 @@ struct UniformBufferObject {
     alignas(4) float prefilteredCubeMipLevels;
     alignas(4) float scaleIBLAmbient;
     alignas(4) int lightCount;                 // Number of active lights (dynamic)
-    alignas(4) int shadowMapCount;             // Number of active shadow maps (dynamic)
-    alignas(4) float shadowBias;               // Shadow bias to prevent shadow acne
+    alignas(4) int padding0;                   // Padding for alignment (shadows removed)
     alignas(4) float padding1;                 // Padding for alignment
+    alignas(4) float padding2;                 // Padding for alignment
 
     // Additional padding to ensure the structure size is aligned to 64 bytes (device nonCoherentAtomSize)
-    // Current size: 3*64 + 16 + 8*4 = 240 bytes, pad to 256 bytes (multiple of 64)
-    alignas(4) float padding2[4];              // Add 16 more bytes to reach 256 bytes total
+    // Adjusted padding to maintain 256 bytes total size
+    alignas(4) float padding3[2];              // Add remaining bytes to reach 256 bytes total
 };
 
 
@@ -162,6 +163,16 @@ class Renderer {
      */
     bool IsInitialized() const { return initialized; }
 
+    /**
+     * @brief Set sun position slider value in [0,1]. 0 and 1 = night, 0.5 = noon.
+     */
+    void SetSunPosition(float s) { sunPosition = std::clamp(s, 0.0f, 1.0f); }
+
+    /**
+     * @brief Get sun position slider value.
+     */
+    float GetSunPosition() const { return sunPosition; }
+
 
     /**
      * @brief Get the Vulkan device.
@@ -347,21 +358,6 @@ class Renderer {
         exposure = _exposure;
     }
 
-    /**
-     * @brief Enable or disable shadow rendering.
-     * @param enabled True to enable shadows, false to disable.
-     * @note Shadows should be pre-computed and cached during model loading for optimal performance.
-     *       Toggling this flag should only affect shader uniform values, not trigger recomputation.
-     */
-    void SetShadowsEnabled(bool enabled) {
-        // Only update if the value actually changed to avoid unnecessary uniform buffer updates
-        if (this->shadowsEnabled != enabled) {
-            this->shadowsEnabled = enabled;
-            // TODO: Update uniform buffer with shadow enable/disable flag
-            // Shadow maps should remain cached and not be recomputed
-        }
-    }
-
     /**
      * @brief Create or resize light storage buffers to accommodate the given number of lights.
      * @param lightCount The number of lights to accommodate.
@@ -417,7 +413,9 @@ class Renderer {
     // PBR rendering parameters
     float gamma = 2.2f;     // Gamma correction value
     float exposure = 3.0f;  // HDR exposure value (higher for emissive lighting)
-    bool shadowsEnabled = true;  // Shadow rendering enabled by default
+
+    // Sun control (UI-driven)
+    float sunPosition = 0.5f;    // 0..1, extremes are night, 0.5 is noon
 
     // Vulkan RAII context
     vk::raii::Context context;
@@ -519,25 +517,8 @@ class Renderer {
     // Default texture resources (used when no texture is provided)
     TextureResources defaultTextureResources;
 
-    // Shadow mapping resources
-    struct ShadowMapResources {
-        vk::raii::Image shadowMapImage = nullptr;
-        std::unique_ptr<MemoryPool::Allocation> shadowMapImageAllocation = nullptr;
-        vk::raii::ImageView shadowMapImageView = nullptr;
-        vk::raii::Sampler shadowMapSampler = nullptr;
-        vk::raii::Framebuffer shadowMapFramebuffer = nullptr;
-        vk::raii::RenderPass shadowMapRenderPass = nullptr;
-        uint32_t shadowMapSize = 2048; // Default shadow map resolution
-    };
-    std::vector<ShadowMapResources> shadowMaps; // One shadow map per light
-
-    // Shadow mapping constants
-    static constexpr uint32_t MAX_SHADOW_MAPS = 16; // Descriptors/array size remains 16
-    static constexpr uint32_t DEFAULT_SHADOW_MAP_SIZE = 2048;
-
     // Performance clamps (to reduce per-frame cost)
-    static constexpr uint32_t MAX_ACTIVE_LIGHTS = 32;      // Limit the number of lights processed per frame
-    static constexpr uint32_t MAX_SHADOW_MAPS_USED = 4;    // Limit the number of shadows sampled per frame
+    static constexpr uint32_t MAX_ACTIVE_LIGHTS = 1024;      // Limit the number of lights processed per frame
 
     // Static lights loaded during model initialization
     std::vector<ExtractedLight> staticLights;
@@ -627,12 +608,6 @@ class Renderer {
     bool createCommandPool();
 
     // Shadow mapping methods
-    bool createShadowMaps();
-    bool createShadowMapRenderPass();
-    bool createShadowMapFramebuffers();
-    bool createShadowMapDescriptorSetLayout();
-    void renderShadowMaps(const std::vector<Entity*>& entities, const std::vector<ExtractedLight>& lights);
-    void updateShadowMapUniforms(uint32_t lightIndex, const ExtractedLight& light);
     bool createComputeCommandPool();
     bool createDepthResources();
     bool createTextureImage(const std::string& texturePath, TextureResources& resources);

attachments/simple_engine/renderer_core.cpp

@@ -162,29 +162,6 @@ bool Renderer::Initialize(const std::string& appName, bool enableValidationLayer
         return false;
     }
 
-    // Create shadow maps for shadow mapping
-    if (!createShadowMaps()) {
-        std::cerr << "Failed to create shadow maps" << std::endl;
-        return false;
-    }
-
-    // Create a shadow map render pass
-    if (!createShadowMapRenderPass()) {
-        std::cerr << "Failed to create shadow map render pass" << std::endl;
-        return false;
-    }
-
-    // Create shadow map framebuffers
-    if (!createShadowMapFramebuffers()) {
-        std::cerr << "Failed to create shadow map framebuffers" << std::endl;
-        return false;
-    }
-
-    // Create a shadow map descriptor set layout
-    if (!createShadowMapDescriptorSetLayout()) {
-        std::cerr << "Failed to create shadow map descriptor set layout" << std::endl;
-        return false;
-    }
 
     // Create command buffers
     if (!createCommandBuffers()) {

attachments/simple_engine/renderer_pipelines.cpp

@@ -95,17 +95,9 @@ bool Renderer::createPBRDescriptorSetLayout() {
                 .stageFlags = vk::ShaderStageFlagBits::eFragment,
                 .pImmutableSamplers = nullptr
             },
-            // Binding 6: Shadow map array
+            // Binding 6: Light storage buffer (shadows removed)
             vk::DescriptorSetLayoutBinding{
                 .binding = 6,
-                .descriptorType = vk::DescriptorType::eCombinedImageSampler,
-                .descriptorCount = MAX_SHADOW_MAPS, // Array of shadow maps (dynamic count)
-                .stageFlags = vk::ShaderStageFlagBits::eFragment,
-                .pImmutableSamplers = nullptr
-            },
-            // Binding 7: Light storage buffer
-            vk::DescriptorSetLayoutBinding{
-                .binding = 7,
                 .descriptorType = vk::DescriptorType::eStorageBuffer,
                 .descriptorCount = 1,
                 .stageFlags = vk::ShaderStageFlagBits::eFragment,