@arcgis/core 5.1.0-next.79 → 5.1.0-next.80

package/chunks/GlobalIllumination.glsl.js

@@ -1,187 +1,214 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepthLastFrame as t}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepthLastFrame.glsl.js";import{addMainLightDirection as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{ScreenSpaceReflections as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceReflections.glsl.js";import{CameraSpace as a}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{FloatPassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as r,If as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ColorAttachment1 as u}from"../views/webgl/enums.js";import{NoParameters as d}from"../views/webgl/NoParameters.js";import{ShaderBuilder as p}from"../views/webgl/ShaderBuilder.js";const h=.01,f=.008,g=.002,v=.5,x=.02,b=.1,w=.008,D=.012,S=.008,y=40,F=.095,j=.008,z=60,I=2,B=.0039,G=.25;class M extends d{constructor(){super(...arguments),this.projScale=1,this.scaleGlobalIllumination=1,this.accumulatedFrames=0,this.frameCount=0}}function W(d){const M=new p,W=M.fragment;return M.include(e),M.include(a),i(W),W.include(t),M.include(o,{highStepCount:!1,screenSpaceReflections:!0}),W.uniforms.add(new m("normalMap",e=>e.normalTexture),new m("depthMap",e=>e.depthTexture),new m("lastFrameDepthTexture",(e,t)=>t.reprojection.lastFrameDepth?.attachment),new c("lastFrameGlobalIlluminationTexture",e=>e.globalIllumination?.getTexture()),new c("lastFrameGlobalIlluminationWeightTexture",e=>e.globalIllumination?.getTexture(u)),new s("reprojectionViewMatrix",e=>e.reprojection.viewMatrix),new s("view",e=>e.camera.viewMatrix),new l("accumulatedFramesGI",e=>e.accumulatedFrames),new l("frameCount",e=>e.frameCount),new l("scaleGlobalIllumination",e=>e.scaleGlobalIllumination),new m("blueNoiseTex",e=>e.noiseTexture)),d.hasEmission&&W.uniforms.add(new m("lastFrameEmissionTexture",(e,t)=>t.reprojection.lastFrameEmission?.attachment)),W.constants.add("timeSamplesSize","float",64),W.constants.add("blueNoiseGridSize","float",8),W.code.add(r`
-		float computeIdleEmissionBlendWeight(float accumulatedFrames) {
-			float idleEmissionBlendProgress = clamp(
-				accumulatedFrames / ${r.float(y)},
-				0.0,
-				1.0
-			);
-			return mix(
-				${r.float(D)},
-				${r.float(S)},
-				idleEmissionBlendProgress
-			);
-		}
-
-		float computeIdleOcclusionBlendWeight(float accumulatedFrames) {
-			float idleOcclusionBlendProgress = clamp(
-				accumulatedFrames / ${r.float(z)},
-				0.0,
-				1.0
-			);
-			return mix(
-				${r.float(F)},
-				${r.float(j)},
-				pow(idleOcclusionBlendProgress, ${r.float(I)})
-			);
-		}
-
-		// Blue noise value based on a texture lookup
-		vec4 randomDirection(float index) {
-			vec2 textureOffset = vec2(mod(index, blueNoiseGridSize), floor(index / blueNoiseGridSize)) * timeSamplesSize;
-			vec2 noiseCoord = textureOffset + mod(
-				floor(uv * vec2(textureSize(normalMap, 0)) * scaleGlobalIllumination),
-				vec2(timeSamplesSize)
-			);
-			vec4 blueNoiseValue = texelFetch(blueNoiseTex, ivec2(noiseCoord), 0);
-
-			return 2.0 * blueNoiseValue - 1.0;
-		}
-
-		bool isEdgeDepth(float centerDepth, vec2 sampleUv) {
-			vec2 texelSize = 1.0 / vec2(textureSize(depthMap, 0));
-			float depthLeft = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(-texelSize.x, 0.0)));
-			float depthRight = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(texelSize.x, 0.0)));
-			float depthUp = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, texelSize.y)));
-			float depthDown = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, -texelSize.y)));
-
-			float maxDifference = max(max(abs(centerDepth - depthLeft), abs(centerDepth - depthRight)), max(abs(centerDepth - depthUp), abs(centerDepth - depthDown)));
-
-			return abs(maxDifference / centerDepth) > 0.01;
-		}
-
-		vec3 sampleCosineHemisphere(vec2 u) {
-			float phi = 6.28318530718 * u.x;
-			float radius = sqrt(u.y);
-			float x = radius * cos(phi);
-			float y = radius * sin(phi);
-			float z = sqrt(max(0.0, 1.0 - u.y));
-
-			return vec3(x, y, z);
-		}
-
-		mat3 basisFromNormal(vec3 n) {
-			vec3 up = abs(n.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-			vec3 tangent = normalize(cross(up, n));
-			vec3 bitangent = cross(n, tangent);
-
-			return mat3(tangent, bitangent, n);
-		}
-	`),M.outputs.add("fragGlobalIllumination","vec4",0),M.outputs.add("fragWeight","float",1),W.main.add(r`
-		float depth = depthFromTexture(depthMap, uv);
-
-		// Early out if depth is out of range, such as in the sky
-		if (depth >= 1.0 || depth <= 0.0) {
-			fragGlobalIllumination = vec4(0.0, 0.0, 0.0, 1.0);
-			fragWeight = 0.0;
-			return;
-		}
-
-		// Get the normal of current fragment
-		ivec2 iuv = ivec2(uv * vec2(textureSize(normalMap, 0)));
-		vec4 normal4 = texelFetch(normalMap, iuv, 0);
-		if (normal4.a != 1.0) {
-			fragGlobalIllumination = vec4(0.0, 0.0, 0.0, 1.0);
-			fragWeight = 0.0;
-			return;
-		}
-		vec3 normal = normalize(normal4.xyz * 2.0 - 1.0);
-
-		// Reconstruct view space position of current fragment
-		float currentPixelDepth = linearizeDepth(depth);
-		vec3 currentPixelPos = reconstructPosition(uv * vec2(textureSize(normalMap, 0)), currentPixelDepth);
-		vec4 viewPos = vec4(currentPixelPos, 1.0);
-
-		// Reproject current view position to last frame
-		vec4 reprojectedViewPos = reprojectionViewMatrix * viewPos;
-		vec4 reprojectedCoordinate = applyProjectionMat(proj, reprojectedViewPos.xyz);
-
-		// Read last frame reprojected depth and GI value.
-		float lastFrameDepthViewPos = -linearDepthFromTextureLastFrame(lastFrameDepthTexture, reprojectedCoordinate.xy);
-		vec4 lastFrameGlobalIllumination = texture(lastFrameGlobalIlluminationTexture, reprojectedCoordinate.xy);
-		float historyOcclusionBlendWeight = texture(lastFrameGlobalIlluminationWeightTexture, reprojectedCoordinate.xy).r;
-
-		int steps;
-		float occlusionBlendWeight = 1.0;
-		float emissionBlendWeight = 1.0;
-		float idleEmissionBlendWeight = computeIdleEmissionBlendWeight(accumulatedFramesGI);
-		float idleOcclusionBlendWeight = computeIdleOcclusionBlendWeight(accumulatedFramesGI);
-		float reprojectionDepthMismatch = abs((lastFrameDepthViewPos + reprojectedViewPos.z) / max(lastFrameDepthViewPos, reprojectedViewPos.z));
-		bool hasReprojectionMismatch = reprojectionDepthMismatch > ${r.float(h)};
-		bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
-		bool isLowQualityEdgePixel = isScaledGlobalIllumination && isEdgeDepth(currentPixelDepth, uv);
-		bool resetEmissionHistory = false;
-
-		// Heuristic to determine blending weights and number of steps for occlusion and emission
-		if (hasReprojectionMismatch) {
-			if (isLowQualityEdgePixel) {
-				steps = 1;
-				occlusionBlendWeight = ${r.float(f)};
-				resetEmissionHistory = true;
-			} else {
-				steps = 6;
-				occlusionBlendWeight = 1.0;
-				resetEmissionHistory = true;
-			}
-		} else {
-			steps = 1;
-			if (historyOcclusionBlendWeight > ${r.float(v)}) {
-				occlusionBlendWeight = ${r.float(b)};
-				emissionBlendWeight = ${r.float(w)};
-			} else if (historyOcclusionBlendWeight > ${r.float(x)}) {
-				occlusionBlendWeight = historyOcclusionBlendWeight - 0.05;
-				emissionBlendWeight = ${r.float(w)};
-			} else {
-				occlusionBlendWeight = isScaledGlobalIllumination ? ${r.float(f)} : idleOcclusionBlendWeight;
-				emissionBlendWeight = isScaledGlobalIllumination ? ${r.float(g)} : idleEmissionBlendWeight;
-			}
-		}
-
-		vec4 randomDirectionSample;
-		mat3 normalBasis = basisFromNormal(normal);
-		int temporalSampleStride = min(64 / steps, 6);
-		float temporalFrameOffset = mod(frameCount, float(64 / steps));
-
-		// For each ray determine if it hits geometry and calculate occlusion and emission values
-		float stepSize = 1.0 / float(steps);
-		for (int i = 0; i < steps; ++i) {
-			float sampleIndex = float(i * temporalSampleStride + int(temporalFrameOffset));
-			randomDirectionSample = randomDirection(sampleIndex);
-			vec2 hemisphereSample = randomDirectionSample.rg * 0.5 + 0.5;
-			vec3 rayDirection = normalBasis * sampleCosineHemisphere(hemisphereSample);
-			vec3 hit = screenSpaceIntersection(rayDirection, viewPos.xyz, normalize(viewPos.xyz), normal, randomDirectionSample.a * 0.5 + 0.5, true);
-
-			if (hit.z > 0.0) {
-				// Emission - reproject to get and accumulate emission from last frame
-				vec2 hitReprojectedCoordinate = reprojectionCoordinate(hit);
-				vec3 emissionColor = ${n(d.hasEmission,"texture(lastFrameEmissionTexture, hitReprojectedCoordinate).xyz","vec3(0.0)")};
-
-				fragGlobalIllumination.rgb += emissionColor * stepSize;
-			} else {
-				// 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 * 0.2 + 0.8, skyFacingWeight);
-				fragGlobalIllumination.a += skyModulation * stepSize;
-			}
-		}
-
-		// Rendering trick add noise to reduce accumulation artifacts
-		float accumulationDither = occlusionBlendWeight < 1.0
-			? randomDirectionSample.b * ${r.float(B)}
-			: 0.0;
-
-		// Accumulate occlusion
-		// Accumulate emission
-		vec3 lastFrameEmission = lastFrameGlobalIllumination.rgb;
-		float emissionDitherScale = isScaledGlobalIllumination ? ${r.float(G)} : 1.0;
-		fragGlobalIllumination.rgb = resetEmissionHistory
-			? vec3(0.0)
-			: mix(lastFrameEmission + accumulationDither * emissionDitherScale, fragGlobalIllumination.rgb, emissionBlendWeight);
-
-		// Accumulate occlusion
-		fragGlobalIllumination.a = mix(lastFrameGlobalIllumination.a + accumulationDither, fragGlobalIllumination.a, occlusionBlendWeight);
-
-		fragWeight = occlusionBlendWeight;
-	`),M}const P=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationPassParameters:M,build:W},Symbol.toStringTag,{value:"Module"}));export{M as G,P as a,W as b};
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepthLastFrame as o}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepthLastFrame.glsl.js";import{addMainLightDirection as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{ScreenSpaceReflections as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceReflections.glsl.js";import{CameraSpace as a}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{FloatPassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as i,If as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ColorAttachment1 as u}from"../views/webgl/enums.js";import{NoParameters as d}from"../views/webgl/NoParameters.js";import{ShaderBuilder as p}from"../views/webgl/ShaderBuilder.js";const h=.01,f=.008,g=.002,v=.5,x=.02,b=.1,w=.008,y=.012,C=.008,F=40,S=.095,D=.008,W=60,j=2,z=.0039,I=.25,B=1/3,G=2/3,M=2,P=.05,T=.15,$=.75;class O extends d{constructor(){super(...arguments),this.projScale=1,this.scaleGlobalIllumination=1,this.accumulatedFrames=0,this.frameCount=0}}function L(d){const O=new p,L=O.fragment;return O.include(e),O.include(a),t(L),L.include(o),O.include(r,{highStepCount:!1,screenSpaceReflections:!0}),L.uniforms.add(new m("normalMap",e=>e.normalTexture),new m("depthMap",e=>e.depthTexture),new m("lastFrameColorTexture",(e,o)=>o.reprojection.lastFrameColor?.getTexture()),new m("lastFrameDepthTexture",(e,o)=>o.reprojection.lastFrameDepth?.attachment),new c("lastFrameGlobalIlluminationTexture",e=>e.globalIllumination?.getTexture()),new c("lastFrameGlobalIlluminationWeightTexture",e=>e.globalIllumination?.getTexture(u)),new s("reprojectionViewMatrix",e=>e.reprojection.viewMatrix),new s("view",e=>e.camera.viewMatrix),new l("accumulatedFramesGI",e=>e.accumulatedFrames),new l("frameCount",e=>e.frameCount),new l("scaleGlobalIllumination",e=>e.scaleGlobalIllumination),new m("blueNoiseTex",e=>e.noiseTexture)),d.hasEmission&&L.uniforms.add(new m("lastFrameEmissionTexture",(e,o)=>o.reprojection.lastFrameEmission?.attachment)),L.constants.add("timeSamplesSize","float",64),L.constants.add("blueNoiseGridSize","float",8),L.code.add(i`
+    float computeIdleColorBlendWeight(float accumulatedFrames) {
+      float idleColorBlendProgress = clamp(
+        accumulatedFrames / ${i.float(F)},
+        0.0,
+        1.0
+      );
+      return mix(
+        ${i.float(y)},
+        ${i.float(C)},
+        idleColorBlendProgress
+      );
+    }
+
+    float computeIdleOcclusionBlendWeight(float accumulatedFrames) {
+      float idleOcclusionBlendProgress = clamp(
+        accumulatedFrames / ${i.float(W)},
+        0.0,
+        1.0
+      );
+      return mix(
+        ${i.float(S)},
+        ${i.float(D)},
+        pow(idleOcclusionBlendProgress, ${i.float(j)})
+      );
+    }
+
+    // Blue noise value based on a texture lookup
+    vec4 randomDirection(float index) {
+      vec2 textureOffset = vec2(mod(index, blueNoiseGridSize), floor(index / blueNoiseGridSize)) * timeSamplesSize;
+      vec2 noiseCoord = textureOffset + mod(
+        floor(uv * vec2(textureSize(normalMap, 0)) * scaleGlobalIllumination),
+        vec2(timeSamplesSize)
+      );
+      vec4 blueNoiseValue = texelFetch(blueNoiseTex, ivec2(noiseCoord), 0);
+
+      return 2.0 * blueNoiseValue - 1.0;
+    }
+
+    bool isEdgeDepth(float centerDepth, vec2 sampleUv) {
+      vec2 texelSize = 1.0 / vec2(textureSize(depthMap, 0));
+      float depthLeft = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(-texelSize.x, 0.0)));
+      float depthRight = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(texelSize.x, 0.0)));
+      float depthUp = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, texelSize.y)));
+      float depthDown = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, -texelSize.y)));
+
+      float maxDifference = max(max(abs(centerDepth - depthLeft), abs(centerDepth - depthRight)), max(abs(centerDepth - depthUp), abs(centerDepth - depthDown)));
+
+      return abs(maxDifference / centerDepth) > 0.01;
+    }
+
+    vec3 sampleCosineHemisphere(vec2 u) {
+      float phi = 6.28318530718 * u.x;
+      float radius = sqrt(u.y);
+      float x = radius * cos(phi);
+      float y = radius * sin(phi);
+      float z = sqrt(max(0.0, 1.0 - u.y));
+
+      return vec3(x, y, z);
+    }
+
+    mat3 basisFromNormal(vec3 n) {
+      vec3 up = abs(n.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+      vec3 tangent = normalize(cross(up, n));
+      vec3 bitangent = cross(n, tangent);
+
+      return mat3(tangent, bitangent, n);
+    }
+
+    float computeChromaWeight(vec3 color) {
+      float gray = dot(color, vec3(${i.float(B)}));
+      vec3 deviationFromGray = color - gray;
+      float chromaDistanceSquared = dot(deviationFromGray, deviationFromGray);
+      float normalizedChroma = chromaDistanceSquared / ${i.float(G)};
+
+      return clamp(normalizedChroma * ${i.float(M)}, 0.0, 1.0);
+    }
+
+    float computeColorBleedWeight(vec3 receiverColor, vec3 sourceColor) {
+      float receiverChromaWeight = computeChromaWeight(receiverColor);
+      float sourceChromaWeight = computeChromaWeight(sourceColor);
+      float receiverAverageIntensity = dot(receiverColor, vec3(${i.float(B)}));
+
+      // Favor bright, neutral receivers lit by more saturated hit surfaces
+      float bleedFactor =
+        pow(receiverAverageIntensity, ${i.float(P)}) *
+        (1.0 - receiverChromaWeight) *
+        pow(sourceChromaWeight, ${i.float(T)});
+
+      return ${i.float($)} * clamp(bleedFactor, 0.0, 1.0);
+    }
+  `),O.outputs.add("fragGlobalIllumination","vec4",0),O.outputs.add("fragWeight","float",1),L.main.add(i`
+    float depth = depthFromTexture(depthMap, uv);
+
+    // Early out if depth is out of range, such as in the sky
+    if (depth >= 1.0 || depth <= 0.0) {
+      fragGlobalIllumination = vec4(0.0, 0.0, 0.0, 1.0);
+      fragWeight = 0.0;
+      return;
+    }
+
+    // Get the normal of current fragment
+    ivec2 iuv = ivec2(uv * vec2(textureSize(normalMap, 0)));
+    vec4 normal4 = texelFetch(normalMap, iuv, 0);
+    if (normal4.a != 1.0) {
+      fragGlobalIllumination = vec4(0.0, 0.0, 0.0, 1.0);
+      fragWeight = 0.0;
+      return;
+    }
+    vec3 normal = normalize(normal4.xyz * 2.0 - 1.0);
+
+    // Reconstruct view space position of current fragment
+    float currentPixelDepth = linearizeDepth(depth);
+    vec3 currentPixelPos = reconstructPosition(uv * vec2(textureSize(normalMap, 0)), currentPixelDepth);
+    vec4 viewPos = vec4(currentPixelPos, 1.0);
+
+    // Reproject current view position to last frame
+    vec4 reprojectedViewPos = reprojectionViewMatrix * viewPos;
+    vec4 reprojectedCoordinate = applyProjectionMat(proj, reprojectedViewPos.xyz);
+
+    // Read last frame reprojected depth and GI history
+    float lastFrameDepthViewPos = -linearDepthFromTextureLastFrame(lastFrameDepthTexture, reprojectedCoordinate.xy);
+    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(accumulatedFramesGI);
+    float idleOcclusionBlendWeight = computeIdleOcclusionBlendWeight(accumulatedFramesGI);
+    float reprojectionDepthMismatch = abs((lastFrameDepthViewPos + reprojectedViewPos.z) / max(lastFrameDepthViewPos, reprojectedViewPos.z));
+    bool hasReprojectionMismatch = reprojectionDepthMismatch > ${i.float(h)};
+    bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
+    bool isLowQualityEdgePixel = isScaledGlobalIllumination && isEdgeDepth(currentPixelDepth, uv);
+    bool resetColorHistory = false;
+
+    // Heuristic to determine blending weights and number of steps for occlusion and color
+    if (hasReprojectionMismatch) {
+      if (isLowQualityEdgePixel) {
+        steps = 1;
+        occlusionBlendWeight = ${i.float(f)};
+        resetColorHistory = true;
+      } else {
+        steps = 6;
+        occlusionBlendWeight = 1.0;
+        resetColorHistory = true;
+      }
+    } else {
+      steps = 1;
+      if (historyOcclusionBlendWeight > ${i.float(v)}) {
+        occlusionBlendWeight = ${i.float(b)};
+        colorBlendWeight = ${i.float(w)};
+      } else if (historyOcclusionBlendWeight > ${i.float(x)}) {
+        occlusionBlendWeight = historyOcclusionBlendWeight - 0.05;
+        colorBlendWeight = ${i.float(w)};
+      } else {
+        occlusionBlendWeight = isScaledGlobalIllumination ? ${i.float(f)} : idleOcclusionBlendWeight;
+        colorBlendWeight = isScaledGlobalIllumination ? ${i.float(g)} : idleColorBlendWeight;
+      }
+    }
+
+    vec4 randomDirectionSample;
+    mat3 normalBasis = basisFromNormal(normal);
+    int temporalSampleStride = min(64 / steps, 6);
+    float temporalFrameOffset = mod(frameCount, float(64 / steps));
+
+    // For each ray determine if it hits geometry and accumulate occlusion or color
+    float stepSize = 1.0 / float(steps);
+    for (int i = 0; i < steps; ++i) {
+      float sampleIndex = float(i * temporalSampleStride + int(temporalFrameOffset));
+      randomDirectionSample = randomDirection(sampleIndex);
+      vec2 hemisphereSample = randomDirectionSample.rg * 0.5 + 0.5;
+      float offsetSample = randomDirectionSample.a * 0.5 + 0.5;
+      vec3 rayDirection = normalBasis * sampleCosineHemisphere(hemisphereSample);
+      vec3 hit = screenSpaceIntersection(rayDirection, viewPos.xyz, normalize(viewPos.xyz), normal, offsetSample, true);
+
+      if (hit.z > 0.0) {
+        // Emission and color bleed - reproject the current receiver and sampled hit to estimate bounced color
+        vec3 receiverColor = texture(lastFrameColorTexture, reprojectedCoordinate.xy).rgb;
+
+        vec2 hitReprojectedCoordinate = reprojectionCoordinate(hit);
+        vec3 sourceColor = texture(lastFrameColorTexture, hitReprojectedCoordinate).rgb;
+        vec3 sourceEmission = ${n(d.hasEmission,"texture(lastFrameEmissionTexture, hitReprojectedCoordinate).xyz","vec3(0.0)")};
+
+        float colorBleedWeight = computeColorBleedWeight(receiverColor, sourceColor);
+        fragGlobalIllumination.rgb += (sourceColor * colorBleedWeight + sourceEmission) * stepSize;
+      } else {
+        // 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 * 0.2 + 0.8, skyFacingWeight);
+        fragGlobalIllumination.a += skyModulation * stepSize;
+      }
+    }
+
+    // Rendering trick add noise to reduce accumulation artifacts
+    float accumulationDither = occlusionBlendWeight < 1.0
+      ? randomDirectionSample.b * ${i.float(z)}
+      : 0.0;
+
+    // Accumulate color
+    vec3 lastFrameColor = lastFrameGlobalIllumination.rgb;
+    float colorDitherScale = isScaledGlobalIllumination ? ${i.float(I)} : 1.0;
+    fragGlobalIllumination.rgb = resetColorHistory
+      ? vec3(0.0)
+      : mix(lastFrameColor + accumulationDither * colorDitherScale, fragGlobalIllumination.rgb, colorBlendWeight);
+
+    // Accumulate occlusion
+    fragGlobalIllumination.a = mix(lastFrameGlobalIllumination.a + accumulationDither, fragGlobalIllumination.a, occlusionBlendWeight);
+
+    fragWeight = occlusionBlendWeight;
+  `),O}const R=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationPassParameters:O,build:L},Symbol.toStringTag,{value:"Module"}));export{O as G,R as a,L as b};

package/chunks/GlobalIlluminationBlur.glsl.js

@@ -1,88 +1,88 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
 import{create as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{ScreenSpacePass as l}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepth as o}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{GlobalIlluminationWeights as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/GlobalIlluminationWeights.glsl.js";import{CameraSpace as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{BooleanBindUniform as a}from"../views/3d/webgl-engine/core/shaderModules/BooleanBindUniform.js";import{Float2DrawUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{FloatPassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DDrawUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DDrawUniform.js";import{Texture2DPassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as c}from"../views/webgl/NoParameters.js";import{ShaderBuilder as p}from"../views/webgl/ShaderBuilder.js";const h=4;class f extends c{constructor(){super(...arguments),this.blurSize=e()}}function d(){const e=new p,c=e.fragment;e.include(l),e.include(t),e.include(i);const f=(h+3)/2,d=1/(2*f*f);c.include(o);const g=5e4;c.uniforms.add(new a("hasEmission",e=>e.hasEmission),new u("depthMap",e=>e.depthTexture),new u("normalMap",e=>e.normalTexture),new m("globalIlluminationTexture",e=>e.texture),new m("globalIlluminationWeightTexture",e=>e.weightTexture),new s("blurSize",e=>e.blurSize),new n("scaleGlobalIllumination",e=>e.scaleGlobalIllumination),new n("projScale",(e,l)=>{const o=l.camera.distance;return o>g?Math.max(0,e.projScale-(o-g)):e.projScale}));const b=.1,S=400,v=.03,w=.08,W=1.5;return c.code.add(r`
-		void accumulateBlurSample(
-			vec2 sampleUv,
-			float sampleOffset,
-			float centerDepth,
-			vec3 centerNormal,
-			float depthSharpness,
-			bool skipOcclusionBlur,
-			inout float emissionWeightSum,
-			inout vec3 emissionSum,
-			inout float occlusionWeightSum,
-			inout float occlusionSum,
-			float centerOcclusionBlendWeight
-		) {
-			vec4 sampleGlobalIllumination = texture(globalIlluminationTexture, sampleUv);
-			vec3 sampleNormal = texture(normalMap, sampleUv).rgb;
-			float sampleDepth = linearDepthFromTexture(depthMap, sampleUv);
+    void accumulateBlurSample(
+      vec2 sampleUv,
+      float sampleOffset,
+      float centerDepth,
+      vec3 centerNormal,
+      float depthSharpness,
+      bool skipOcclusionBlur,
+      inout float emissionWeightSum,
+      inout vec3 emissionSum,
+      inout float occlusionWeightSum,
+      inout float occlusionSum,
+      float centerOcclusionBlendWeight
+    ) {
+      vec4 sampleGlobalIllumination = texture(globalIlluminationTexture, sampleUv);
+      vec3 sampleNormal = texture(normalMap, sampleUv).rgb;
+      float sampleDepth = linearDepthFromTexture(depthMap, sampleUv);
 
-			float depthDelta = sampleDepth - centerDepth;
-			bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
-			float normalSimilarityWeight = globalIlluminationNormalSimilarityWeight(sampleNormal, centerNormal);
-			float depthNormalCorrection = globalIlluminationDepthNormalCorrection(sampleNormal);
-			vec3 emission = sampleGlobalIllumination.rgb;
-			float emissionSpatialWeightMultiplier = isScaledGlobalIllumination ? ${r.float(S)} : 1.0;
+      float depthDelta = sampleDepth - centerDepth;
+      bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
+      float normalSimilarityWeight = globalIlluminationNormalSimilarityWeight(sampleNormal, centerNormal);
+      float depthNormalCorrection = globalIlluminationDepthNormalCorrection(sampleNormal);
+      vec3 emission = sampleGlobalIllumination.rgb;
+      float emissionSpatialWeightMultiplier = isScaledGlobalIllumination ? ${r.float(S)} : 1.0;
 
-			float emissionWeight = exp(
-				-sampleOffset * sampleOffset * ${r.float(d)} * ${r.float(b)} * emissionSpatialWeightMultiplier
-				- depthDelta * depthDelta * depthSharpness * depthNormalCorrection
-			);
-			emissionWeight *= normalSimilarityWeight;
-			emissionWeightSum += emissionWeight;
-			emissionSum += emissionWeight * emission;
+      float emissionWeight = exp(
+        -sampleOffset * sampleOffset * ${r.float(d)} * ${r.float(b)} * emissionSpatialWeightMultiplier
+        - depthDelta * depthDelta * depthSharpness * depthNormalCorrection
+      );
+      emissionWeight *= normalSimilarityWeight;
+      emissionWeightSum += emissionWeight;
+      emissionSum += emissionWeight * emission;
 
-			if (skipOcclusionBlur) {
-				return;
-			}
+      if (skipOcclusionBlur) {
+        return;
+      }
 
-			float occlusionSpatialKernelScale = centerOcclusionBlendWeight > ${r.float(v)}
-				? ${r.float(w)}
-				: ${r.float(W)};
-			float occlusionWeight = exp(-sampleOffset * sampleOffset * occlusionSpatialKernelScale - depthDelta * depthDelta * depthSharpness);
-			occlusionWeight *= normalSimilarityWeight;
-			occlusionWeightSum += occlusionWeight;
-			occlusionSum += occlusionWeight * sampleGlobalIllumination.a;
-		}
-	`),c.main.add(r`
-		vec3 emissionSum = vec3(0.0);
-		float emissionWeightSum = 0.0;
+      float occlusionSpatialKernelScale = centerOcclusionBlendWeight > ${r.float(v)}
+        ? ${r.float(w)}
+        : ${r.float(W)};
+      float occlusionWeight = exp(-sampleOffset * sampleOffset * occlusionSpatialKernelScale - depthDelta * depthDelta * depthSharpness);
+      occlusionWeight *= normalSimilarityWeight;
+      occlusionWeightSum += occlusionWeight;
+      occlusionSum += occlusionWeight * sampleGlobalIllumination.a;
+    }
+  `),c.main.add(r`
+    vec3 emissionSum = vec3(0.0);
+    float emissionWeightSum = 0.0;
 
-		vec4 centerGlobalIllumination = texture(globalIlluminationTexture, uv);
-		float centerOcclusionBlendWeight = texture(globalIlluminationWeightTexture, uv).r;
-		bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
-		bool shouldReuseCenterOcclusion = isScaledGlobalIllumination && centerOcclusionBlendWeight <= ${r.float(v)};
-		bool shouldSkipLowQualityBlur = !hasEmission && shouldReuseCenterOcclusion;
-		if (shouldSkipLowQualityBlur) {
-			fragColor = centerGlobalIllumination;
-			return;
-		}
+    vec4 centerGlobalIllumination = texture(globalIlluminationTexture, uv);
+    float centerOcclusionBlendWeight = texture(globalIlluminationWeightTexture, uv).r;
+    bool isScaledGlobalIllumination = scaleGlobalIllumination < 1.0;
+    bool shouldReuseCenterOcclusion = isScaledGlobalIllumination && centerOcclusionBlendWeight <= ${r.float(v)};
+    bool shouldSkipLowQualityBlur = !hasEmission && shouldReuseCenterOcclusion;
+    if (shouldSkipLowQualityBlur) {
+      fragColor = centerGlobalIllumination;
+      return;
+    }
 
-		float centerDepth = linearDepthFromTexture(depthMap, uv);
-		vec3 centerNormal = texture(normalMap, uv).rgb;
-		float occlusionSum = 0.0;
-		float occlusionWeightSum = 0.0;
+    float centerDepth = linearDepthFromTexture(depthMap, uv);
+    vec3 centerNormal = texture(normalMap, uv).rgb;
+    float occlusionSum = 0.0;
+    float occlusionWeightSum = 0.0;
 
-		float depthSharpness = globalIlluminationDepthSharpness(projScale, centerDepth);
-		for (int sampleOffset = -${r.int(h)}; sampleOffset <= ${r.int(h)}; ++sampleOffset) {
-			float sampleOffsetFloat = float(sampleOffset);
-			vec2 sampleUv = uv + sampleOffsetFloat * blurSize;
-			accumulateBlurSample(
-				sampleUv,
-				sampleOffsetFloat,
-				centerDepth,
-				centerNormal,
-				depthSharpness,
-				shouldReuseCenterOcclusion,
-				emissionWeightSum,
-				emissionSum,
-				occlusionWeightSum,
-				occlusionSum,
-				centerOcclusionBlendWeight
-			);
-		}
+    float depthSharpness = globalIlluminationDepthSharpness(projScale, centerDepth);
+    for (int sampleOffset = -${r.int(h)}; sampleOffset <= ${r.int(h)}; ++sampleOffset) {
+      float sampleOffsetFloat = float(sampleOffset);
+      vec2 sampleUv = uv + sampleOffsetFloat * blurSize;
+      accumulateBlurSample(
+        sampleUv,
+        sampleOffsetFloat,
+        centerDepth,
+        centerNormal,
+        depthSharpness,
+        shouldReuseCenterOcclusion,
+        emissionWeightSum,
+        emissionSum,
+        occlusionWeightSum,
+        occlusionSum,
+        centerOcclusionBlendWeight
+      );
+    }
 
-		vec3 blurredEmission = (emissionSum / emissionWeightSum).rgb;
-		float occlusion = shouldReuseCenterOcclusion ? centerGlobalIllumination.a : occlusionSum / occlusionWeightSum;
-		fragColor = vec4(blurredEmission, occlusion);
-	`),e}const g=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationBlurDrawParameters:f,build:d},Symbol.toStringTag,{value:"Module"}));export{f as G,g as a,d as b};
+    vec3 blurredEmission = (emissionSum / emissionWeightSum).rgb;
+    float occlusion = shouldReuseCenterOcclusion ? centerGlobalIllumination.a : occlusionSum / occlusionWeightSum;
+    fragColor = vec4(blurredEmission, occlusion);
+  `),e}const g=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationBlurDrawParameters:f,build:d},Symbol.toStringTag,{value:"Module"}));export{f as G,g as a,d as b};

package/config.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import"./core/has.js";import{deepMerge as e}from"./core/object.js";const s={apiKey:void 0,apiKeys:{scopes:[]},applicationName:"",applicationUrl:globalThis.location?.href,assetsPath:"",fontsUrl:"https://static.arcgis.com/fonts",geometryServiceUrl:"https://utility.arcgisonline.com/arcgis/rest/services/Geometry/GeometryServer",geoRSSServiceUrl:"https://utility.arcgis.com/sharing/rss",kmlServiceUrl:"https://utility.arcgis.com/sharing/kml",userPrivilegesApplied:!0,portalUrl:"https://www.arcgis.com",respectPrefersReducedMotion:!0,routeServiceUrl:"https://route-api.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World",workers:{loaderConfig:{has:{},paths:{},map:{},packages:[]}},request:{crossOriginNoCorsDomains:null,httpsDomains:["arcgis.com","arcgisonline.com","esrikr.com","premiumservices.blackbridge.com","esripremium.accuweather.com","gbm.digitalglobe.com","firstlook.digitalglobe.com","msi.digitalglobe.com"],interceptors:[],internalInterceptors:[],maxUrlLength:2e3,priority:"high",proxyRules:[],proxyUrl:null,timeout:62e3,trustedServers:[],useIdentity:!0},log:{interceptors:[],level:null}};if(globalThis.esriConfig&&(e(s,globalThis.esriConfig,!0),delete s.has),!s.assetsPath){{const e="5.1.0-next.79";s.assetsPath=`https://cdn.jsdelivr.net/npm/@arcgis/core@${e}/assets`}s.defaultAssetsPath=s.assetsPath}export{s as default};
+import"./core/has.js";import{deepMerge as e}from"./core/object.js";const s={apiKey:void 0,apiKeys:{scopes:[]},applicationName:"",applicationUrl:globalThis.location?.href,assetsPath:"",fontsUrl:"https://static.arcgis.com/fonts",geometryServiceUrl:"https://utility.arcgisonline.com/arcgis/rest/services/Geometry/GeometryServer",geoRSSServiceUrl:"https://utility.arcgis.com/sharing/rss",kmlServiceUrl:"https://utility.arcgis.com/sharing/kml",userPrivilegesApplied:!0,portalUrl:"https://www.arcgis.com",respectPrefersReducedMotion:!0,routeServiceUrl:"https://route-api.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World",workers:{loaderConfig:{has:{},paths:{},map:{},packages:[]}},request:{crossOriginNoCorsDomains:null,httpsDomains:["arcgis.com","arcgisonline.com","esrikr.com","premiumservices.blackbridge.com","esripremium.accuweather.com","gbm.digitalglobe.com","firstlook.digitalglobe.com","msi.digitalglobe.com"],interceptors:[],internalInterceptors:[],maxUrlLength:2e3,priority:"high",proxyRules:[],proxyUrl:null,timeout:62e3,trustedServers:[],useIdentity:!0},log:{interceptors:[],level:null}};if(globalThis.esriConfig&&(e(s,globalThis.esriConfig,!0),delete s.has),!s.assetsPath){{const e="5.1.0-next.80";s.assetsPath=`https://cdn.jsdelivr.net/npm/@arcgis/core@${e}/assets`}s.defaultAssetsPath=s.assetsPath}export{s as default};

package/form/elements/inputs/MultipleChoiceInput.d.ts

@@ -6,7 +6,7 @@ import type { OtherChoiceProperties } from "./multipleChoice/OtherChoice.js";
 
 export interface MultipleChoiceInputProperties extends Partial<Pick<MultipleChoiceInput, "choiceDelimiter" | "includeOtherChoice" | "maxSelectedChoices" | "minSelectedChoices">> {
   /** An array of available choices. */
-  choices?: ChoiceProperties[] | null;
+  choices?: ChoiceProperties[];
   /** The configuration for the `other` choice when [includeOtherChoice](https://developers.arcgis.com/javascript/latest/references/core/form/elements/inputs/MultipleChoiceInput/#includeOtherChoice) is `true`. */
   otherChoice?: OtherChoiceProperties | null;
 }
@@ -43,8 +43,8 @@ export default class MultipleChoiceInput extends Input {
    */
   accessor choiceDelimiter: string;
   /** An array of available choices. */
-  get choices(): Choice[] | null | undefined;
-  set choices(value: ChoiceProperties[] | null | undefined);
+  get choices(): Choice[];
+  set choices(value: ChoiceProperties[]);
   /** Indicates whether an additional `other` choice should be displayed. */
   accessor includeOtherChoice: boolean | null | undefined;
   /** The maximum number of choices allowed. */