Some cleanup, still trying to solve the problem

libraries/render-utils/src/AmbientOcclusionEffect.cpp

@@ -375,7 +375,7 @@ const gpu::PipelinePointer& AmbientOcclusionEffect::getVBlurPipeline() {
 
 const gpu::PipelinePointer& AmbientOcclusionEffect::getMipCreationPipeline() {
 	if (!_mipCreationPipeline) {
-		_mipCreationPipeline = gpu::Context::createMipGenerationPipeline(gpu::Shader::createPixel(shader::render_utils::fragment::mip_depth_median));
+		_mipCreationPipeline = gpu::Context::createMipGenerationPipeline(gpu::Shader::createPixel(shader::render_utils::fragment::ssao_mip_depth));
 	}
 	return _mipCreationPipeline;
 }

libraries/render-utils/src/DebugDeferredBuffer.cpp

@@ -384,7 +384,7 @@ void DebugDeferredBuffer::configure(const Config& config) {
     auto& parameters = _parameters.edit();
 
     _mode = (Mode)config.mode;
-    _size = config.size;
+    _size = glm::vec4{config.debugCursorTexcoord.x*2.0f - 1.0f, -1.0f, 1.0f, 1.0f};
     parameters._shadowCascadeIndex = glm::clamp(_mode - Mode::ShadowCascade0Mode, 0, (int)SHADOW_CASCADE_MAX_COUNT - 1);
 }
 

libraries/render-utils/src/DebugDeferredBuffer.h

@@ -25,14 +25,14 @@ class DebugDeferredBufferConfig : public render::Job::Config {
     Q_OBJECT
     Q_PROPERTY(bool enabled MEMBER enabled)
     Q_PROPERTY(int mode MEMBER mode WRITE setMode)
-    Q_PROPERTY(glm::vec4 size MEMBER size NOTIFY dirty)
+    Q_PROPERTY(glm::vec2 debugCursorTexcoord MEMBER debugCursorTexcoord NOTIFY dirty)
 public:
     DebugDeferredBufferConfig() : render::Job::Config(false) {}
 
     void setMode(int newMode);
 
     int mode{ 0 };
-    glm::vec4 size{ 0.0f, -1.0f, 1.0f, 1.0f };
+    glm::vec2 debugCursorTexcoord{ 0.5f, 0.5f };
 signals:
     void dirty();
 };

libraries/render-utils/src/ssao.slh

@@ -249,14 +249,12 @@ vec3 fetchTapUnfiltered(ivec4 side, ivec2 ssC, vec3 tap, vec2 sideImageSize) {
    return P;
 }
 
-vec4 fetchTap(ivec4 side, ivec2 ssC, vec3 tap, vec2 sideImageSize) {
-    int mipLevel = evalMipFromRadius(tap.z * float(doFetchMips()));
-
-    vec2 ssP = tap.xy + vec2(ssC);
+vec4 fetchTap(ivec4 side, vec2 tapPixelPos, float tapRadius, vec2 sideImageSize) {
+    int mipLevel = evalMipFromRadius(tapRadius * float(doFetchMips()));
 
     // We need to divide by 2^mipLevel to read the appropriately scaled coordinate from a MIP-map.
     // Manually clamp to the texture size because texelFetch bypasses the texture unit
-    vec2 tapUV = (vec2(ssP) + vec2(0.5)) / sideImageSize;
+    vec2 tapUV = (tapPixelPos + vec2(0.5)) / sideImageSize;
     vec2 fetchUV = vec2(tapUV.x + side.w * 0.5 * (side.x - tapUV.x), tapUV.y);
 
     vec4 P;
@@ -293,44 +291,21 @@ float evalVisibilitySSAO(in vec3 centerPosition, in vec3 centerNormal, in vec3 t
 float computeHorizonFromTap(vec3 tapPositionES, vec3 fragPositionES, vec3 fragNormalES) {
     vec3 deltaVec = tapPositionES - fragPositionES;
     float distanceSquared = dot(deltaVec, deltaVec);
-    float horizon = dot(normalize(deltaVec), fragNormalES);
+    float cosHorizonAngle = dot(normalize(deltaVec), fragNormalES);
     float radiusFalloff = max(0.0, 1.0 - (distanceSquared / getRadius2()));
 
-    horizon = max(0.0, (horizon - getFalloffAngle()) / (1.0 - getFalloffAngle()));
-    horizon *= radiusFalloff;
+    cosHorizonAngle = max(0.0, (cosHorizonAngle - getFalloffAngle()) / (1.0 - getFalloffAngle()));
+    cosHorizonAngle *= radiusFalloff;
 
-    return horizon;
-}
-
-vec2 clampSearchVector(vec2 sideImageSize, vec2 shadedPixelPos, vec2 searchVec) {
-    vec2 clampedSearchVec = searchVec;
-    vec2 endPixel = shadedPixelPos + clampedSearchVec;
-
-    if (endPixel.x < 0) {
-        clampedSearchVec *= ((0-shadedPixelPos.x) / clampedSearchVec.x);
-        endPixel = shadedPixelPos + clampedSearchVec;
-    }
-    if (endPixel.x > (sideImageSize.x-1)) {
-        clampedSearchVec *= ((sideImageSize.x-1-shadedPixelPos.x) / clampedSearchVec.x);
-        endPixel = shadedPixelPos + clampedSearchVec;
-    }
-    if (endPixel.y < 0) {
-        clampedSearchVec *= ((0-shadedPixelPos.y) / clampedSearchVec.y);
-        endPixel = shadedPixelPos + clampedSearchVec;
-    }
-    if (endPixel.y > (sideImageSize.y-1)) {
-        clampedSearchVec *= ((sideImageSize.y-1-shadedPixelPos.y) / clampedSearchVec.y);
-    }
-
-    return clampedSearchVec;
+    return cosHorizonAngle;
 }
 
 <@func computeHorizon()@>
-        if (tapPixelPos.x>=0 && tapPixelPos.y>=0 && tapPixelPos.x<sideImageSize.x && tapPixelPos.y<sideImageSize.y) {
+        vec2 tapPixelPos = tapPixelOffset + shadedPixelPos;
+        if (tapPixelPos.x<0 && tapPixelPos.y<0 && tapPixelPos.x>=sideImageSize.x && tapPixelPos.y>=sideImageSize.y) {
             break;
         }
-        vec3 tap = vec3(tapPixelPos, radius);
-        vec4 tapUVZ_mip = fetchTap(side, shadedPixelPos, tap, sideImageSize);
+        vec4 tapUVZ_mip = fetchTap(side, tapPixelPos, radius, sideImageSize);
         vec3 tapPositionES = evalEyePositionFromZeye(side.x, tapUVZ_mip.z, tapUVZ_mip.xy);
         float tapCosHorizonAngle = computeHorizonFromTap(tapPositionES, fragPositionES, fragNormalES);
 
@@ -338,26 +313,25 @@ vec2 clampSearchVector(vec2 sideImageSize, vec2 shadedPixelPos, vec2 searchVec)
         
 <@endfunc@>
 
-#define SSAO_LINEAR_SAMPLING 1
+#define SSAO_LINEAR_SEARCH_HORIZON 1
 
-float computeHorizon(ivec4 side, ivec2 shadedPixelPos, vec2 sideImageSize, vec2 deltaTap, 
-                    vec3 fragPositionES, vec3 fragNormalES, vec2 searchVec) {
+float computeHorizon(ivec4 side, vec2 shadedPixelPos, vec2 sideImageSize, vec2 deltaTap, 
+                    vec3 fragPositionES, vec3 fragNormalES, vec2 searchVec, float searchRadius) {
     vec2 absSearchVec = abs(searchVec);
-    int stepCount = int(max(absSearchVec.x, absSearchVec.y));
+    int stepCount = int(ceil(max(absSearchVec.x, absSearchVec.y)));
     float cosHorizonAngle = 0.0;
 
     if (stepCount>0) {
         vec2 deltaPixelTap = searchVec / float(stepCount);
-        float searchRadius = length(searchVec);
         float deltaRadius = searchRadius / float(stepCount);
-        vec2 tapPixelPos = vec2(0);
+        vec2 tapPixelOffset = vec2(0);
 
-#if SSAO_LINEAR_SAMPLING
+#if SSAO_LINEAR_SEARCH_HORIZON
         float radius = 0.0;
         int stepIndex;
 
         for (stepIndex=0 ; stepIndex<stepCount ; stepIndex++) {
-            tapPixelPos += deltaPixelTap;
+            tapPixelOffset += deltaPixelTap;
             radius += deltaRadius;
 
             <$computeHorizon()$>
@@ -366,8 +340,8 @@ float computeHorizon(ivec4 side, ivec2 shadedPixelPos, vec2 sideImageSize, vec2
         float radius = deltaRadius;
         float mipLevel = evalMipFromRadius(radius * float(doFetchMips()));
 
-        while (radius<searchRadius) {
-            tapPixelPos += deltaPixelTap;
+        while (radius<=searchRadius) {
+            tapPixelOffset += deltaPixelTap;
 
             <$computeHorizon()$>
 
@@ -384,16 +358,16 @@ float computeHorizon(ivec4 side, ivec2 shadedPixelPos, vec2 sideImageSize, vec2
     return cosHorizonAngle;
 }
 
-float evalVisibilityHBAO(ivec4 side, ivec2 shadedPixelPos, vec2 sideImageSize, vec2 deltaTap, float diskPixelRadius, 
+float evalVisibilityHBAO(ivec4 side, vec2 shadedPixelPos, vec2 sideImageSize, vec2 deltaTap, float diskPixelRadius, 
                          vec3 fragPositionES, vec3 fragNormalES) {
 	vec2 searchVec = deltaTap * diskPixelRadius;
 	float obscurance;
 
     // Forward search for h1
-    obscurance = computeHorizon(side, shadedPixelPos, sideImageSize, deltaTap, fragPositionES, fragNormalES, searchVec);
+    obscurance = computeHorizon(side, shadedPixelPos, sideImageSize, deltaTap, fragPositionES, fragNormalES, searchVec, diskPixelRadius);
 
     // Backward search for h2
-    obscurance += computeHorizon(side, shadedPixelPos, sideImageSize, deltaTap, fragPositionES, fragNormalES, -searchVec);
+    obscurance += computeHorizon(side, shadedPixelPos, sideImageSize, deltaTap, fragPositionES, fragNormalES, -searchVec, diskPixelRadius);
 
 	return obscurance * 0.5 / PI;
 }

libraries/render-utils/src/ssao_makeOcclusion.slf

@@ -60,10 +60,13 @@ void main(void) {
     for (int i = 0; i < numSamples; ++i) {
 #if SSAO_USE_HORIZON_BASED
 		vec3 deltaTap = getUnitTapLocation(i, 1.0, randomPatternRotationAngle, PI);
-        obscuranceSum += evalVisibilityHBAO(side, shadedPixelPos, sideImageSize, deltaTap.xy, diskPixelRadius, fragPositionES, fragNormalES);
+        // TEMPO OP
+        deltaTap.xy = vec2(1,0);
+        obscuranceSum += evalVisibilityHBAO(side, vec2(shadedPixelPos), sideImageSize, deltaTap.xy, diskPixelRadius, fragPositionES, fragNormalES);
 #else
         vec3 tap = getTapLocationClampedSSAO(i, randomPatternRotationAngle, diskPixelRadius, shadedPixelPos, sideImageSize);
-        vec3 tapUVZ = fetchTap(side, shadedPixelPos, tap, sideImageSize);
+        vec2 tapPixelPos = vec2(shadedPixelPos) + tap.xy;
+        vec3 tapUVZ = fetchTap(side, tapPixelPos, tap.z, sideImageSize);
         vec3 tapPositionES = evalEyePositionFromZeye(side.x, tapUVZ.z, tapUVZ.xy);
         obscuranceSum += float(tap.z > 0.0) * evalVisibilitySSAO(fragPositionES, fragNormalES, tapPositionES);
 #endif

libraries/render-utils/src/ssao_mip_depth.slf

@@ -2,7 +2,7 @@
 <$VERSION_HEADER$>
 //  Generated on <$_SCRIBE_DATE$>
 //
-//  mip_depth_median.frag
+//  ssao_mip_depth.frag
 //  fragment shader
 //
 //  Created by Olivier Prat on 4/18/18.
@@ -22,7 +22,7 @@ void main(void) {
 	vec4 depths = textureGather(depthTexture, varTexCoord0);
 
 	// Order the depths from minimum to maximum
-	depths.xy = depths.x > depths.y ? depths.yx : depths.xy;
+/*	depths.xy = depths.x > depths.y ? depths.yx : depths.xy;
 	depths.xz = depths.x > depths.z ? depths.zx : depths.xz;
 	depths.xw = depths.x > depths.w ? depths.wx : depths.xw;
 
@@ -31,6 +31,11 @@ void main(void) {
 
 	depths.zw = depths.z > depths.w ? depths.wz : depths.zw;
 
-	float median = (depths.y + depths.z) / 2.0;
-    outFragColor = vec4(vec3(median), 1.0);
+	float outZ = (depths.y + depths.z) / 2.0;*/
+
+	float outZ = min(depths.x, depths.y);
+	outZ = min(outZ, depths.z);
+	outZ = min(outZ, depths.w);
+
+    outFragColor = vec4(vec3(outZ), 1.0);
 }

scripts/developer/utilities/render/luci.js

@@ -78,13 +78,11 @@
     Controller.mouseReleaseEvent.connect(function() { moveDebugCursor = false; });
     Controller.mouseMoveEvent.connect(function (e) { if (moveDebugCursor) setDebugCursor(e.x, e.y); });
 
-
-
     function setDebugCursor(x, y) {
-        nx = (x / Window.innerWidth);
-        ny = 1.0 - ((y) / (Window.innerHeight - 32));
+        nx = ((x + 0.5) / Window.innerWidth);
+        ny = 1.0 - ((y + 0.5) / (Window.innerHeight));
 
-         Render.getConfig("RenderMainView").getConfig("Antialiasing").debugCursorTexcoord = { x: nx, y: ny };
+        Render.getConfig("RenderMainView").getConfig("DebugDeferredBuffer").debugCursorTexcoord = { x: nx, y: ny };
     }