the lighting in the PBR scene *looks* better. There's still a bit that doesn't quite feel right. Need to investigate. But position was getting set close to the origin so something screwy is still going on.

gpx1000 · gpx1000 · commit a5edf28b5ad8 · 2025-08-11T01:54:33.000-07:00
diff --git a/attachments/simple_engine/descriptor_manager.cpp b/attachments/simple_engine/descriptor_manager.cpp
@@ -52,14 +52,12 @@ bool DescriptorManager::createUniformBuffers(Entity* entity, uint32_t maxFramesI
         vk::DeviceSize bufferSize = sizeof(UniformBufferObject);
 
         // Create entity resources if they don't exist
-        if (entityResources.find(entity) == entityResources.end()) {
-            entityResources[entity] = EntityResources();
-        }
+        auto entityResourcesIt = entityResources.try_emplace( entity ).first;
 
         // Clear existing uniform buffers
-        entityResources[entity].uniformBuffers.clear();
-        entityResources[entity].uniformBuffersMemory.clear();
-        entityResources[entity].uniformBuffersMapped.clear();
+        entityResourcesIt->second.uniformBuffers.clear();
+        entityResourcesIt->second.uniformBuffersMemory.clear();
+        entityResourcesIt->second.uniformBuffersMapped.clear();
 
         // Create uniform buffers
         for (size_t i = 0; i < maxFramesInFlight; i++) {
@@ -74,9 +72,9 @@ bool DescriptorManager::createUniformBuffers(Entity* entity, uint32_t maxFramesI
             void* data = bufferMemory.mapMemory(0, bufferSize);
 
             // Store resources
-            entityResources[entity].uniformBuffers.push_back(std::move(buffer));
-            entityResources[entity].uniformBuffersMemory.push_back(std::move(bufferMemory));
-            entityResources[entity].uniformBuffersMapped.push_back(data);
+            entityResourcesIt->second.uniformBuffers.push_back(std::move(buffer));
+            entityResourcesIt->second.uniformBuffersMemory.push_back(std::move(bufferMemory));
+            entityResourcesIt->second.uniformBuffersMapped.push_back(data);
         }
 
         return true;
diff --git a/attachments/simple_engine/model_loader.cpp b/attachments/simple_engine/model_loader.cpp
@@ -41,7 +41,7 @@ static bool LoadKTX2FileToRGBA(const std::string& filePath, std::vector<uint8_t>
 
 // Emissive scaling factor to convert from Blender units to engine units
 #define EMISSIVE_SCALE_FACTOR (1.0f / 638.0f)
-#define LIGHT_SCALE_FACTOR (1.0f / 2.0f) // The sun is way too bright
+#define LIGHT_SCALE_FACTOR (1.0f / 638.0f)
 
 ModelLoader::~ModelLoader() {
     // Destructor implementation
@@ -184,6 +184,7 @@ bool ModelLoader::ParseGLTF(const std::string& filename, Model* model) {
         std::cout << "Blender generator detected, applying blender factor" << std::endl;
         light_scale = EMISSIVE_SCALE_FACTOR;
     }
+    light_scale = EMISSIVE_SCALE_FACTOR;
 
     // Track loaded textures to prevent loading the same texture multiple times
     std::set<std::string> loadedTextures;
@@ -1061,8 +1062,19 @@ bool ModelLoader::ParseGLTF(const std::string& filename, Model* model) {
                             } else {
                                 std::cerr << "      Failed to load embedded normal texture: " << textureId << std::endl;
                             }
+                        } else if (!image.uri.empty()) {
+                            // Fallback: load KTX2 from a file and upload to memory
+                            std::vector<uint8_t> data; int w=0,h=0,c=0;
+                            std::string filePath = baseTexturePath + image.uri;
+                            if (LoadKTX2FileToRGBA(filePath, data, w, h, c) &&
+                                renderer->LoadTextureFromMemory(textureId, data.data(), w, h, c)) {
+                                materialMesh.normalTexturePath = textureId;
+                                std::cout << "    Loaded normal KTX2 file: " << filePath << std::endl;
+                                } else {
+                                    std::cerr << "    Failed to load normal KTX2 file: " << filePath << std::endl;
+                                }
                         } else {
-                            std::cerr << "      Warning: No decoded bytes for normal texture index " << texIndex << std::endl;
+                            std::cerr << "    Warning: No decoded bytes for normal texture index " << texIndex << std::endl;
                         }
                     }
                 }
@@ -1265,7 +1277,7 @@ bool ModelLoader::ParseGLTF(const std::string& filename, Model* model) {
     std::cout << "Extracting lights from GLTF model..." << std::endl;
 
     // Extract punctual lights (KHR_lights_punctual extension)
-    if (!ExtractPunctualLights(gltfModel, filename)) {
+    if (ExtractPunctualLights(gltfModel, filename)) {
         std::cerr << "Warning: Failed to extract punctual lights from " << filename << std::endl;
     }
 
@@ -1294,7 +1306,7 @@ std::vector<ExtractedLight> ModelLoader::GetExtractedLights(const std::string& m
 
                 // Check if this material has emissive properties (no threshold filtering)
                 float emissiveIntensity = glm::length(material->emissive) * material->emissiveStrength;
-                if (emissiveIntensity >= 0.0f) { // Accept all emissive materials, including zero intensities
+                if (emissiveIntensity >= 0.1f) {
                     // Calculate the center position of the emissive surface
                     glm::vec3 center(0.0f);
                     if (!materialMesh.vertices.empty()) {
@@ -1315,18 +1327,13 @@ std::vector<ExtractedLight> ModelLoader::GetExtractedLights(const std::string& m
                         avgNormal = glm::vec3(0.0f, -1.0f, 0.0f); // Default downward direction
                     }
 
-                    // CRITICAL FIX: Offset the light position away from the surface
-                    // This allows the emissive light to properly illuminate the surface from outside
-                    float offsetDistance = 0.5f; // Offset distance from surface
-                    glm::vec3 lightPosition = center + avgNormal * offsetDistance;
-
                     // Create an emissive light source
                     ExtractedLight emissiveLight;
                     emissiveLight.type = ExtractedLight::Type::Emissive;
-                    emissiveLight.position = lightPosition; // Use the offset position
+                    emissiveLight.position = center;
                     emissiveLight.color = material->emissive;
                     emissiveLight.intensity = material->emissiveStrength;
-                    emissiveLight.range = 10.0f; // Default range for emissive lights
+                    emissiveLight.range = 1.0f; // Default range for emissive lights
                     emissiveLight.sourceMaterial = material->GetName();
                     emissiveLight.direction = avgNormal;
 
@@ -1485,4 +1492,3 @@ bool ModelLoader::ExtractPunctualLights(const tinygltf::Model& gltfModel, const
     std::cout << "  Extracted " << lights.size() << " total lights from model" << std::endl;
     return lights.empty();
 }
-
diff --git a/attachments/simple_engine/physics_system.cpp b/attachments/simple_engine/physics_system.cpp
@@ -1158,15 +1158,13 @@ void PhysicsSystem::ReadbackGPUPhysicsData() const {
     if (vulkanResources.persistentCounterMemory) {
         static uint32_t lastPairCount = UINT32_MAX;
         static uint32_t lastCollisionCount = UINT32_MAX;
-        static int debugFrames = 0;
         const uint32_t* counters = static_cast<const uint32_t*>(vulkanResources.persistentCounterMemory);
         uint32_t pairCount = counters[0];
         uint32_t collisionCount = counters[1];
-        if (debugFrames < 120 && (pairCount != lastPairCount || collisionCount != lastCollisionCount)) {
-            std::cout << "Physics GPU counters - pairs: " << pairCount << ", collisions: " << collisionCount << std::endl;
+        if (pairCount != lastPairCount || collisionCount != lastCollisionCount) {
+            // std::cout << "Physics GPU counters - pairs: " << pairCount << ", collisions: " << collisionCount << std::endl;
             lastPairCount = pairCount;
             lastCollisionCount = collisionCount;
-            debugFrames++;
         }
     }
 
diff --git a/attachments/simple_engine/renderer.h b/attachments/simple_engine/renderer.h
@@ -45,7 +45,7 @@ struct SwapChainSupportDetails {
  * @brief Structure for individual light data in the storage buffer.
  */
 struct LightData {
-    alignas(16) glm::vec4 position;      // Light position (w component unused)
+    alignas(16) glm::vec4 position;      // Light position (w component used for direction vs position)
     alignas(16) glm::vec4 color;         // Light color and intensity
     alignas(16) glm::mat4 lightSpaceMatrix; // Light space matrix for shadow mapping
     alignas(4) int lightType;            // 0=Point, 1=Directional, 2=Spot, 3=Emissive
diff --git a/attachments/simple_engine/renderer_resources.cpp b/attachments/simple_engine/renderer_resources.cpp
@@ -1218,13 +1218,6 @@ bool Renderer::createDescriptorSets(Entity* entity, const std::string& texturePa
                     descriptor_path_resolved: ;
                 }
 
-                // Debug: report resolved baseColor texture binding for this entity
-                if (meshComponent) {
-                    const std::string& bc = pbrTexturePaths[0];
-                    bool present = textureResources.find(bc) != textureResources.end();
-                    std::cout << "PBR baseColor for entity '" << entity->GetName() << "': '" << bc
-                              << "' (" << (present ? "loaded" : "not in cache") << ")" << std::endl;
-                }
                 // Create descriptor writes for all 5 texture bindings
                 for (int binding = 1; binding <= 5; binding++) {
                     descriptorWrites[binding] = vk::WriteDescriptorSet{
@@ -1934,11 +1927,7 @@ bool Renderer::updateLightStorageBuffer(uint32_t frameIndex, const std::vector<E
                 lightData[i].position = glm::vec4(light.position, 1.0f); // w=1 indicates position
             }
 
-            // Set light color with proper intensity (remove the division by 683 that was making lights too dim)
-            float intensity = light.intensity;
-            if (intensity < 5.0f) intensity = 5.0f; // Minimum intensity to prevent completely dark lights
-
-            lightData[i].color = glm::vec4(light.color * intensity, 1.0f);
+            lightData[i].color = glm::vec4(light.color * light.intensity, 1.0f);
 
             // Calculate light space matrix for shadow mapping
             glm::mat4 lightProjection, lightView;
diff --git a/attachments/simple_engine/shaders/pbr.slang b/attachments/simple_engine/shaders/pbr.slang
@@ -23,7 +23,7 @@ struct VSOutput {
 
 // Light data structure for storage buffer
 struct LightData {
-    float4 position;      // Light position (w component unused)
+    float4 position;      // Light position (w component 1 for directional)
     float4 color;         // Light color and intensity
     float4x4 lightSpaceMatrix; // Light space matrix for shadow mapping
     int lightType;        // 0=Point, 1=Directional, 2=Spot, 3=Emissive
@@ -217,40 +217,64 @@ float4 PSMain(VSOutput input) : SV_TARGET
     // Calculate lighting for each light (dynamic count - no limit)
     for (int i = 0; i < ubo.lightCount; i++) {
         LightData light = lightBuffer[i];
-        float3 lightPos = light.position.xyz;
+        float3 lightPos = mul(light.lightSpaceMatrix, float4(input.WorldPos, 1.0)).xyz;
+        float3 lightVec = light.position.xyz;
         float3 lightColor = light.color.rgb;
 
         // Handle emissive lights differently
         if (light.lightType == 3) { // Emissive light
-            // For emissive lights, treat them as area lights with enhanced contribution
-            // Calculate light direction and distance
+            // Treat emissive like a positional contributor from its stored position
             float3 L = normalize(lightPos - input.WorldPos);
             float distance = length(lightPos - input.WorldPos);
+            float attenuation = 1.0 / (distance * distance);
+            float3 radiance = lightColor * attenuation;
+
+            float3 H = normalize(V + L);
+
+            float NdotL = max(dot(N, L), 0.0);
+            float NdotV = max(dot(N, V), 0.0);
+            float NdotH = max(dot(N, H), 0.0);
+            float HdotV = max(dot(H, V), 0.0);
+
+            float shadow = 0.0;
+            if (i < ubo.shadowMapCount) {
+                float4 fragPosLightSpace = mul(light.lightSpaceMatrix, float4(input.WorldPos, 1.0));
+                shadow = calculateShadow(fragPosLightSpace, i, N, L);
+            }
 
-            // Enhanced attenuation for emissive lights to make them more effective
-            float attenuation = 1.0 / (1.0 + 0.1 * distance + 0.01 * distance * distance);
+            float D = DistributionGGX(NdotH, roughness);
+            float G = GeometrySmith(NdotV, NdotL, roughness);
+            float3 F = FresnelSchlick(HdotV, F0);
+
+            float3 numerator = D * G * F;
+            float denominator = 4.0 * NdotV * NdotL + 0.0001;
+            float3 specular = numerator / denominator;
+
+            float3 kS = F;
+            float3 kD = float3(1.0, 1.0, 1.0) - kS;
+            kD *= 1.0 - metallic;
+
+            float shadowFactor = 1.0 - shadow;
+            Lo += (kD * baseColor.rgb / PI + specular) * radiance * NdotL * shadowFactor;
 
-            // Boost emissive light intensity to make them more visible
-            float3 radiance = lightColor * attenuation * 2.0; // 2x multiplier for emissive lights
+        } else if (light.lightType == 1) { // Directional light
+            // For directional lights, position field stores direction; use no distance attenuation
+            float3 L = normalize(-lightVec); // light direction towards the surface
+            float3 radiance = lightColor;    // No attenuation with distance
 
-            // Calculate half vector
             float3 H = normalize(V + L);
 
-            // Calculate BRDF terms
             float NdotL = max(dot(N, L), 0.0);
             float NdotV = max(dot(N, V), 0.0);
             float NdotH = max(dot(N, H), 0.0);
             float HdotV = max(dot(H, V), 0.0);
 
-            // Calculate shadow factor for emissive lights
             float shadow = 0.0;
             if (i < ubo.shadowMapCount) {
-                // Transform fragment position to light space
                 float4 fragPosLightSpace = mul(light.lightSpaceMatrix, float4(input.WorldPos, 1.0));
                 shadow = calculateShadow(fragPosLightSpace, i, N, L);
             }
 
-            // Specular BRDF
             float D = DistributionGGX(NdotH, roughness);
             float G = GeometrySmith(NdotV, NdotL, roughness);
             float3 F = FresnelSchlick(HdotV, F0);
@@ -259,40 +283,32 @@ float4 PSMain(VSOutput input) : SV_TARGET
             float denominator = 4.0 * NdotV * NdotL + 0.0001;
             float3 specular = numerator / denominator;
 
-            // Energy conservation
             float3 kS = F;
             float3 kD = float3(1.0, 1.0, 1.0) - kS;
             kD *= 1.0 - metallic;
 
-            // Apply shadow factor to lighting
             float shadowFactor = 1.0 - shadow;
             Lo += (kD * baseColor.rgb / PI + specular) * radiance * NdotL * shadowFactor;
 
-        } else { // Regular lights (Point, Directional, Spot)
-            // Calculate light direction and distance
+        } else { // Point/Spot lights
             float3 L = normalize(lightPos - input.WorldPos);
             float distance = length(lightPos - input.WorldPos);
             float attenuation = 1.0 / (distance * distance);
             float3 radiance = lightColor * attenuation;
 
-            // Calculate half vector
             float3 H = normalize(V + L);
 
-            // Calculate BRDF terms
             float NdotL = max(dot(N, L), 0.0);
             float NdotV = max(dot(N, V), 0.0);
             float NdotH = max(dot(N, H), 0.0);
             float HdotV = max(dot(H, V), 0.0);
 
-            // Calculate shadow factor
             float shadow = 0.0;
             if (i < ubo.shadowMapCount) {
-                // Transform fragment position to light space
                 float4 fragPosLightSpace = mul(light.lightSpaceMatrix, float4(input.WorldPos, 1.0));
                 shadow = calculateShadow(fragPosLightSpace, i, N, L);
             }
 
-            // Specular BRDF
             float D = DistributionGGX(NdotH, roughness);
             float G = GeometrySmith(NdotV, NdotL, roughness);
             float3 F = FresnelSchlick(HdotV, F0);
@@ -301,12 +317,10 @@ float4 PSMain(VSOutput input) : SV_TARGET
             float denominator = 4.0 * NdotV * NdotL + 0.0001;
             float3 specular = numerator / denominator;
 
-            // Energy conservation
             float3 kS = F;
             float3 kD = float3(1.0, 1.0, 1.0) - kS;
             kD *= 1.0 - metallic;
 
-            // Apply shadow factor to lighting (1.0 - shadow means 0 shadow = full light, 1 shadow = no light)
             float shadowFactor = 1.0 - shadow;
             Lo += (kD * baseColor.rgb / PI + specular) * radiance * NdotL * shadowFactor;
         }
