✨ feat: lighting

CMakeLists.txt

@@ -158,6 +158,7 @@ add_executable(${PROJECT_NAME}
     src/common/components/mesh-renderer.cpp
     src/common/components/free-camera-controller.cpp
     src/common/components/movement.cpp
+    src/common/components/light.cpp
 
     src/game/components/collider.cpp
     src/game/components/enemy.cpp

assets/shaders/lit.frag

@@ -0,0 +1,174 @@
+#version 330 core
+
+in Varyings {
+    vec4 color;
+    vec2 tex_coord;
+    vec3 worldPos;
+    vec3 worldNormal;
+    mat3 TBN;
+} fs_in;
+
+out vec4 frag_color;
+
+// ── Material ─────────────────────────────────────────────────────────
+struct Material {
+    // factors (used when no texture)
+    vec3 albedo;
+    float metallic;
+    float roughness;
+    float ambientOcclusion;
+    vec3 emission;
+
+    // textures + flags
+    sampler2D textureAlbedo;
+    bool hasTextureAlbedo;
+
+    sampler2D textureMetallic;
+    bool hasTextureMetallic;
+
+    sampler2D textureRoughness;
+    bool hasTextureRoughness;
+
+    sampler2D textureNormal;
+    bool hasTextureNormal;
+
+    sampler2D textureAmbientOcclusion;
+    bool hasTextureAmbientOcclusion;
+
+    sampler2D textureEmissive;
+    bool hasTextureEmissive;
+};
+uniform Material material;
+uniform float alphaThreshold;
+uniform vec4 tint;
+
+// ── Lights ───────────────────────────────────────────────────────────
+#define MAX_LIGHTS 8
+
+#define LIGHT_DIRECTIONAL 0
+#define LIGHT_POINT       1
+#define LIGHT_SPOT        2
+
+struct Light {
+    int type;
+    vec3 color;
+    vec3 position;
+    vec3 direction;
+    vec3 attenuation;   // (constant, linear, quadratic)
+    vec2 spotAngles;    // (inner, outer) in radians
+};
+uniform Light lights[MAX_LIGHTS];
+uniform int numLights;
+
+uniform vec3 cameraPos;
+
+// ── Helpers ───────────────────────────────────────────────────────────
+vec3 sampleAlbedo(vec2 uv) {
+    vec3 base = material.hasTextureAlbedo ? texture(material.textureAlbedo, uv).rgb : vec3(1.0);
+    return base * material.albedo;
+}
+
+float sampleMetallic(vec2 uv) {
+    return material.hasTextureMetallic ? texture(material.textureMetallic, uv).r * material.metallic : material.metallic;
+}
+
+float sampleRoughness(vec2 uv) {
+    return material.hasTextureRoughness ? texture(material.textureRoughness, uv).r * material.roughness : material.roughness;
+}
+
+float sampleAO(vec2 uv) {
+    return material.hasTextureAmbientOcclusion ? texture(material.textureAmbientOcclusion, uv).r * material.ambientOcclusion : material.ambientOcclusion;
+}
+
+vec3 sampleEmission(vec2 uv) {
+    return material.hasTextureEmissive ? texture(material.textureEmissive, uv).rgb * material.emission : material.emission;
+}
+
+vec3 sampleNormal(vec2 uv) {
+    if(!material.hasTextureNormal)
+        return normalize(fs_in.worldNormal);
+    vec3 n = texture(material.textureNormal, uv).rgb * 2.0 - 1.0;
+    return normalize(fs_in.TBN * n);
+}
+
+// ── Blinn-Phong per light ─────────────────────────────────────────────
+vec3 calcLight(
+    Light light,
+    vec3 N,
+    vec3 V,
+    vec3 albedo,
+    float roughness,
+    float metallic
+) {
+
+    vec3 L;
+    float attenuation = 1.0;
+
+    if(light.type == LIGHT_DIRECTIONAL) {
+        L = normalize(-light.direction);
+
+    } else {
+        vec3 toLight = light.position - fs_in.worldPos;
+        float dist = length(toLight);
+        L = normalize(toLight);
+
+        // quadratic attenuation: 1 / (c + l*d + q*d^2)
+        attenuation = 1.0 / (light.attenuation.x + light.attenuation.y * dist + light.attenuation.z * dist * dist);
+
+        if(light.type == LIGHT_SPOT) {
+            float theta = dot(L, normalize(-light.direction));
+            float innerCos = cos(light.spotAngles.x);
+            float outerCos = cos(light.spotAngles.y);
+            float epsilon = innerCos - outerCos;
+            float spot = clamp((theta - outerCos) / epsilon, 0.0, 1.0);
+            attenuation *= spot;
+        }
+    }
+
+    // diffuse
+    float diff = max(dot(N, L), 0.0);
+    vec3 diffuse = diff * albedo * light.color;
+
+    // specular (Blinn-Phong)
+    // roughness → shininess: rough=1 → shininess=2, rough=0 → shininess=256
+    float shininess = mix(256.0, 2.0, roughness);
+    vec3 H = normalize(L + V);
+    float spec = pow(max(dot(N, H), 0.0), shininess);
+    // metallic surfaces use albedo color for specular
+    vec3 specColor = mix(vec3(0.04), albedo, metallic);
+    vec3 specular = spec * specColor * light.color;
+
+    return (diffuse + specular) * attenuation;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────
+void main() {
+    vec2 uv = fs_in.tex_coord;
+    vec3 albedo = sampleAlbedo(uv) * fs_in.color.rgb * tint.rgb;
+    float metallic = sampleMetallic(uv);
+    float roughness = sampleRoughness(uv);
+    float ao = sampleAO(uv);
+    vec3 emission = sampleEmission(uv);
+    vec3 N = sampleNormal(uv);
+    vec3 V = normalize(cameraPos - fs_in.worldPos);
+
+    // ambient
+    vec3 ambient = vec3(0.03) * albedo * ao;
+
+    // accumulate all lights
+    vec3 lighting = vec3(0.0);
+    int lightCount = min(numLights, MAX_LIGHTS);
+    for(int i = 0; i < lightCount; i++) {
+        lighting += calcLight(lights[i], N, V, albedo, roughness, metallic);
+    }
+
+    vec3 result = ambient + lighting + emission;
+
+    // alpha from albedo texture or tint
+    float alpha = material.hasTextureAlbedo ? texture(material.textureAlbedo, uv).a * tint.a * fs_in.color.a : tint.a * fs_in.color.a;
+
+    if(alpha < alphaThreshold)
+        discard;
+
+    frag_color = vec4(result, alpha);
+}

assets/shaders/lit.vert

@@ -0,0 +1,37 @@
+#version 330 core
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec4 color;
+layout(location = 2) in vec2 tex_coord;
+layout(location = 3) in vec3 normal;
+layout(location = 4) in vec3 tangent;
+
+out Varyings {
+    vec4 color;
+    vec2 tex_coord;
+    vec3 worldPos;
+    vec3 worldNormal;
+    mat3 TBN;
+} vs_out;
+
+uniform mat4 transform;
+uniform mat4 model;
+
+void main() {
+    gl_Position = transform * vec4(position, 1.0);
+
+    vs_out.color = color;
+    vs_out.tex_coord = tex_coord;
+    vs_out.worldPos = vec3(model * vec4(position, 1.0));
+
+    // normal matrix — handles non-uniform scaling correctly
+    mat3 normalMatrix = transpose(inverse(mat3(model)));
+    vec3 N = normalize(normalMatrix * normal);
+    vs_out.worldNormal = N;
+
+    // TBN matrix for normal mapping
+    vec3 T = normalize(normalMatrix * tangent);
+    T = normalize(T - dot(T, N) * N);  // re-orthogonalize
+    vec3 B = cross(N, T);
+    vs_out.TBN = mat3(T, B, N);
+}

config/app.jsonc

@@ -22,6 +22,10 @@
                 "textured": {
                     "vs": "assets/shaders/textured.vert",
                     "fs": "assets/shaders/textured.frag"
+                },
+                "lit": {
+                    "vs": "assets/shaders/lit.vert",
+                    "fs": "assets/shaders/lit.frag"
                 }
             },
             "textures": {
@@ -144,8 +148,8 @@
                     "sampler": "default"
                 },
                 "monkey": {
-                    "type": "textured",
-                    "shader": "textured",
+                    "type": "lit",
+                    "shader": "lit",
                     "pipelineState": {
                         "faceCulling": {
                             "enabled": false
@@ -154,8 +158,8 @@
                             "enabled": true
                         }
                     },
-                    "tint": [1.0, 1.0, 1.0, 1.0],
-                    "texture": "monkey",
+                    "tint": [1, 1, 1, 1],
+                    "textureAlbedo": "monkey",
                     "sampler": "default"
                 },
                 "moon": {
@@ -178,8 +182,14 @@
         "game": {
             "enemySpawner": {
                 "spawnPoints": [
-                    [30.0, 0.0, 30.0], [-30.0, 0.0, 30.0], [30.0, 0.0, -30.0], [-30.0, 0.0, -30.0],
-                    [42.0, 0.0, 0.0], [-42.0, 0.0, 0.0], [0.0, 0.0, 42.0], [0.0, 0.0, -42.0]
+                    [30.0, 0.0, 30.0],
+                    [-30.0, 0.0, 30.0],
+                    [30.0, 0.0, -30.0],
+                    [-30.0, 0.0, -30.0],
+                    [42.0, 0.0, 0.0],
+                    [-42.0, 0.0, 0.0],
+                    [0.0, 0.0, 42.0],
+                    [0.0, 0.0, -42.0]
                 ],
                 "spawnInterval": 2.0,
                 "initialSpawnCount": 4,
@@ -283,6 +293,13 @@
                         "layer": "player",
                         "radius": 0.45,
                         "height": 1.8
+                    },
+                    {
+                        "type": "light",
+                        "lightType": "spot",
+                        "color": [1, 1, 1],
+                        "attenuation": [1.0, 0.22, 0.2],
+                        "spotAngles": [2, 5]
                     }
                 ]
             },
@@ -298,6 +315,17 @@
                         "material": "ground"
                     }
                 ]
+            },
+            {
+                "position": [2, 1, -2],
+                "scale": [5, 5, 5],
+                "components": [
+                    {
+                        "type": "Mesh Renderer",
+                        "mesh": "monkey",
+                        "material": "monkey"
+                    }
+                ]
             }
         ]
     }

flake.nix

@@ -65,6 +65,7 @@
             just-lsp
             ccache
             clang-tools
+            gdb
           ];
         };
 

src/common/asset-loader.cpp

@@ -115,6 +115,17 @@ namespace our {
         }
     }
 
+    template <>
+    void AssetLoader<our::Light>::deserialize(const nlohmann::json& data) {
+        if (data.is_object()) {
+            for (auto& [name, desc] : data.items()) {
+                our::Light* light = new our::Light();
+                light->deserialize(desc);
+                assets[name] = light;
+            }
+        }
+    };
+
     void deserializeAllAssets(const nlohmann::json& assetData) {
         if (!assetData.is_object()) return;
         if (assetData.contains("shaders")) AssetLoader<ShaderProgram>::deserialize(assetData["shaders"]);
@@ -123,6 +134,12 @@ namespace our {
         if (assetData.contains("meshes")) AssetLoader<Mesh>::deserialize(assetData["meshes"]);
         if (assetData.contains("materials")) AssetLoader<Material>::deserialize(assetData["materials"]);
         if (assetData.contains("sounds")) AssetLoader<AudioBuffer>::deserialize(assetData["sounds"]);
+        if (assetData.contains("lights")) AssetLoader<our::Light>::deserialize(assetData["lights"]);
+        // setting some default assets if something is missing
+        if (!AssetLoader<Sampler>::get("default")) {
+            Sampler* defaultSampler = new Sampler();
+            AssetLoader<Sampler>::add("default", defaultSampler);
+        }
     }
 
     void clearAllAssets() {

src/common/asset-loader.hpp

@@ -33,6 +33,10 @@ namespace our {
             }
             return nullptr;
         };
+
+        static void add(const std::string& name, T* asset) {
+            assets[name] = asset;
+        }
         // This function deletes all the assets held by this class and clear the assets map
         static void clear() {
             for (auto& [name, asset] : assets) {

src/common/components/component-deserializer.hpp

@@ -19,6 +19,7 @@ namespace our {
         ComponentRegistry::registerType<MovementComponent>();
         ComponentRegistry::registerType<MeshRendererComponent>();
         ComponentRegistry::registerType<AudioSourceComponent>();
+        ComponentRegistry::registerType<Light>();
 
         initialized = true;
     }

src/common/components/light.cpp

@@ -0,0 +1,25 @@
+#include "light.hpp"
+
+#include <deserialize-utils.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <json/json.hpp>
+
+namespace our {
+
+    void Light::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) return;
+        std::string typeStr = data.value("lightType", "point");
+        if (typeStr == "directional") {
+            type = LightType::DIRECTIONAL;
+        } else if (typeStr == "point") {
+            type = LightType::POINT;
+        } else if (typeStr == "spot") {
+            type = LightType::SPOT;
+        }
+        color = data.value("color", glm::vec3(1.0f, 1.0f, 1.0f));
+        attenuation = data.value("attenuation", glm::vec3(1.0f, 0.0f, 0.0f));
+        glm::vec2 spotAnglesDegrees = data.value("spotAngles", glm::vec2(15.0f, 30.0f));
+        spotAngles = {glm::radians(spotAnglesDegrees.x), glm::radians(spotAnglesDegrees.y)};
+    }
+}  // namespace our