Feat: Realistic PBR Renderer

.gitignore

@@ -7,9 +7,13 @@
 
 # Build
 /build/
-/scripts/local_*.sh
 /projects/
-/resources/
+
+# Resources
+/resources/fonts/
+/resources/icons/
+/resources/meshes/
+/resources/textures/
 
 # Visual Studio
 /.vs

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.14)
 
-project(atta VERSION 0.3.10 LANGUAGES CXX C)
+project(atta VERSION 0.3.11 LANGUAGES CXX C)
 
 option(ATTA_BUILD_TESTS "Set to ON to build also the test executables" ON)
 option(ATTA_BUILD_DOCS "Build the documentation" OFF)

examples/tutorials/material-resource/material-resource.atta

@@ -1,5 +1,5 @@
 [project]
-attaVersion = "0.3.7"
+attaVersion = "0.3.10"
 name = "material-resource"
 
 [config]
@@ -166,3 +166,8 @@ transform.position = vec3(0.000000, 0.000000, 2.548024)
 transform.orientation = quat(0.000000, 0.000000, 0.000000, 1.000000)
 transform.scale = vec3(1.000000, 1.000000, 1.000000)
 
+[node]
+id = 9
+environmentLight.sid = "environment/suburban_soccer_park_2k.hdr"
+name.name = "Environment light"
+

resources/shaders/common/depth.asl

@@ -0,0 +1,18 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+perDraw mat4 uModel;
+perDraw vec4 uColor;
+// uniform sampler2D uDepthMap;
+
+perVertex vec3 vUV;
+
+vec4 vertex(vec3 iVertex, vec3 iNormal, vec3 iUV) {
+    vUV = iUV;
+    return uProjection * uView * uModel * vec4(iVertex, 1.0f);
+}
+
+vec4 fragment() {
+    // float depthValue = texture(depthMap, vUV).r;
+    // return vec4(vec3(depthValue), 1.0f);
+    return vec4(0, 0, 0, 1);
+}

resources/shaders/common/drawerLine.asl

@@ -0,0 +1,12 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+
+perVertex vec4 vColor;
+
+vec4 vertex(vec3 iPos, vec4 iColor) {
+    vec4 pos = uProjection * uView * vec4(iPos, 1.0);
+    vColor = iColor;
+    return vec4(pos.xyz, pos.w);
+}
+
+void fragment(out vec4 color) { color = vColor; }

resources/shaders/common/drawerPoint.asl

@@ -0,0 +1,14 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+
+perVertex vec4 vColor;
+
+vec4 vertex(vec3 iPos, vec4 iColor) {
+    vec4 pos = uProjection * uView * vec4(iPos, 1.0);
+    vColor = iColor;
+    gl_PointSize = 5.0;
+    return pos;
+}
+
+void fragment(out vec4 color) { color = vColor; }
+

resources/shaders/common/grid.asl

@@ -0,0 +1,28 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+perFrame vec3 uCamPos;
+
+perVertex vec4 vColor;
+perVertex vec3 vFragPos;
+
+vec4 vertex(vec3 iPos, vec4 iColor, float iWidth) {
+    vec4 pos = uProjection * uView * vec4(iPos, 1.0);
+    vColor = iColor;
+    vFragPos = iPos;
+    return vec4(pos.xyz, pos.w);
+}
+
+void fragment(out vec4 color) {
+    float dist = length(uCamPos - vFragPos) + 0.0001;
+    color = vColor;
+
+    // Parameters for controlling the fade effect
+    float fadeStart = 20.0; // Distance where the fading starts
+    float fadeEnd = 50.0;   // Distance where the grid is fully faded/transparent
+
+    // Clamped ratio between where fading starts and where it ends
+    float fadeRatio = clamp((dist - fadeStart) / (fadeEnd - fadeStart), 0.0, 1.0);
+
+    // Apply fade falloff
+    color.a *= 1.0 - fadeRatio;
+}

resources/shaders/common/selected.asl

@@ -0,0 +1,8 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+perDraw mat4 uModel;
+perDraw vec4 uColor;
+
+vec4 vertex(vec3 iVertex, vec3 iNormal, vec3 iUV) { return uProjection * uView * uModel * vec4(iVertex, 1.0f); }
+
+vec4 fragment() { return uColor; }

resources/shaders/common/skybox.asl

@@ -0,0 +1,20 @@
+perFrame mat4 uProjection;
+perFrame mat4 uView;
+perFrame samplerCube uEnvironmentMap;
+
+perVertex vec3 vTexCoords;
+
+vec4 vertex(vec3 iVertex, vec3 iNormal, vec2 iUV) {
+    vTexCoords = iVertex;
+    // Add small dependency between vertex and normal/uv to avoid compilation error
+    vTexCoords += iNormal / 10000.0f + vec3(iUV,0) / 10000.0f;
+
+    // Remove translation from the view matrix (so the skybox remains centered)
+    mat4 rotView = mat4(mat3(uView));
+    return uProjection * rotView * vec4(iVertex, 1.0);
+}
+
+void fragment(out vec4 color) {
+    // Sample the cubemap using the normalized direction
+    color = texture(uEnvironmentMap, normalize(vTexCoords));
+}

resources/shaders/compute/brdf.asl

@@ -0,0 +1,92 @@
+perVertex vec2 uv;
+
+vec4 vertex(vec2 iVertex, vec2 iUV) {
+    uv = iUV;
+    return vec4(iVertex, 0.0, 1.0);
+}
+
+const float PI = 3.14159265359;
+
+float RadicalInverse_VdC(uint bits) {
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return float(bits) * 2.3283064365386963e-10;
+}
+
+vec2 Hammersley(uint i, uint N) {
+    return vec2(float(i) / float(N), RadicalInverse_VdC(i));
+}
+
+vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness) {
+    float a = roughness * roughness;
+
+    float phi = 2.0 * PI * Xi.x;
+    float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y));
+    float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+
+    vec3 H;
+    H.x = cos(phi) * sinTheta;
+    H.y = sin(phi) * sinTheta;
+    H.z = cosTheta;
+
+    vec3 up        = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+    vec3 tangent   = normalize(cross(up, N));
+    vec3 bitangent = cross(N, tangent);
+
+    return normalize(tangent * H.x + bitangent * H.y + N * H.z);
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness) {
+    float a = roughness;
+    float k = (a * a) / 2.0;
+    return NdotV / (NdotV * (1.0 - k) + k);
+}
+
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    return GeometrySchlickGGX(NdotV, roughness) * GeometrySchlickGGX(NdotL, roughness);
+}
+
+vec2 IntegrateBRDF(float NdotV, float roughness) {
+    vec3 V;
+    V.x = sqrt(1.0 - NdotV * NdotV);
+    V.y = 0.0;
+    V.z = NdotV;
+
+    float A = 0.0;
+    float B = 0.0;
+
+    vec3 N = vec3(0.0, 0.0, 1.0);
+
+    const uint SAMPLE_COUNT = 1024u;
+    for (uint i = 0u; i < SAMPLE_COUNT; ++i) {
+        vec2 Xi = Hammersley(i, SAMPLE_COUNT);
+        vec3 H  = ImportanceSampleGGX(Xi, N, roughness);
+        vec3 L  = normalize(2.0 * dot(V, H) * H - V);
+
+        float NdotL = max(L.z, 0.0);
+        float NdotH = max(H.z, 0.0);
+        float VdotH = max(dot(V, H), 0.0);
+
+        if (NdotL > 0.0) {
+            float G     = GeometrySmith(N, V, L, roughness);
+            float G_Vis = (G * VdotH) / (NdotH * NdotV);
+            float Fc    = pow(1.0 - VdotH, 5.0);
+
+            A += (1.0 - Fc) * G_Vis;
+            B += Fc * G_Vis;
+        }
+    }
+    A /= float(SAMPLE_COUNT);
+    B /= float(SAMPLE_COUNT);
+    return vec2(A, B);
+}
+
+void fragment(out vec4 color) {
+    vec2 integratedBRDF = IntegrateBRDF(uv.x, uv.y);
+    color = vec4(integratedBRDF, 0.0, 1.0);
+}

resources/shaders/compute/entityClick.asl

@@ -0,0 +1,8 @@
+perFrame mat4 projection;
+perFrame mat4 view;
+perDraw mat4 model;
+perDraw int entityId;
+
+vec4 vertex(vec3 inPos, vec3 inNormal, vec2 inUV) { return projection * view * model * vec4(inPos, 1.0f); }
+
+void fragment(out int eid) { eid = entityId; }

resources/shaders/compute/equiToCubemap.asl

@@ -0,0 +1,26 @@
+perFrame mat4 uProjection;
+perFrame mat4 uView;
+perFrame sampler2D uEquirectangularMap;
+
+perVertex vec3 localPos;
+
+vec4 vertex(vec3 iPos, vec3 iNormal, vec2 iUV) {
+    localPos = iPos;
+    // Add small dependency between vertex and normal/uv to avoid compilation error
+    localPos += iNormal / 10000.0f + vec3(iUV,0) / 10000.0f;
+    return uProjection * uView * vec4(localPos, 1.0);
+}
+
+const vec2 invAtan = vec2(0.1591, 0.3183);
+vec2 sampleSphericalMap(vec3 v) {
+    // Z-up convention: azimuth in XY plane, elevation along Z axis
+    vec2 uv = vec2(atan(v.y, v.x), asin(v.z));
+    uv *= invAtan;
+    uv += 0.5;
+    return uv;
+}
+
+void fragment(out vec4 color) {
+    vec2 uv = sampleSphericalMap(normalize(localPos));
+    color = vec4(texture(uEquirectangularMap, uv).rgb, 1.0);
+}

resources/shaders/compute/irradiance.asl

@@ -0,0 +1,38 @@
+perFrame mat4 uProjection;
+perFrame mat4 uView;
+perFrame samplerCube uEnvironmentMap;
+
+perVertex vec3 localPos;
+
+vec4 vertex(vec3 iPos, vec3 iNormal, vec2 iUV) {
+    localPos = iPos;
+    localPos += iNormal / 10000.0f + vec3(iUV, 0) / 10000.0f;
+    return uProjection * uView * vec4(localPos, 1.0);
+}
+
+const float PI = 3.14159265359;
+
+void fragment(out vec4 color) {
+    vec3 N = normalize(localPos);
+
+    vec3 irradiance = vec3(0.0);
+
+    vec3 up    = vec3(0.0, 1.0, 0.0);
+    vec3 right = normalize(cross(up, N));
+    up         = normalize(cross(N, right));
+
+    float sampleDelta = 0.025;
+    float nrSamples = 0.0;
+    for (float phi = 0.0; phi < 2.0 * PI; phi += sampleDelta) {
+        for (float theta = 0.0; theta < 0.5 * PI; theta += sampleDelta) {
+            vec3 tangentSample = vec3(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
+            vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * N;
+
+            irradiance += texture(uEnvironmentMap, sampleVec).rgb * cos(theta) * sin(theta);
+            nrSamples++;
+        }
+    }
+    irradiance = PI * irradiance * (1.0 / float(nrSamples));
+
+    color = vec4(irradiance, 1.0);
+}

resources/shaders/compute/prefilter.asl

@@ -0,0 +1,70 @@
+perFrame mat4 uProjection;
+perFrame mat4 uView;
+perFrame samplerCube uEnvironmentMap;
+perFrame float uRoughness;
+
+perVertex vec3 localPos;
+
+vec4 vertex(vec3 iPos, vec3 iNormal, vec2 iUV) {
+    localPos = iPos;
+    localPos += iNormal / 10000.0f + vec3(iUV, 0) / 10000.0f;
+    return uProjection * uView * vec4(localPos, 1.0);
+}
+
+const float PI = 3.14159265359;
+
+float RadicalInverse_VdC(uint bits) {
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return float(bits) * 2.3283064365386963e-10;
+}
+
+vec2 Hammersley(uint i, uint N) {
+    return vec2(float(i) / float(N), RadicalInverse_VdC(i));
+}
+
+vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness) {
+    float a = roughness * roughness;
+
+    float phi = 2.0 * PI * Xi.x;
+    float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y));
+    float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+
+    vec3 H;
+    H.x = cos(phi) * sinTheta;
+    H.y = sin(phi) * sinTheta;
+    H.z = cosTheta;
+
+    vec3 up        = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+    vec3 tangent   = normalize(cross(up, N));
+    vec3 bitangent = cross(N, tangent);
+
+    return normalize(tangent * H.x + bitangent * H.y + N * H.z);
+}
+
+void fragment(out vec4 color) {
+    vec3 N = normalize(localPos);
+    vec3 R = N;
+    vec3 V = R;
+
+    const uint SAMPLE_COUNT = 1024u;
+    float totalWeight = 0.0;
+    vec3 prefilteredColor = vec3(0.0);
+    for (uint i = 0u; i < SAMPLE_COUNT; ++i) {
+        vec2 Xi = Hammersley(i, SAMPLE_COUNT);
+        vec3 H  = ImportanceSampleGGX(Xi, N, uRoughness);
+        vec3 L  = normalize(2.0 * dot(V, H) * H - V);
+
+        float NdotL = max(dot(N, L), 0.0);
+        if (NdotL > 0.0) {
+            prefilteredColor += texture(uEnvironmentMap, L).rgb * NdotL;
+            totalWeight      += NdotL;
+        }
+    }
+    prefilteredColor = prefilteredColor / totalWeight;
+
+    color = vec4(prefilteredColor, 1.0);
+}

resources/shaders/drawer/line.asl

@@ -0,0 +1,12 @@
+perFrame mat4 uView;
+perFrame mat4 uProjection;
+
+perVertex vec4 vColor;
+
+vec4 vertex(vec3 iPos, vec4 iColor) {
+    vec4 pos = uProjection * uView * vec4(iPos, 1.0);
+    vColor = iColor;
+    return vec4(pos.xyz, pos.w);
+}
+
+void fragment(out vec4 color) { color = vColor; }