Added support for texture cubemaps and IBL using reflection probes (#561)

* Added texture cube support
* Added reflection render pass (generates a cubemap for each reflection probe)
* Added reflection render feature (sends the cubemap to an entity about to be drawn.
* Reworked scene parsing:
  * Side effect: cannot cull per-model anymore, can only cull per-mesh
* Added Mat3 uniform support
* Added visibility flags to the material renderer, to exlude an actor from certain passes
* Deprecated cull model, cull mesh is preferred for now (will be added back when tackling #564)
* Added "depth test" option to debug shape drawer, so that bounds/volumes can be shown through objects
* Reflection probe data is passed to the shader as a UBO. In the future, we should implement a proper solution to handle multiple UBOs, and track their binding index
* Added material settings to enable/disable reflection capture & usage on a particular material.
* Separated material editor settings into pipeline (state mask) & general settings.
* Vastly improved PBR shader (re-organized)

Author: adriengivry

Resources/Engine/Shaders/Common/Buffers/EngineUBO.ovfxh

@@ -1,4 +1,4 @@
-layout (std140) uniform EngineUBO
+layout (std140, binding = 0) uniform EngineUBO
 {
     mat4    ubo_Model;
     mat4    ubo_View;

Resources/Engine/Shaders/Common/Buffers/ReflectionUBO.ovfxh

@@ -0,0 +1,9 @@
+layout (std140, binding = 1) uniform ReflectionUBO
+{
+    vec4 position;
+    mat4 rotation;
+    vec4 boxCenter;
+    vec4 boxHalfExtents;
+    float brightness;
+    bool boxProjection;
+} ubo_ReflectionProbeData;

Resources/Engine/Shaders/Common/Physics.ovfxh

@@ -1,12 +1,11 @@
-bool IsPointInAABB(vec3 point, vec3 aabbCenter, vec3 aabbHalfSize)
+float IsPointInAABB(vec3 p, vec3 center, vec3 halfSize)
 {
-    return
-        point.x > aabbCenter.x - aabbHalfSize.x && point.x < aabbCenter.x + aabbHalfSize.x &&
-        point.y > aabbCenter.y - aabbHalfSize.y && point.y < aabbCenter.y + aabbHalfSize.y &&
-        point.z > aabbCenter.z - aabbHalfSize.z && point.z < aabbCenter.z + aabbHalfSize.z;
+    vec3 d = abs(p - center) - halfSize;
+    return step(0.0, -max(d.x, max(d.y, d.z))); // returns 1.0 if inside, 0.0 if outside
 }
 
-bool IsPointInSphere(vec3 point, vec3 sphereCenter, float sphereRadius)
+float IsPointInSphere(vec3 p, vec3 center, float radius)
 {
-    return distance(point, sphereCenter) <= sphereRadius;
-}
+    float distSq = dot(p - center, p - center);
+    return step(distSq, radius * radius); // 1.0 if inside, 0.0 if outside
+}

Resources/Engine/Shaders/Lighting/IBL.ovfxh

@@ -0,0 +1,105 @@
+#include ":Shaders/Common/Buffers/ReflectionUBO.ovfxh"
+
+// https://seblagarde.wordpress.com/wp-content/uploads/2012/08/parallax_corrected_cubemap-siggraph2012.pdf
+vec3 BoxProjectionOBB(vec3 reflectionVector, vec3 worldPos, vec3 probePos, vec3 obbCenter, vec3 obbHalfExtents, mat3 obbOrientation)
+{
+    // Transform world position and reflection vector to OBB local space
+    vec3 localPos = obbOrientation * (worldPos - obbCenter);
+    vec3 localReflection = obbOrientation * reflectionVector;
+    vec3 localProbePos = obbOrientation * (probePos - obbCenter);
+    
+    // Perform AABB intersection in local space
+    vec3 ndr = normalize(localReflection);
+    vec3 rbmax = (obbHalfExtents - localPos) / ndr;
+    vec3 rbmin = (-obbHalfExtents - localPos) / ndr;
+    
+    vec3 rbminmax;
+    rbminmax.x = (ndr.x > 0.0) ? rbmax.x : rbmin.x;
+    rbminmax.y = (ndr.y > 0.0) ? rbmax.y : rbmin.y;
+    rbminmax.z = (ndr.z > 0.0) ? rbmax.z : rbmin.z;
+    float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);
+    
+    // Find intersection point in local space
+    vec3 localIntersection = localPos + ndr * fa;
+    
+    // Transform intersection back to world space
+    vec3 worldIntersection = transpose(obbOrientation) * localIntersection + obbCenter;
+    
+    return normalize(worldIntersection - probePos);
+}
+
+vec3 ParallaxCorrect(vec3 reflectionDir, vec3 worldPos)
+{
+    if (ubo_ReflectionProbeData.boxProjection)
+    {
+        return BoxProjectionOBB(
+            reflectionDir,
+            worldPos, 
+            ubo_ReflectionProbeData.position.xyz,
+            ubo_ReflectionProbeData.boxCenter.xyz,
+            ubo_ReflectionProbeData.boxHalfExtents.xyz,
+            mat3(ubo_ReflectionProbeData.rotation)
+        );
+    }
+    
+    return reflectionDir; // No box projection, return original reflection direction
+}
+
+// BRDF integration approximation for IBL specular
+vec2 EnvBRDFApprox(float NdotV, float roughness)
+{
+    // Approximation from "Moving Frostbite to PBR" by Lagarde & de Rousiers
+    // This is great because it mitigates the need to sample a precomputed BRDF LUT!
+    const vec4 c0 = vec4(-1, -0.0275, -0.572, 0.022);
+    const vec4 c1 = vec4(1, 0.0425, 1.04, -0.04);
+    vec4 r = roughness * c0 + c1;
+    float a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;
+    vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;
+    return AB;
+}
+
+// Modified Fresnel-Schlick approximation that includes roughness term for IBL
+vec3 FresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
+{
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+vec3 CalculateImageBasedLighting(
+    samplerCube environmentMap,
+    vec3 fragPos,
+    vec3 V,
+    vec3 N,
+    float roughness,
+    float metallic,
+    vec3 F0,
+    float NdotV,
+    vec3 albedo
+) {
+    // 0. Constants
+    const int environmentMaxLOD = textureQueryLevels(environmentMap) - 1;
+    
+    // 1. Calculate reflection vector
+    const vec3 R = ParallaxCorrect(reflect(-V, N), fragPos);
+    
+    // 2. Diffuse irradiance (environment lighting)
+    const vec3 irradiance = textureLod(environmentMap, N, environmentMaxLOD).rgb; // High mip level for diffuse
+    
+    // 3. Specular reflection
+    const vec3 prefilteredColor = textureLod(environmentMap, R, roughness * environmentMaxLOD).rgb;
+    
+    // 4. Apply BRDF
+    const vec2 brdf = EnvBRDFApprox(NdotV, roughness);
+    
+    // 5. Calculate Fresnel for IBL
+    const vec3 F_IBL = FresnelSchlickRoughness(NdotV, F0, roughness);
+    
+    // 6. Calculate specular and diffuse IBL components
+    const vec3 kS_IBL = F_IBL;
+    const vec3 kD_IBL = (1.0 - kS_IBL) * (1.0 - metallic);
+    
+    const vec3 diffuseIBL = kD_IBL * irradiance * albedo;
+    const vec3 specularIBL = prefilteredColor * (F_IBL * brdf.x + brdf.y);
+    
+    // 7. Return IBL contribution
+    return (diffuseIBL + specularIBL) * ubo_ReflectionProbeData.brightness;
+}

Resources/Engine/Shaders/Lighting/Light.ovfxh

@@ -0,0 +1,195 @@
+#include ":Shaders/Common/Physics.ovfxh"
+#include ":Shaders/Lighting/Shadow.ovfxh"
+
+struct Light
+{
+    int type;
+    float intensity;
+    vec3 color;
+    mat4 data;
+};
+
+struct PointLight
+{
+    float intensity;
+    vec3 color;
+    vec3 position;
+    float constant;
+    float linear;
+    float quadratic;
+};
+
+struct DirectionalLight
+{
+    float intensity;
+    vec3 color;
+    vec3 direction;
+    bool hasShadow;
+};
+
+struct SpotLight
+{
+    float intensity;
+    vec3 color;
+    vec3 position;
+    vec3 direction;
+    float innerCutoff;
+    float outerCutoff;
+    float constant;
+    float linear;
+    float quadratic;
+};
+
+struct AmbientBoxLight
+{
+    float intensity;
+    vec3 color;
+    vec3 position;
+    vec3 size;
+};
+
+struct AmbientSphereLight
+{
+    float intensity;
+    vec3 color;
+    vec3 position;
+    float radius;
+};
+
+Light ExtractLight(mat4 light)
+{
+    Light lightInfo;
+    lightInfo.type = int(light[3][0]);
+    lightInfo.intensity = light[3][3];
+    lightInfo.color = UnPack(light[2][0]);
+    lightInfo.data = light;
+    return lightInfo;
+}
+
+PointLight ExtractPointLight(Light light)
+{
+    PointLight pointLight;
+    pointLight.intensity = light.intensity;
+    pointLight.color = light.color;
+    pointLight.position = light.data[0].rgb;
+    pointLight.constant = light.data[0][3];
+    pointLight.linear = light.data[1][3];
+    pointLight.quadratic = light.data[2][3];
+    return pointLight;
+}
+
+DirectionalLight ExtractDirectionalLight(Light light)
+{
+    DirectionalLight dirLight;
+    dirLight.intensity = light.intensity;
+    dirLight.color = light.color;
+    dirLight.direction = light.data[1].rgb;
+    dirLight.hasShadow = light.data[2][1] > 0.0;
+    return dirLight;
+}
+
+SpotLight ExtractSpotLight(Light light)
+{
+    SpotLight spotLight;
+    spotLight.intensity = light.intensity;
+    spotLight.color = light.color;
+    spotLight.position = light.data[0].rgb;
+    spotLight.direction = light.data[1].rgb;
+    spotLight.innerCutoff = light.data[3][1];
+    spotLight.outerCutoff = light.data[3][1] + light.data[3][2];
+    spotLight.constant = light.data[0][3];
+    spotLight.linear = light.data[1][3];
+    spotLight.quadratic = light.data[2][3];
+    return spotLight;
+}
+
+AmbientBoxLight ExtractAmbientBoxLight(Light light)
+{
+    AmbientBoxLight boxLight;
+    boxLight.intensity = light.intensity;
+    boxLight.color = light.color;
+    boxLight.position = light.data[0].rgb;
+    boxLight.size = vec3(light.data[0][3], light.data[1][3], light.data[2][3]);
+    return boxLight;
+}
+
+AmbientSphereLight ExtractAmbientSphereLight(Light light)
+{
+    AmbientSphereLight sphereLight;
+    sphereLight.position = light.data[0].rgb;
+    sphereLight.color = light.color;
+    sphereLight.intensity = light.intensity;
+    sphereLight.radius = light.data[0][3];
+    return sphereLight;
+}
+
+struct LightContribution
+{
+    vec3 radiance;
+    vec3 L;
+};
+
+float CalculateAttenuation(vec3 lightPos, vec3 fragPos, float constant, float linear, float quadratic)
+{
+    const float distance = length(lightPos - fragPos);
+    const float attenuation = constant + linear * distance + quadratic * (distance * distance);
+    return 1.0 / attenuation;
+}
+
+LightContribution CalculatePointLightContribution(PointLight light, vec3 fragPos)
+{
+    const vec3 L = normalize(light.position - fragPos);
+    const float attenuation = CalculateAttenuation(light.position, fragPos, light.constant, light.linear, light.quadratic);
+    const vec3 radiance = light.color * light.intensity * attenuation;
+    
+    return LightContribution(radiance, L);
+}
+
+LightContribution CalculateDirectionalLightContribution(DirectionalLight light, vec3 fragPos, vec3 N, sampler2D shadowMap, mat4 lightSpaceMatrix)
+{
+    const vec3 L = -light.direction;
+    
+    float lightCoeff = light.intensity;
+    
+    // Apply shadow if enabled
+    if (light.hasShadow)
+    {
+        vec4 fragPosLightSpace = lightSpaceMatrix * vec4(fragPos, 1.0);
+        float shadow = CalculateShadow(fragPosLightSpace, shadowMap, N, light.direction);
+        lightCoeff *= (1.0 - shadow);
+    }
+    
+    const vec3 radiance = light.color * lightCoeff;
+    
+    return LightContribution(radiance, L);
+}
+
+LightContribution CalculateSpotLightContribution(SpotLight light, vec3 fragPos)
+{
+    const vec3 L = normalize(light.position - fragPos);
+    const float attenuation = CalculateAttenuation(light.position, fragPos, light.constant, light.linear, light.quadratic);
+    
+    // Calculate spot intensity
+    const float cutOff = cos(radians(light.innerCutoff));
+    const float outerCutOff = cos(radians(light.outerCutoff));
+    const vec3 lightDirection = normalize(light.position - fragPos);
+    const float theta = dot(lightDirection, normalize(-light.direction));
+    const float epsilon = cutOff - outerCutOff;
+    const float spotIntensity = clamp((theta - outerCutOff) / epsilon, 0.0, 1.0);
+    
+    const vec3 radiance = light.color * light.intensity * attenuation * spotIntensity;
+    
+    return LightContribution(radiance, L);
+}
+
+vec3 CalculateAmbientBoxLightContribution(AmbientBoxLight light, vec3 fragPos)
+{
+    float inside = IsPointInAABB(fragPos, light.position, light.size);
+    return inside * light.color * light.intensity;
+}
+
+vec3 CalculateAmbientSphereLightContribution(AmbientSphereLight light, vec3 fragPos)
+{
+    float inside = IsPointInSphere(fragPos, light.position, light.radius);
+    return inside * light.color * light.intensity;
+}