@arcgis/core 6.0.0-next.32 → 6.0.0-next.34

package/chunks/GlobalIllumination.glsl.js

@@ -35,6 +35,28 @@ highQualityIdleOcclusionBlendEnd,
 pow(idleOcclusionBlendProgress, highQualityIdleOcclusionBlendExponent)
 );
 }
+vec2 computeAccumulationBlendWeights(
+bool hasReprojectionMismatch,
+float historyOcclusionBlendWeight,
+bool isScaledGlobalIllumination
+) {
+if (hasReprojectionMismatch) {
+return vec2(1.0);
+}
+if (historyOcclusionBlendWeight > weakHistoryOcclusionThreshold) {
+return vec2(weakHistoryOcclusionBlendWeight, stableHistoryColorBlendWeight);
+}
+if (historyOcclusionBlendWeight > strongHistoryOcclusionThreshold) {
+return vec2(historyOcclusionBlendWeight - 0.05, stableHistoryColorBlendWeight);
+}
+return isScaledGlobalIllumination
+? vec2(lowQualityOcclusionBlendWeight, lowQualityColorBlendWeight)
+: vec2(computeIdleOcclusionBlendWeight(accumulatedFrames), computeIdleColorBlendWeight(accumulatedFrames));
+}
+float computeSkyContribution(vec3 rayDirection, vec3 viewMainLightDirection, float skyFacingWeight) {
+float skyModulation = pow(max(dot(rayDirection, viewMainLightDirection), 0.0), 3.0) * 5.5;
+return mix(1.0, skyModulation * (1.0 - factorDaylightDirectional) + factorDaylightDirectional, skyFacingWeight);
+}
 vec3 sampleCosineHemisphere(vec2 u) {
 float phi = 6.28318530718 * u.x;
 float radius = sqrt(u.y);
@@ -49,21 +71,21 @@ vec3 tangent = normalize(cross(up, n));
 vec3 bitangent = cross(n, tangent);
 return mat3(tangent, bitangent, n);
 }
-float blueNoiseDitherValue(vec2 pixel, float frame, vec2 axis, float phase) {
-float scroll = 5.588238 * mod(frame, 512.0);
-vec2 p = pixel + vec2(scroll);
+float blueNoiseDitherValue(vec2 pixel, vec2 axis, float phase) {
 vec2 rotated = vec2(
-axis.x * p.x + axis.y * p.y,
--axis.y * p.x + axis.x * p.y
+axis.x * pixel.x + axis.y * pixel.y,
+-axis.y * pixel.x + axis.x * pixel.y
 );
 return fract(52.9829189 * fract(0.06711056 * rotated.x + 0.00583715 * rotated.y + phase));
 }
 vec4 blueNoiseDither(vec2 pixel, float frame) {
+float scroll = 5.588238 * mod(frame, 512.0);
+vec2 translatedPixel = pixel + vec2(scroll);
 vec4 value = vec4(
-blueNoiseDitherValue(pixel, frame, vec2(0.9659258, 0.25881904), 0.0),
-blueNoiseDitherValue(pixel, frame, vec2(0.70710677, 0.70710677), 0.17),
-blueNoiseDitherValue(pixel, frame, vec2(0.25881904, 0.9659258), 0.37),
-blueNoiseDitherValue(pixel, frame, vec2(1.0, 0.0), 0.61)
+blueNoiseDitherValue(translatedPixel, vec2(0.9659258, 0.25881904), 0.0),
+blueNoiseDitherValue(translatedPixel, vec2(0.70710677, 0.70710677), 0.17),
+blueNoiseDitherValue(translatedPixel, vec2(0.25881904, 0.9659258), 0.37),
+blueNoiseDitherValue(translatedPixel, vec2(1.0, 0.0), 0.61)
 );
 return value * 2.0 - 1.0;
 }`),C.outputs.add(`fragGlobalIllumination`,`vec4`,0),C.outputs.add(`fragWeight`,`vec2`,1),w.main.add(c`
@@ -77,7 +99,8 @@ return value * 2.0 - 1.0;
     }
 
     // Get the normal of current fragment
-    ivec2 iuv = ivec2(uv * vec2(textureSize(normalMap, 0)));
+    ivec2 normalMapSize = textureSize(normalMap, 0);
+    ivec2 iuv = ivec2(uv * vec2(normalMapSize));
 
     vec4 normalTexel = texelFetch(normalMap, iuv, 0);
 
@@ -94,7 +117,7 @@ return value * 2.0 - 1.0;
 
     // Reconstruct view space position of current fragment
     float currentPixelDepth = linearizeDepth(depth);
-    vec3 currentPixelPos = reconstructPosition(uv * vec2(textureSize(normalMap, 0)), currentPixelDepth);
+    vec3 currentPixelPos = reconstructPosition(uv * vec2(normalMapSize), currentPixelDepth);
     vec4 viewPos = vec4(currentPixelPos, 1.0);
 
     // Reproject current view position to last frame
@@ -106,44 +129,34 @@ return value * 2.0 - 1.0;
     vec4 lastFrameGlobalIllumination = texture(lastFrameGlobalIlluminationTexture, reprojectedCoordinate.xy);
     float historyOcclusionBlendWeight = texture(lastFrameGlobalIlluminationWeightTexture, reprojectedCoordinate.xy).r;
 
-    int steps;
-    float occlusionBlendWeight = 1.0;
-    float colorBlendWeight = 1.0;
-    float idleColorBlendWeight = computeIdleColorBlendWeight(accumulatedFrames);
-    float idleOcclusionBlendWeight = computeIdleOcclusionBlendWeight(accumulatedFrames);
     float reprojectionDepthMismatch = abs((lastFrameDepthViewPos + reprojectedViewPos.z) / max(lastFrameDepthViewPos, reprojectedViewPos.z));
     bool hasReprojectionMismatch = reprojectionDepthMismatch > reprojectionMismatchThreshold;
     bool isScaledGlobalIllumination = resolutionScale < 1.0;
 
-    // Heuristic to determine blending weights and number of steps for occlusion and color
-    if (hasReprojectionMismatch) {
-      steps = 6;
-      occlusionBlendWeight = 1.0;
-    } else {
-      steps = 1;
-      if (historyOcclusionBlendWeight > weakHistoryOcclusionThreshold) {
-        occlusionBlendWeight = weakHistoryOcclusionBlendWeight;
-        colorBlendWeight = stableHistoryColorBlendWeight;
-      } else if (historyOcclusionBlendWeight > strongHistoryOcclusionThreshold) {
-        occlusionBlendWeight = historyOcclusionBlendWeight - 0.05;
-        colorBlendWeight = stableHistoryColorBlendWeight;
-      } else {
-        occlusionBlendWeight = isScaledGlobalIllumination ? lowQualityOcclusionBlendWeight : idleOcclusionBlendWeight;
-        colorBlendWeight = isScaledGlobalIllumination ? lowQualityColorBlendWeight : idleColorBlendWeight;
-      }
-    }
+    vec2 blendWeights = computeAccumulationBlendWeights(
+      hasReprojectionMismatch,
+      historyOcclusionBlendWeight,
+      isScaledGlobalIllumination
+    );
+    float occlusionBlendWeight = blendWeights.x;
+    float colorBlendWeight = blendWeights.y;
+    int rayCount = hasReprojectionMismatch ? 6 : 1;
 
     vec4 randomDirectionSample;
     mat3 normalBasis = basisFromNormal(normal);
-    int temporalSampleStride = min(64 / steps, 6);
-    float temporalFrameOffset = mod(temporalSampleFrame, float(64 / steps));
+    int temporalSampleStride = min(64 / rayCount, 6);
+    float temporalFrameOffset = mod(temporalSampleFrame, float(64 / rayCount));
+    vec2 pixel = floor(gl_FragCoord.xy);
+    vec3 viewDirection = normalize(viewPos.xyz);
+    vec3 viewMainLightDirection = (view * vec4(mainLightDirection, 0.0)).xyz;
+    float skyFacingWeight = clamp(3.5 * dot(viewMainLightDirection, normal), 0.0, 1.0);
 
     // For each ray determine if it hits geometry and accumulate occlusion or color
-    float stepSize = 1.0 / float(steps);
+    float inverseRayCount = 1.0 / float(rayCount);
 
-    for (int i = 0; i < steps; ++i) {
+    for (int i = 0; i < rayCount; ++i) {
       float sampleIndex = float(i * temporalSampleStride + int(temporalFrameOffset));
-      randomDirectionSample = blueNoiseDither(floor(gl_FragCoord.xy), sampleIndex);
+      randomDirectionSample = blueNoiseDither(pixel, sampleIndex);
       vec2 hemisphereSample = randomDirectionSample.rg * 0.5 + 0.5;
       float offsetSample = randomDirectionSample.a * 0.5 + 0.5;
       vec3 rayDirection = normalBasis * sampleCosineHemisphere(hemisphereSample);
@@ -152,7 +165,7 @@ return value * 2.0 - 1.0;
       vec3 hit = screenSpaceIntersectionWithLimits(
         rayDirection,
         viewPos.xyz,
-        normalize(viewPos.xyz),
+        viewDirection,
         normal,
         offsetSample,
         rayMarchScreenReach,
@@ -161,7 +174,6 @@ return value * 2.0 - 1.0;
 
       float hitOpacity = 0.0;
       if (hit.z > 0.0) {
-        ivec2 normalMapSize = textureSize(normalMap, 0);
         ivec2 hitIuv = clamp(ivec2(hit.xy * vec2(normalMapSize)), ivec2(0), normalMapSize - ivec2(1));
         float storedHitOpacity = texelFetch(normalMap, hitIuv, 0).a;
 
@@ -175,17 +187,14 @@ return value * 2.0 - 1.0;
           vec3 sourceEmission = rejectReprojectedHitEmission
             ? vec3(0.0)
             : texture(lastFrameEmissionTexture, hitReprojectedCoordinate).xyz * inputScale;
-          fragGlobalIllumination.rgb += emissionBoostFactor * sourceEmission * stepSize;
+          fragGlobalIllumination.rgb += emissionBoostFactor * sourceEmission * inverseRayCount;
           `)}
       }
 
       if (hitOpacity < 1.0) {
         // Occlusion - heuristic modulating sky intensity based on angle to main light
-        vec4 viewMainLightDirection = view * vec4(mainLightDirection, 0.0);
-        float skyModulation = pow(max(dot(rayDirection, viewMainLightDirection.xyz), 0.0), 3.0) * 5.5;
-        float skyFacingWeight = clamp(3.5 * dot(viewMainLightDirection.xyz, normal), 0.0, 1.0);
-        skyModulation = mix(1.0, skyModulation * (1.0 - factorDaylightDirectional) + factorDaylightDirectional, skyFacingWeight);
-        fragGlobalIllumination.a += (1.0 - hitOpacity) * skyModulation * stepSize;
+        float skyModulation = computeSkyContribution(rayDirection, viewMainLightDirection, skyFacingWeight);
+        fragGlobalIllumination.a += (1.0 - hitOpacity) * skyModulation * inverseRayCount;
       }
     }
 

package/chunks/GlobalIlluminationBlur.glsl.js

@@ -6,23 +6,22 @@ import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{Sc
       float centerDepth,
       vec3 centerNormal,
       float depthSharpness,
+      float emissionSpatialWeightMultiplier,
       bool skipOcclusionBlur,
       inout float emissionWeightSum,
       inout vec3 emissionSum,
       inout float occlusionWeightSum,
       inout float occlusionSum,
-      float centerOcclusionBlendWeight
+      float occlusionSpatialKernelScale
     ) {
       vec4 sampleGlobalIllumination = texture(globalIlluminationTexture, sampleUv);
       vec3 sampleNormal = texture(normalMap, sampleUv).rgb;
       float sampleDepth = linearDepthFromTexture(depthMap, sampleUv);
 
       float depthDelta = sampleDepth - centerDepth;
-      bool isScaledGlobalIllumination = resolutionScale < 1.0;
       float normalSimilarityWeight = globalIlluminationNormalSimilarityWeight(sampleNormal, centerNormal);
       float depthNormalCorrection = globalIlluminationDepthNormalCorrection(sampleNormal);
       vec3 emission = sampleGlobalIllumination.rgb;
-      float emissionSpatialWeightMultiplier = isScaledGlobalIllumination ? ${s.float(120)} : 1.0;
 
       float emissionWeight = exp(
         -sampleOffset * sampleOffset * ${s.float(.04081632653061224)} * ${s.float(.1)} * emissionSpatialWeightMultiplier
@@ -36,9 +35,6 @@ import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{Sc
         return;
       }
 
-      float occlusionSpatialKernelScale = centerOcclusionBlendWeight > ${s.float(g)}
-        ? ${s.float(.08)}
-        : ${s.float(1.5)};
       float occlusionWeight = exp(-sampleOffset * sampleOffset * occlusionSpatialKernelScale - depthDelta * depthDelta * depthSharpness);
       occlusionWeight *= normalSimilarityWeight;
       occlusionWeightSum += occlusionWeight;
@@ -49,8 +45,9 @@ import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{Sc
     float emissionWeightSum = 0.0;
 
     vec4 centerGlobalIllumination = texture(globalIlluminationTexture, uv);
-    float centerOcclusionBlendWeight = texture(globalIlluminationWeightTexture, uv).r;
-    float centerColorBlendWeight = texture(globalIlluminationWeightTexture, uv).g;
+    vec2 centerBlendWeights = texture(globalIlluminationWeightTexture, uv).rg;
+    float centerOcclusionBlendWeight = centerBlendWeights.r;
+    float centerColorBlendWeight = centerBlendWeights.g;
     bool isScaledGlobalIllumination = resolutionScale < 1.0;
     bool shouldReuseCenterOcclusion = isScaledGlobalIllumination && centerOcclusionBlendWeight <= ${s.float(g)};
     bool shouldSkipLowQualityBlur = !hasEmission && shouldReuseCenterOcclusion;
@@ -65,6 +62,12 @@ import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{Sc
     float occlusionWeightSum = 0.0;
 
     float depthSharpness = globalIlluminationDepthSharpness(projScale, centerDepth);
+    float emissionSpatialWeightMultiplier = isScaledGlobalIllumination
+      ? ${s.float(120)}
+      : 1.0;
+    float occlusionSpatialKernelScale = centerOcclusionBlendWeight > ${s.float(g)}
+      ? ${s.float(.08)}
+      : ${s.float(1.5)};
     float lowQualityBlurScale = hasEmission
       ? mix(
           1.0,
@@ -81,12 +84,13 @@ import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{Sc
         centerDepth,
         centerNormal,
         depthSharpness,
+        emissionSpatialWeightMultiplier,
         shouldReuseCenterOcclusion,
         emissionWeightSum,
         emissionSum,
         occlusionWeightSum,
         occlusionSum,
-        centerOcclusionBlendWeight
+        occlusionSpatialKernelScale
       );
     }