@arcgis/core 5.1.0-next.71 → 5.1.0-next.73

package/chunks/GlobalIllumination.glsl.js

@@ -1,117 +1,187 @@
 /* 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 i}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepthLastFrame.glsl.js";import{EncodeEmissionColors as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EncodingColor.glsl.js";import{addMainLightDirection as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{ScreenSpaceReflections as t}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 n}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as s,If as l}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as u}from"../views/webgl/NoParameters.js";import{ShaderBuilder as p}from"../views/webgl/ShaderBuilder.js";class g extends u{constructor(){super(...arguments),this.projScale=1,this.frameCount=0}}function h(u){const g=new p,h=g.fragment;return g.include(e),g.include(a),r(h),h.include(i),g.include(t,{highStepCount:!1,screenSpaceReflections:!0}),h.include(o),h.uniforms.add(new d("normalMap",e=>e.normalTexture),new d("depthMap",e=>e.depthTexture),new d("lastFrameDepthTexture",(e,i)=>i.reprojection.lastFrameDepth?.attachment),new m("lastFrameGlobalIlluminationTexture",e=>e.globalIllumination?.getTexture()),new c("reprojectionViewMatrix",e=>e.reprojection.viewMatrix),new c("view",e=>e.camera.viewMatrix),new n("frameCount",e=>e.frameCount),new d("blueNoiseTex",e=>e.noiseTexture)),u.hasEmission&&h.uniforms.add(new d("lastFrameEmissionTexture",(e,i)=>i.reprojection.lastFrameEmission?.attachment)),h.constants.add("timeSamplesSize","float",64),h.constants.add("blueNoiseGridSize","float",8),h.code.add(s`vec4 randomDirection(float index) {
-vec2 textureOffset = vec2(mod(index, blueNoiseGridSize), floor(index / blueNoiseGridSize)) * timeSamplesSize;
-ivec2 iuv = ivec2(textureOffset + mod(gl_FragCoord.xy, vec2(timeSamplesSize)));
-vec4 blueNoiseValue = texelFetch(blueNoiseTex, iuv, 0);
-return 2.0 * blueNoiseValue - 1.0;
-}
-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);
-}`),h.main.add(s`
-    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) {
-      fragColor = vec4(0.0, 0.0, 0.0, 1.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) {
-      fragColor = vec4(0.0, 0.0, 0.0, 1.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(gl_FragCoord.xy, 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);
-
-    int steps;
-    float weightOcclusion;
-    float weightEmission;
-
-    // Heuristic to determine blending weights and number of steps for occlusion and emission
-    if (abs((lastFrameDepthViewPos + reprojectedViewPos.z)/max(lastFrameDepthViewPos, reprojectedViewPos.z)) > 0.01) {
-      steps = 6;
-      weightOcclusion = 1.0;
-      weightEmission = 1.0;
-    } else {
-      steps = 1;
-      if (lastFrameGlobalIllumination.b > 0.5) {
-        weightOcclusion = 0.15;
-        weightEmission = 0.008;
-      } else if (lastFrameGlobalIllumination.b >  0.02) {
-        weightOcclusion = lastFrameGlobalIllumination.b - 0.005;
-        weightEmission = 0.008;
-      } else {
-        weightOcclusion = 0.016;
-        weightEmission = 0.008;
-      }
-    }
-
-    vec4 randomDirectionSample;
-    mat3 normalBasis = basisFromNormal(normal);
-
-    // 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 index = float(i * min(64/steps, 6) + int(mod(frameCount, float(64/steps))));
-      randomDirectionSample = randomDirection(index);
-      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 = ${l(u.hasEmission,"texture(lastFrameEmissionTexture, hitReprojectedCoordinate).xyz","vec3(0.0)")};
-        fragColor += vec4(emissionColor * vec3(stepSize), 0.0);
-      } 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 weight = clamp(3.5 * dot(viewMainLightDirection.xyz, normal), 0.0, 1.0);
-        skyModulation = mix(1.0, skyModulation * 0.2 + 0.8, weight);
-        fragColor += skyModulation * vec4(vec3(0.0), stepSize);
-      }
-    }
-
-    // Rendering trick add noise to reduce accumulation artifacts
-    float ditheringNoise = weightOcclusion < 1. ? randomDirectionSample.b * 0.0039 : 0.0;
-
-    // Accumulate occlusion
-    fragColor.a = mix(lastFrameGlobalIllumination.a + ditheringNoise, fragColor.a, weightOcclusion);
-
-    // Accumulate emission
-    vec3 lastFrameEmission = decodeVec2ToRGB(lastFrameGlobalIllumination.rg);
-    fragColor.rgb = mix(lastFrameEmission + ditheringNoise, fragColor.rgb, weightEmission);
-
-    // Encode emission and occlusion into output
-    vec2 encodedColor = encodeRGBtoVec2(fragColor.rgb);
-    fragColor.r = encodedColor.x;
-    fragColor.g = encodedColor.y;
-    fragColor.b = weightOcclusion;
-  `),g}const f=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationPassParameters:g,build:h},Symbol.toStringTag,{value:"Module"}));export{g as G,f as a,h as b};
+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};

package/chunks/GlobalIlluminationBlur.glsl.js

@@ -1,68 +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 o}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepth as t}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{EncodeEmissionColors as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EncodingColor.glsl.js";import{CameraSpace as s}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{Float2DrawUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{FloatPassUniform as a}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 n}from"../views/3d/webgl-engine/core/shaderModules/Texture2DDrawUniform.js";import{Texture2DPassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as m}from"../views/webgl/NoParameters.js";import{ShaderBuilder as u}from"../views/webgl/ShaderBuilder.js";const p=4;class f extends m{constructor(){super(...arguments),this.blurSize=e()}}function d(){const e=new u,m=e.fragment;e.include(o),e.include(s),m.include(l);const f=(p+3)/2,d=1/(2*f*f);m.include(t);const h=5e4;m.uniforms.add(new c("depthMap",e=>e.depthTexture),new c("normalMap",e=>e.normalTexture),new n("tex",e=>e.colorTexture),new i("blurSize",e=>e.blurSize),new a("projScale",(e,o)=>{const t=o.camera.distance;return t>h?Math.max(0,e.projScale-(t-h)):e.projScale}));const g=15.3,S=.1,v=.03,b=.08,w=1.5;m.code.add(r`
-    void accumulateBlurSample(
-      vec2 sampleUv,
-      float sampleOffset,
-      float centerDepth,
-      vec3 centerNormal,
-      float depthSharpness,
-      inout float emissionWeightSum,
-      inout vec3 emissionSum,
-      inout float occlusionWeightSum,
-      inout float occlusionSum,
-      float centerOcclusionWeight
-    ) {
-      vec4 globalIllumination = texture(tex, sampleUv);
-      vec3 sampleNormal = texture(normalMap, sampleUv).rgb;
-      float sampleDepth = linearDepthFromTexture(depthMap, sampleUv);
+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);
 
-      float depthDelta = sampleDepth - centerDepth;
-      float normalWeight = clamp(1.0 - ${r.float(g)} * length(sampleNormal - centerNormal), 0.0, 1.0);
-      vec3 decodedEmission = decodeVec2ToRGB(globalIllumination.rg);
+			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(S)} - depthDelta * depthDelta * depthSharpness);
-      emissionWeight *= normalWeight;
-      emissionWeightSum += emissionWeight;
-      emissionSum += emissionWeight * decodedEmission;
+			float emissionWeight = exp(
+				-sampleOffset * sampleOffset * ${r.float(d)} * ${r.float(b)} * emissionSpatialWeightMultiplier
+				- depthDelta * depthDelta * depthSharpness * depthNormalCorrection
+			);
+			emissionWeight *= normalSimilarityWeight;
+			emissionWeightSum += emissionWeight;
+			emissionSum += emissionWeight * emission;
 
-      float occlusionKernelScale = centerOcclusionWeight > ${r.float(v)}
-        ? ${r.float(b)}
-        : ${r.float(w)};
-      float occlusionWeight = exp(-sampleOffset * sampleOffset * occlusionKernelScale - depthDelta * depthDelta * depthSharpness);
-      occlusionWeight *= normalWeight;
-      occlusionWeightSum += occlusionWeight;
-      occlusionSum += occlusionWeight * globalIllumination.a;
-    }
-  `);const W=-.05;return m.main.add(r`
-    vec3 emissionSum = vec3(0.0);
-    float emissionWeightSum = 0.0;
+			if (skipOcclusionBlur) {
+				return;
+			}
 
-    float centerDepth = linearDepthFromTexture(depthMap, uv);
-    vec3 centerNormal = texture(normalMap, uv).rgb;
-    float occlusionSum = 0.0;
-    float occlusionWeightSum = 0.0;
-    float centerOcclusionWeight = texture(tex, uv).b;
+			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 depthSharpness = ${r.float(W)} * projScale / centerDepth;
-    for (int sampleOffset = -${r.int(p)}; sampleOffset <= ${r.int(p)}; ++sampleOffset) {
-      float sampleOffsetFloat = float(sampleOffset);
-      vec2 sampleUv = uv + sampleOffsetFloat * blurSize;
-      accumulateBlurSample(
-        sampleUv,
-        sampleOffsetFloat,
-        centerDepth,
-        centerNormal,
-        depthSharpness,
-        emissionWeightSum,
-        emissionSum,
-        occlusionWeightSum,
-        occlusionSum,
-        centerOcclusionWeight
-      );
-    }
+		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;
+		}
 
-    vec3 blurredEmission = (emissionSum / emissionWeightSum).rgb;
-    vec2 encodedEmission = encodeRGBtoVec2(blurredEmission.rgb);
-    float occlusion = occlusionSum / occlusionWeightSum;
-    fragColor = vec4(vec3(encodedEmission.x, encodedEmission.y, centerOcclusionWeight), occlusion);
-  `),e}const h=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationBlurDrawParameters:f,build:d},Symbol.toStringTag,{value:"Module"}));export{f as G,h as a,d as b};
+		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
+			);
+		}
+
+		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/chunks/GlobalIlluminationUpscale.glsl.js

@@ -0,0 +1,66 @@
+/* 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{ReadDepth as t}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{GlobalIlluminationWeights as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/GlobalIlluminationWeights.glsl.js";import{CameraSpace as r}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{FloatPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as i}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DDrawUniform as o}from"../views/3d/webgl-engine/core/shaderModules/Texture2DDrawUniform.js";import{Texture2DPassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as h}from"../views/webgl/NoParameters.js";import{ShaderBuilder as u}from"../views/webgl/ShaderBuilder.js";const s=5e4;class m extends h{}function c(){const h=new u,m=h.fragment;return h.include(e),h.include(r),h.include(l),m.include(t),m.uniforms.add(new n("depthMap",e=>e.depthTexture),new n("normalMap",e=>e.normalTexture),new o("tex",e=>e.colorTexture),new o("globalIlluminationWeightTexture",e=>e.weightTexture),new a("scaleGlobalIllumination",e=>e.scaleGlobalIllumination),new a("projScale",(e,t)=>{const l=t.camera.distance;return l>s?Math.max(0,e.projScale-(l-s)):e.projScale})),m.code.add(i`float computeDepthWeight(float sampleDepth, float centerDepth, float depthSharpness) {
+float depthDelta = abs(sampleDepth - centerDepth);
+return exp(-0.08 - depthDelta * depthDelta * depthSharpness);
+}
+vec3 normalFromTexture(sampler2D normalTexture, vec2 uv) {
+ivec2 normalTextureSize = textureSize(normalTexture, 0);
+ivec2 normalTexel = clamp(ivec2(uv * vec2(normalTextureSize)), ivec2(0), normalTextureSize - ivec2(1));
+return texelFetch(normalTexture, normalTexel, 0).xyz;
+}
+void sampleJointBilateralUpscale(vec2 sampleUv, out vec4 upscaledColor, out float upscaledWeight) {
+float centerDepth = linearDepthFromTexture(depthMap, sampleUv);
+vec3 centerNormal = normalFromTexture(normalMap, sampleUv);
+float depthSharpness = globalIlluminationDepthSharpness(projScale, centerDepth, centerNormal);
+vec2 lowResTextureSize = vec2(textureSize(tex, 0));
+vec2 texelPosition = sampleUv * lowResTextureSize - 0.5;
+vec2 texelBase = floor(texelPosition);
+vec2 bilinearWeightsFraction = fract(texelPosition);
+vec2 uv00 = (texelBase + vec2(0.5, 0.5)) / lowResTextureSize;
+vec2 uv10 = (texelBase + vec2(1.5, 0.5)) / lowResTextureSize;
+vec2 uv01 = (texelBase + vec2(0.5, 1.5)) / lowResTextureSize;
+vec2 uv11 = (texelBase + vec2(1.5, 1.5)) / lowResTextureSize;
+vec4 color00 = texture(tex, uv00);
+vec4 color10 = texture(tex, uv10);
+vec4 color01 = texture(tex, uv01);
+vec4 color11 = texture(tex, uv11);
+float weight00 = texture(globalIlluminationWeightTexture, uv00).r;
+float weight10 = texture(globalIlluminationWeightTexture, uv10).r;
+float weight01 = texture(globalIlluminationWeightTexture, uv01).r;
+float weight11 = texture(globalIlluminationWeightTexture, uv11).r;
+float depth00 = linearDepthFromTexture(depthMap, uv00);
+float depth10 = linearDepthFromTexture(depthMap, uv10);
+float depth01 = linearDepthFromTexture(depthMap, uv01);
+float depth11 = linearDepthFromTexture(depthMap, uv11);
+vec3 normal00 = normalFromTexture(normalMap, uv00);
+vec3 normal10 = normalFromTexture(normalMap, uv10);
+vec3 normal01 = normalFromTexture(normalMap, uv01);
+vec3 normal11 = normalFromTexture(normalMap, uv11);
+float bilinearWeight00 = (1.0 - bilinearWeightsFraction.x) * (1.0 - bilinearWeightsFraction.y);
+float bilinearWeight10 = bilinearWeightsFraction.x * (1.0 - bilinearWeightsFraction.y);
+float bilinearWeight01 = (1.0 - bilinearWeightsFraction.x) * bilinearWeightsFraction.y;
+float bilinearWeight11 = bilinearWeightsFraction.x * bilinearWeightsFraction.y;
+float jointBilateralWeight00 = bilinearWeight00 * computeDepthWeight(depth00, centerDepth, depthSharpness) * globalIlluminationNormalSimilarityWeight(normal00, centerNormal);
+float jointBilateralWeight10 = bilinearWeight10 * computeDepthWeight(depth10, centerDepth, depthSharpness) * globalIlluminationNormalSimilarityWeight(normal10, centerNormal);
+float jointBilateralWeight01 = bilinearWeight01 * computeDepthWeight(depth01, centerDepth, depthSharpness) * globalIlluminationNormalSimilarityWeight(normal01, centerNormal);
+float jointBilateralWeight11 = bilinearWeight11 * computeDepthWeight(depth11, centerDepth, depthSharpness) * globalIlluminationNormalSimilarityWeight(normal11, centerNormal);
+float jointBilateralWeightSum = jointBilateralWeight00 + jointBilateralWeight10 + jointBilateralWeight01 + jointBilateralWeight11;
+if (jointBilateralWeightSum < 0.0001) {
+vec2 nearestUv = (floor(texelPosition + 0.5) + vec2(0.5)) / lowResTextureSize;
+upscaledColor = texture(tex, nearestUv);
+upscaledWeight = texture(globalIlluminationWeightTexture, nearestUv).r;
+return;
+}
+upscaledColor = (
+color00 * jointBilateralWeight00 +
+color10 * jointBilateralWeight10 +
+color01 * jointBilateralWeight01 +
+color11 * jointBilateralWeight11
+) / jointBilateralWeightSum;
+upscaledWeight = (
+weight00 * jointBilateralWeight00 +
+weight10 * jointBilateralWeight10 +
+weight01 * jointBilateralWeight01 +
+weight11 * jointBilateralWeight11
+) / jointBilateralWeightSum;
+}`),h.outputs.add("fragColor","vec4",0),h.outputs.add("fragWeight","float",1),m.main.add(i`sampleJointBilateralUpscale(uv, fragColor, fragWeight);`),h}const p=Object.freeze(Object.defineProperty({__proto__:null,GlobalIlluminationUpscaleDrawParameters:m,build:c},Symbol.toStringTag,{value:"Module"}));export{m as G,p as a,c as b};

package/chunks/ImageMaterial.glsl.js

@@ -1,12 +1,10 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{SliceDraw as e}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as r}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{terrainDepthTest as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as i}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as s}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{FloatPassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{If as a,glsl as l}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{outputColorHighlightOLID as n}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{NoParameters as g}from"../views/webgl/NoParameters.js";import{ShaderBuilder as p}from"../views/webgl/ShaderBuilder.js";class v extends g{}function c(g){const v=new p,{vertex:c,fragment:m,varyings:u}=v,{output:w,perspectiveInterpolation:f}=g;return s(c,g),v.include(r),v.include(o,g),v.fragment.include(e,g),v.fragment.code.add(l`void outputObjectAndLayerIdColor() {
-    ${a(11===w,"fragColor = vec4(0, 0, 0, 1);")}
-    }`),v.include(n,g),v.attributes.add("position","vec3"),v.attributes.add("uv0","vec2"),f&&v.attributes.add("perspectiveDivide","float"),c.main.add(l`
+import{SliceDraw as e}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as o}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ColorConversion as r}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as i}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{FloatPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{If as t,glsl as a}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{outputColorHighlightOLID as d}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{NoParameters as n}from"../views/webgl/NoParameters.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";class v extends n{}function p(n){const v=new g,{vertex:p,fragment:c,varyings:m}=v,{output:u,perspectiveInterpolation:f}=n;return i(p,n),v.include(o),v.fragment.include(e,n),v.fragment.code.add(a`void outputObjectAndLayerIdColor() {
+    ${t(11===u,"fragColor = vec4(0, 0, 0, 1);")}
+    }`),v.include(d,n),v.attributes.add("position","vec3"),v.attributes.add("uv0","vec2"),f&&v.attributes.add("perspectiveDivide","float"),p.main.add(a`
     vpos = position;
-    forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
     vTexCoord = uv0;
     gl_Position = transformPosition(proj, view, vpos);
-    ${a(f,"gl_Position *= perspectiveDivide;")}`),u.add("vpos","vec3",{invariant:!0}),u.add("vTexCoord","vec2"),m.include(i),m.uniforms.add(new t("opacity",e=>e.opacity),new d("tex",e=>e.texture)).main.add(l`discardBySlice(vpos);
-discardByTerrainDepth();
+    ${t(f,"gl_Position *= perspectiveDivide;")}`),m.add("vpos","vec3",{invariant:!0}),m.add("vTexCoord","vec2"),c.include(r),c.uniforms.add(new s("opacity",e=>e.opacity),new l("tex",e=>e.texture)).main.add(a`discardBySlice(vpos);
 vec4 finalColor = texture(tex, vTexCoord) * opacity;
-outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),v}const m=Object.freeze(Object.defineProperty({__proto__:null,ImageMaterialPassParameters:v,build:c},Symbol.toStringTag,{value:"Module"}));export{m as I,v as a,c as b};
+outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),v}const c=Object.freeze(Object.defineProperty({__proto__:null,ImageMaterialPassParameters:v,build:p},Symbol.toStringTag,{value:"Module"}));export{c as I,v as a,p as b};