diff --git a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl
index d48aeb98b6bb74bb118f72a5173aa043aa63f9ae..4813e6c2d99d399f67ddfc9be9f71f62f4c7543b 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl
@@ -58,8 +58,12 @@ vec4 getPositionWithDepth(vec2 pos_screen, float depth);
vec4 getPosition(vec2 pos_screen);
vec4 getNormalEnvIntensityFlags(vec2 screenpos, out vec3 n, out float envIntensity);
bool traceScreenRay(vec3 position, vec3 reflection, out vec4 hitColor, out float hitDepth, float depth, sampler2D textureFrame);
+
float random (vec2 uv);
-void main() {
+
+
+void main()
+{
vec2 tc = vary_fragcoord.xy;
float depth = linearDepth01(getDepth(tc), zNear, zFar);
vec3 n = vec3(0, 0, 1);
@@ -74,7 +78,8 @@ void main() {
vec4 diffuse = texture2D(diffuseRect, tc);
vec3 specCol = spec.rgb;
- if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR)) {
+ if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
+ {
vec3 orm = specCol.rgb;
float perceptualRoughness = orm.g;
float metallic = orm.b;
@@ -86,12 +91,12 @@ void main() {
specCol = mix(f0, baseColor.rgb, metallic);
}
- vec2 uv2 = tc * screen_res;
- float c = (uv2.x + uv2.y) * 0.125;
- float jitter = mod( c, 1.0);
+ vec2 uv2 = tc * screen_res;
+ float c = (uv2.x + uv2.y) * 0.125;
+ float jitter = mod( c, 1.0);
vec3 firstBasis = normalize(cross(vec3(1.f, 1.f, 1.f), rayDirection));
- vec3 secondBasis = normalize(cross(rayDirection, firstBasis));
+ vec3 secondBasis = normalize(cross(rayDirection, firstBasis));
frag_color = texture(diffuseMap, tc);
vec4 collectedColor;
@@ -100,17 +105,22 @@ void main() {
float vignette = clamp((screenpos.x * screenpos.y) * 16,0, 1);
vignette *= clamp((dot(normalize(viewPos), n) * 0.5 + 0.5 - 0.2) * 8, 0, 1);
vignette *= min(linearDepth(getDepth(tc), zNear, zFar) / zFar, 1);
+
int totalSamples = 4;
- for (int i = 0; i < totalSamples; i++) {
- vec2 coeffs = vec2(random(tc + vec2(0, i)) + random(tc + vec2(i, 0)));
- vec3 reflectionDirectionRandomized = rayDirection + firstBasis * coeffs.x + secondBasis * coeffs.y;
+
+ for (int i = 0; i < totalSamples; i++)
+ {
+ vec2 coeffs = vec2(random(tc + vec2(0, i)) + random(tc + vec2(i, 0)));
+ vec3 reflectionDirectionRandomized = rayDirection + firstBasis * coeffs.x + secondBasis * coeffs.y;
bool hit = traceScreenRay(pos, reflectionDirectionRandomized, hitpoint, depth, depth, diffuseMap);
- if (hit) {
+
+ if (hit)
+ {
collectedColor += hitpoint;
collectedColor.rgb *= specCol.rgb;
}
- }
+ }
collectedColor *= vignette;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl
index f8c6e5701af678360f209c39b1ced4edc7884a7c..b6c789ad40c270f52cc0c66d1d53688aee18a51e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl
@@ -37,17 +37,19 @@ float linearDepth(float depth, float near, float far);
float getDepth(vec2 pos_screen);
float linearDepth01(float d, float znear, float zfar);
-float random (vec2 uv) {
- return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453123); //simple random function
+float random (vec2 uv)
+{
+ return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453123); //simple random function
}
// Based off of https://github.com/RoundedGlint585/ScreenSpaceReflection/
// A few tweaks here and there to suit our needs.
-vec2 generateProjectedPosition(vec3 pos){
- vec4 samplePosition = projection_matrix * vec4(pos, 1.f);
- samplePosition.xy = (samplePosition.xy / samplePosition.w) * 0.5 + 0.5;
- return samplePosition.xy;
+vec2 generateProjectedPosition(vec3 pos)
+{
+ vec4 samplePosition = projection_matrix * vec4(pos, 1.f);
+ samplePosition.xy = (samplePosition.xy / samplePosition.w) * 0.5 + 0.5;
+ return samplePosition.xy;
}
bool isBinarySearchEnabled = true;
@@ -60,79 +62,91 @@ float distanceBias = 0.02;
float depthRejectBias = 0.001;
float epsilon = 0.1;
-bool traceScreenRay(vec3 position, vec3 reflection, out vec4 hitColor, out float hitDepth, float depth, sampler2D textureFrame) {
- vec3 step = rayStep * reflection;
- vec3 marchingPosition = position + step;
- float delta;
- float depthFromScreen;
- vec2 screenPosition;
+bool traceScreenRay(vec3 position, vec3 reflection, out vec4 hitColor, out float hitDepth, float depth, sampler2D textureFrame)
+{
+ vec3 step = rayStep * reflection;
+ vec3 marchingPosition = position + step;
+ float delta;
+ float depthFromScreen;
+ vec2 screenPosition;
bool hit = false;
hitColor = vec4(0);
-
- int i = 0;
- if (depth > depthRejectBias) {
- for (; i < iterationCount && !hit; i++) {
- screenPosition = generateProjectedPosition(marchingPosition);
- depthFromScreen = linearDepth(getDepth(screenPosition), zNear, zFar);
- delta = abs(marchingPosition.z) - depthFromScreen;
-
- if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon) {
- break;
- }
+
+ int i = 0;
+ if (depth > depthRejectBias)
+ {
+ for (; i < iterationCount && !hit; i++)
+ {
+ screenPosition = generateProjectedPosition(marchingPosition);
+ depthFromScreen = linearDepth(getDepth(screenPosition), zNear, zFar);
+ delta = abs(marchingPosition.z) - depthFromScreen;
+
+ if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon)
+ {
+ break;
+ }
- if (abs(delta) < distanceBias) {
- vec4 color = vec4(1);
- if(debugDraw)
- color = vec4( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2, 0);
- hitColor = texture(textureFrame, screenPosition) * color;
- hitDepth = depthFromScreen;
- hit = true;
- break;
- }
- if (isBinarySearchEnabled && delta > 0) {
- break;
- }
- if (isAdaptiveStepEnabled){
- float directionSign = sign(abs(marchingPosition.z) - depthFromScreen);
- //this is sort of adapting step, should prevent lining reflection by doing sort of iterative converging
- //some implementation doing it by binary search, but I found this idea more cheaty and way easier to implement
- step = step * (1.0 - rayStep * max(directionSign, 0.0));
- marchingPosition += step * (-directionSign);
- }
- else {
- marchingPosition += step;
- }
+ if (abs(delta) < distanceBias)
+ {
+ vec4 color = vec4(1);
+ if(debugDraw)
+ color = vec4( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2, 0);
+ hitColor = texture(textureFrame, screenPosition) * color;
+ hitDepth = depthFromScreen;
+ hit = true;
+ break;
+ }
+ if (isBinarySearchEnabled && delta > 0)
+ {
+ break;
+ }
+ if (isAdaptiveStepEnabled)
+ {
+ float directionSign = sign(abs(marchingPosition.z) - depthFromScreen);
+ //this is sort of adapting step, should prevent lining reflection by doing sort of iterative converging
+ //some implementation doing it by binary search, but I found this idea more cheaty and way easier to implement
+ step = step * (1.0 - rayStep * max(directionSign, 0.0));
+ marchingPosition += step * (-directionSign);
+ }
+ else
+ {
+ marchingPosition += step;
+ }
- if (isExponentialStepEnabled){
- step *= 1.05;
- }
- }
- if(isBinarySearchEnabled){
- for(; i < iterationCount && !hit; i++){
-
- step *= 0.5;
- marchingPosition = marchingPosition - step * sign(delta);
-
- screenPosition = generateProjectedPosition(marchingPosition);
- depthFromScreen = linearDepth(getDepth(screenPosition), zNear, zFar);
- delta = abs(marchingPosition.z) - depthFromScreen;
+ if (isExponentialStepEnabled)
+ {
+ step *= 1.05;
+ }
+ }
+ if(isBinarySearchEnabled)
+ {
+ for(; i < iterationCount && !hit; i++)
+ {
+ step *= 0.5;
+ marchingPosition = marchingPosition - step * sign(delta);
+
+ screenPosition = generateProjectedPosition(marchingPosition);
+ depthFromScreen = linearDepth(getDepth(screenPosition), zNear, zFar);
+ delta = abs(marchingPosition.z) - depthFromScreen;
- if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon) {
- break;
- }
+ if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon)
+ {
+ break;
+ }
- if (abs(delta) < distanceBias && depthFromScreen != (depth - distanceBias)) {
- vec4 color = vec4(1);
- if(debugDraw)
- color = vec4( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2, 0);
- hitColor = texture(textureFrame, screenPosition) * color;
- hitDepth = depthFromScreen;
- hit = true;
- break;
- }
- }
- }
- }
-
+ if (abs(delta) < distanceBias && depthFromScreen != (depth - distanceBias))
+ {
+ vec4 color = vec4(1);
+ if(debugDraw)
+ color = vec4( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2, 0);
+ hitColor = texture(textureFrame, screenPosition) * color;
+ hitDepth = depthFromScreen;
+ hit = true;
+ break;
+ }
+ }
+ }
+ }
+
return hit;
}