Light.angularRadius

Author: gecko0307

data/__internal/shaders/AreaLight/AreaLight.frag.glsl

@@ -98,12 +98,12 @@ subroutine(srtLightRadiance) vec3 lightRadianceAreaSphere(
 
     vec3 positionToLightSource = lightPosition - pos;
     float distanceToLight = length(positionToLightSource);
-    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.001)), 0.0, 1.0), 4.0) * lightEnergy;
+    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.00001)), 0.0, 1.0), 4.0) * lightEnergy;
 
     vec3 Lpt = normalize(positionToLightSource);
 
     vec3 centerToRay = dot(positionToLightSource, R) * R - positionToLightSource;
-    vec3 closestPoint = positionToLightSource + centerToRay * clamp(lightAreaRadius / max(length(centerToRay), 0.001), 0.0, 1.0);
+    vec3 closestPoint = positionToLightSource + centerToRay * clamp(lightAreaRadius / max(length(centerToRay), 0.00001), 0.0, 1.0);
     vec3 L = normalize(closestPoint);  
 
     float NL = max(dot(N, Lpt), 0.0);
@@ -122,15 +122,15 @@ subroutine(srtLightRadiance) vec3 lightRadianceAreaSphere(
     // fss90 used to "flatten" retroreflection based on roughness
     float FL = schlickFresnel(NL);
     float FV = schlickFresnel(NE);
-    float fss90 = LH * LH * max(roughness, 0.001);
+    float fss90 = LH * LH * max(roughness, 0.00001);
     float fss = mix(1.0, fss90, FL) * mix(1.0, fss90, FV);
     float ss = 1.25 * (fss * (1.0 / max(NL + NE, 0.1) - 0.5) + 0.5);
 
     vec3 diffuse = invPI * albedo * mix(kD * NL * occlusion, vec3(ss), subsurface) * (1.0 - metallic);
 
     vec3 numerator = NDF * G * F;
     float denominator = 4.0 * max(dot(N, E), 0.0) * NL;
-    vec3 specular = numerator / max(denominator, 0.001);
+    vec3 specular = numerator / max(denominator, 0.00001);
 
     vec3 lightColorLinear = toLinear(lightColor.rgb);
 
@@ -168,7 +168,7 @@ subroutine(srtLightRadiance) vec3 lightRadianceAreaTube(
 
     vec3 positionToLightSource = (lightPosition + lightPosition2) * 0.5 - pos;
     float distanceToLight = length(positionToLightSource);
-    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.001)), 0.0, 1.0), 4.0) * lightEnergy;
+    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.00001)), 0.0, 1.0), 4.0) * lightEnergy;
 
     vec3 Lpt = normalize(positionToLightSource);
 
@@ -188,15 +188,15 @@ subroutine(srtLightRadiance) vec3 lightRadianceAreaTube(
     // fss90 used to "flatten" retroreflection based on roughness
     float FL = schlickFresnel(NL);
     float FV = schlickFresnel(NE);
-    float fss90 = LH * LH * max(roughness, 0.001);
+    float fss90 = LH * LH * max(roughness, 0.00001);
     float fss = mix(1.0, fss90, FL) * mix(1.0, fss90, FV);
     float ss = 1.25 * (fss * (1.0 / max(NL + NE, 0.1) - 0.5) + 0.5);
 
     vec3 diffuse = invPI * albedo * mix(kD * NL * occlusion, vec3(ss), subsurface) * (1.0 - metallic);
 
     vec3 numerator = NDF * G * F;
     float denominator = 4.0 * max(dot(N, E), 0.0) * NL;
-    vec3 specular = numerator / max(denominator, 0.001);
+    vec3 specular = numerator / max(denominator, 0.00001);
 
     vec3 incomingLight = toLinear(lightColor.rgb) * attenuation;
     vec3 radiance = (diffuse * lightDiffuse + specular * lightSpecular * NL) * incomingLight;
@@ -221,7 +221,7 @@ subroutine(srtLightRadiance) vec3 lightRadianceSpot(
     vec3 positionToLightSource = lightPosition - pos;
     float distanceToLight = length(positionToLightSource);
     vec3 L = normalize(positionToLightSource);
-    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.001)), 0.0, 1.0), 2.0) * lightEnergy;
+    float attenuation = pow(clamp(1.0 - (distanceToLight / max(lightRadius, 0.00001)), 0.0, 1.0), 2.0) * lightEnergy;
 
     float spotCos = clamp(dot(L, normalize(lightSpotDirection)), 0.0, 1.0);
     float spotValue = smoothstep(lightSpotCosCutoff, lightSpotCosInnerCutoff, spotCos);
@@ -243,15 +243,15 @@ subroutine(srtLightRadiance) vec3 lightRadianceSpot(
     // fss90 used to "flatten" retroreflection based on roughness
     float FL = schlickFresnel(NL);
     float FV = schlickFresnel(NE);
-    float fss90 = LH * LH * max(roughness, 0.001);
+    float fss90 = LH * LH * max(roughness, 0.00001);
     float fss = mix(1.0, fss90, FL) * mix(1.0, fss90, FV);
     float ss = 1.25 * (fss * (1.0 / max(NL + NE, 0.1) - 0.5) + 0.5);
 
     vec3 diffuse = invPI * albedo * mix(kD * NL * occlusion, vec3(ss), subsurface) * (1.0 - metallic);
 
     vec3 numerator = NDF * G * F;
     float denominator = 4.0 * max(dot(N, E), 0.0) * NL;
-    vec3 specular = numerator / max(denominator, 0.001);
+    vec3 specular = numerator / max(denominator, 0.00001);
 
     vec3 incomingLight = toLinear(lightColor.rgb) * attenuation;
     vec3 radiance = (diffuse * lightDiffuse + specular * lightSpecular * NL) * incomingLight;
@@ -286,7 +286,7 @@ subroutine(srtShadow) float shadowMapDualParaboloid(in vec3 worldPos)
     vec2 uv = dir.xy / (1.0 + abs(dir.z));
     uv = uv * 0.5 + 0.5;
     float layer = 1.0 - float(dir.z >= 0.0);
-    float z = distanceToLight / max(0.001, lightRadius) - bias;
+    float z = distanceToLight / max(0.00001, lightRadius) - bias;
     float shadow = texture(shadowTextureArray, vec4(uv, layer, z));
     return shadow;
 }

data/__internal/shaders/Forward/Forward.frag.glsl

@@ -245,8 +245,6 @@ subroutine(srtAmbient) vec3 ambientEquirectangularMap(in vec3 wN, in float perce
 {
     ivec2 envMapSize = textureSize(ambientTexture, 0);
     float resolution = float(max(envMapSize.x, envMapSize.y));
-    //float glossyExponent = 2.0 / pow(perceptualRoughness, 4.0) - 2.0;
-    //float lod = log2(resolution * sqrt(3.0)) - 0.5 * log2(glossyExponent + 1.0);
     float lod = log2(resolution) * perceptualRoughness;
     return textureLod(ambientTexture, envMapEquirect(wN), lod).rgb;
 }
@@ -256,8 +254,6 @@ subroutine(srtAmbient) vec3 ambientCubemap(in vec3 wN, in float perceptualRoughn
 {
     ivec2 envMapSize = textureSize(ambientTextureCube, 0);
     float resolution = float(max(envMapSize.x, envMapSize.y));
-    //float glossyExponent = 2.0 / pow(perceptualRoughness, 4.0) - 2.0;
-    //float lod = log2(resolution * sqrt(3.0)) - 0.5 * log2(glossyExponent + 1.0);
     float lod = log2(resolution) * perceptualRoughness;
     return textureLod(ambientTextureCube, wN, lod).rgb;
 }
@@ -387,7 +383,7 @@ void main()
             vec3 F = fresnelRoughness(max(dot(H, E), 0.0), f0, r);
 
             vec3 kD = (1.0 - F) * (1.0 - m);
-            vec3 specular = (NDF * G *  F) / max(4.0 * max(dot(N, E), 0.0) * NL, 0.001);
+            vec3 specular = (NDF * G *  F) / max(4.0 * max(dot(N, E), 0.0) * NL, 0.00001);
 
             vec3 incomingLight = toLinear(sunColor.rgb) * sunEnergy;
             vec3 diffuse = albedo * invPI;
@@ -420,7 +416,7 @@ void main()
                 float invSamples = 1.0 / float(sunScatteringSamples);
                 float offset = hash((texCoord * 467.759 + time) * eyePosition.z);
                 accumScatter = 0.0;
-                for (float i = 0; i < float(sunScatteringSamples); i+=1.0)
+                for (float i = 0; i < float(sunScatteringSamples); i += 1.0)
                 {
                     accumScatter += shadowLookup(shadowTextureArray, 1.0, shadowMatrix2 * vec4(currentPosition, 1.0), vec2(0.0));
                     currentPosition += rayDirection * (stepSize - offset * sunScatteringMaxRandomStepOffset);

data/__internal/shaders/SunLight/SunLight.frag.glsl

@@ -28,6 +28,7 @@ uniform float fogEnd;
 uniform vec3 lightDirection;
 uniform vec4 lightColor;
 uniform float lightEnergy;
+uniform float lightAngularRadius;
 uniform bool lightScattering;
 uniform float lightScatteringG;
 uniform float lightScatteringDensity;
@@ -141,13 +142,16 @@ void main()
     float NE = max(dot(N, E), 0.0);
     vec3 H = normalize(E + L);
     float LH = max(dot(L, H), 0.0);
+    
+    // Simulate sun disk
+    roughness = max(roughness, lightAngularRadius); 
 
     float NDF = distributionGGX(N, H, roughness);
     float G = geometrySmith(N, E, L, roughness);
     vec3 F = fresnelRoughness(max(dot(H, E), 0.0), f0, roughness);
 
     vec3 kD = (1.0 - F);
-    vec3 specular = (NDF * G * F) / max(4.0 * max(dot(N, E), 0.0) * NL, 0.001);
+    vec3 specular = (NDF * G * F) / max(4.0 * max(dot(N, E), 0.0) * NL, 0.00001);
 
     vec3 incomingLight = toLinear(lightColor.rgb) * lightEnergy;
 
@@ -156,7 +160,7 @@ void main()
     // fss90 used to "flatten" retroreflection based on roughness
     float FL = schlickFresnel(NL);
     float FV = schlickFresnel(NE);
-    float fss90 = LH * LH * max(roughness, 0.001);
+    float fss90 = LH * LH * max(roughness, 0.00001);
     float fss = mix(1.0, fss90, FL) * mix(1.0, fss90, FV);
     float ss = 1.25 * (fss * (1.0 / max(NL + NE, 0.1) - 0.5) + 0.5);
 

data/__internal/shaders/include/ggx.glsl

@@ -5,7 +5,7 @@ float distributionGGX(vec3 N, vec3 H, float roughness)
     float NdotH = max(dot(N, H), 0.0);
     float NdotH2 = NdotH * NdotH;
     float num = a2;
-    float denom = max(NdotH2 * (a2 - 1.0) + 1.0, 0.001);
+    float denom = max(NdotH2 * (a2 - 1.0) + 1.0, 0.00001);
     const float Pi = 3.14159265359;
     denom = Pi * denom * denom;
     return num / denom;

src/dagon/graphics/light.d

@@ -94,6 +94,9 @@ class Light: Entity
 
     /// The color of the light.
     Color4f color;
+    
+    /// For sun light, specifies effective angular radius of the sun disk.
+    float angularRadius;
 
     /**
      * Attenuation radius of the light volume.
@@ -176,6 +179,7 @@ class Light: Entity
         shining = true;
         length = 1.0f;
         color = Color4f(1.0f, 1.0f, 1.0f, 1.0f);
+        angularRadius = 0.0f;
         volumeRadius = 1.0f;
         radius = 0.0f;
         energy = 1.0f;

src/dagon/render/deferred/shaders/sunlight.d

@@ -70,6 +70,7 @@ class SunLightShader: Shader
     ShaderParameter!Vector3f lightDirection;
     ShaderParameter!Color4f lightColor;
     ShaderParameter!float lightEnergy;
+    ShaderParameter!float lightAngularRadius;
     ShaderParameter!int lightScattering;
     ShaderParameter!float lightScatteringG;
     ShaderParameter!float lightScatteringDensity;
@@ -136,6 +137,7 @@ class SunLightShader: Shader
         lightDirection = createParameter!Vector3f("lightDirection");
         lightColor = createParameter!Color4f("lightColor");
         lightEnergy = createParameter!float("lightEnergy");
+        lightAngularRadius = createParameter!float("lightAngularRadius");
         lightScattering = createParameter!int("lightScattering");
         lightScatteringG = createParameter!float("lightScatteringG");
         lightScatteringDensity = createParameter!float("lightScatteringDensity");
@@ -207,6 +209,7 @@ class SunLightShader: Shader
             lightDirection = (lightDirHg * state.viewMatrix).xyz;
             lightColor = light.color;
             lightEnergy = light.energy;
+            lightAngularRadius = light.angularRadius;
             lightScattering = light.scatteringEnabled;
             lightScatteringG = 1.0f - light.scattering;
             lightScatteringDensity = light.mediumDensity;
@@ -222,6 +225,7 @@ class SunLightShader: Shader
             lightDirection = (lightDirHg * state.viewMatrix).xyz;
             lightColor = Color4f(1.0f, 1.0f, 1.0f, 1.0f);
             lightEnergy = 1.0f;
+            lightAngularRadius = 0.0f;
             lightScattering = 0;
             lightScatteringG = 0.0f;
             lightScatteringDensity = 0.0f;