@arcgis/core 6.0.0-next.1 → 6.0.0-next.11

package/views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js

@@ -1,39 +1,39 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{EvaluateAmbientLighting as e}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as t}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as n}from"./Gamma.glsl.js";import{mainLightDirection as r,mainLightIntensity as i,applyShading as a}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as o}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as s}from"./PiUtils.glsl.js";import{ReadGlobalIllumination as c}from"./ReadGlobalIllumination.glsl.js";import{BooleanBindUniform as l}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as u}from"../../shaderModules/FloatBindUniform.js";import{glsl as d,If as f}from"../../shaderModules/glsl.js";import{ambientBoost as p}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as m}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as h}from"../../../shaders/ToneMapping.glsl.js";function g(e){e.constants.add(`ambientBoostFactor`,`float`,p)}const _=new u(`lightingGlobalFactor`,e=>e.lighting.globalFactor);function v(p,v){let{pbrMode:y,spherical:b,hasColorTexture:x,receiveGlobalIllumination:S}=v;p.include(n),p.include(c,v),p.include(t,v),y!==0&&p.include(o,v),p.include(e,v),p.include(s),p.include(h,v);let C=!(y===2&&!x);C&&p.include(m),g(p),p.uniforms.add(r,_).code.add(d`
+import{EvaluateAmbientLighting as e}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as t}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as n}from"./Gamma.glsl.js";import{mainLightDirection as r,lightingGlobalFactor as i,mainLightIntensity as a,lightingSpecularStrength as o,lightingEnvironmentStrength as s}from"./lightingUniforms.js";import{applyShading as c}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as l}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as u}from"./PiUtils.glsl.js";import{ReadGlobalIllumination as d}from"./ReadGlobalIllumination.glsl.js";import{BooleanBindUniform as f}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as p}from"../../shaderModules/FloatBindUniform.js";import{glsl as m,If as h}from"../../shaderModules/glsl.js";import{ambientBoost as g}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as _}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as v}from"../../../shaders/ToneMapping.glsl.js";function y(e){e.constants.add(`ambientBoostFactor`,`float`,g)}function b(g,b){let{pbrMode:x,spherical:S,hasColorTexture:C,receiveGlobalIllumination:w}=b;g.include(n),g.include(d,b),g.include(t,b),x!==0&&g.include(l,b),g.include(e,b),g.include(u),g.include(v,b);let T=!(x===2&&!C);T&&g.include(_),y(g),g.uniforms.add(r,i).code.add(m`
     float additionalDirectedAmbientLight(float lightAlignment) {
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
 
     float additionalDirectedAmbientLight(vec3 vPosWorld) {
-      float lightAlignment = dot(${b?d`normalize(vPosWorld)`:d`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
+      float lightAlignment = dot(${S?m`normalize(vPosWorld)`:m`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
-  `),p.uniforms.add(i).code.add(d`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
+  `),g.uniforms.add(a).code.add(m`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
 float additionalAmbientScale = additionalDirectedAmbientLight(vPosWorld);
 return (1.0 - ambientOcclusion) * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor * mainLightIntensity;
-}`);let w=S?`globalIlluminationOcclusion`:`ssao`,T=S?`factorDirect`:`0.0`,E=S?`factorAmbient`:`1.0`;switch(p.constants.add(`mainLightIrradianceScale`,`float`,S?.75:1),p.constants.add(`ambientIrradianceScale`,`float`,S?1.5:1),S&&(p.uniforms.add(new u(`factorDirect`,e=>e.globalIlluminationDirectFactor),new u(`factorAmbient`,e=>e.globalIlluminationAmbientFactor)),p.constants.add(`globalIlluminationEmissionCompressionWeight`,`float`,.75),p.code.add(d`vec3 evaluateGlobalIlluminationOcclusion() {
-return min(1.2 * readGlobalIlluminationOcclusion(), 1.0);
+}`);let E=w?`globalIlluminationOcclusion`:`ssao`;switch(g.constants.add(`mainLightIrradianceScale`,`float`,w?.75:1),g.constants.add(`ambientIrradianceScale`,`float`,w?1.5:1),w?(g.uniforms.add(new p(`factorDirect`,e=>e.globalIlluminationDirectFactor),new p(`factorAmbient`,e=>e.globalIlluminationAmbientFactor)),g.constants.add(`globalIlluminationOcclusionBoost`,`float`,1.2),g.constants.add(`globalIlluminationEmissionBoost`,`float`,2.25),g.constants.add(`globalIlluminationEmissionCompressionWeight`,`float`,.75),g.code.add(m`vec3 evaluateGlobalIlluminationOcclusion() {
+return min(globalIlluminationOcclusionBoost * readGlobalIlluminationOcclusion(), 1.0);
 }
 vec3 evaluateGlobalIlluminationEmission(vec3 albedoLinear) {
-vec3 emission = 2.25 * (0.75 * albedoLinear + 0.25) * readGlobalIlluminationEmission().rgb;
+vec3 emission = globalIlluminationEmissionBoost * (0.75 * albedoLinear + 0.25) * readGlobalIlluminationEmission().rgb;
 vec3 compressedEmission = emission / (emission + 1.0);
 return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWeight);
-}`)),y){case 0:case 4:case 3:p.include(a),p.code.add(d`
+}`)):(g.constants.add(`factorDirect`,`float`,0),g.constants.add(`factorAmbient`,`float`,1)),x){case 0:case 4:case 3:g.include(c),g.code.add(m`
         vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
                                    vec3 viewDirection, vec3 upDirection) {
-          ${f(S,d`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
+          ${h(w,`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
 
           vec3 mainLighting = mainLightIrradianceScale * applyShading(normal, shadow);
-          vec3 ambientLighting = ambientIrradianceScale * calculateAmbientIrradiance(normal) * (1.0 - ${w});
+          vec3 ambientLighting = ambientIrradianceScale * calculateAmbientIrradiance(normal) * (1.0 - ${E});
           vec3 albedoLinear = linearizeGamma(albedo);
 
           vec3 totalLight = mainLighting + ambientLighting + additionalLight;
           totalLight = min(totalLight, vec3(PI));
           vec3 linearColor = vec3((albedoLinear / PI) * totalLight);
-          ${f(S,`linearColor += evaluateGlobalIlluminationEmission(albedoLinear);`)}
+          ${h(w,`linearColor += evaluateGlobalIlluminationEmission(albedoLinear);`)}
           return delinearizeGamma(linearColor);
         }
-      `);break;case 1:case 2:p.constants.add(`groundReflectance`,`float`,S?.35:.2),p.code.add(d`
+      `);break;case 1:case 2:g.constants.add(`groundReflectance`,`float`,w?.35:.2),g.code.add(m`
         const float fillLightIntensity = 0.25;
         const float horizonLightDiffusion = 0.4;
 
@@ -41,18 +41,20 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
                                    vec3 viewDirection, vec3 upDirection) {
           PBRShadingInfo inputs;
           calculatePBRInputs(inputs, normal, viewDirection, upDirection, albedo);
-          ${f(S,`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
-      `),v.useFillLights?p.uniforms.add(new l(`hasFillLights`,e=>e.enableFillLights)):p.constants.add(`hasFillLights`,`bool`,!1),p.code.add(d`
-        vec3 ambientDir = vec3(5.0 * upDirection[1] - upDirection[0] * upDirection[2], - 5.0 * upDirection[0] - upDirection[2] * upDirection[1], upDirection[1] * upDirection[1] + upDirection[0] * upDirection[0]);
-        ambientDir = ambientDir != vec3(0.0) ? normalize(ambientDir) : normalize(vec3(5.0, -1.0, 0.0));
+          ${h(w,`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
+      `),b.useFillLights?g.uniforms.add(new f(`hasFillLights`,e=>e.enableFillLights)):g.constants.add(`hasFillLights`,`bool`,!1),g.code.add(m`
+        vec3 ambientDir = vec3( 5.0 * upDirection[1] - upDirection[0] * upDirection[2],
+                               -5.0 * upDirection[0] - upDirection[2] * upDirection[1],
+                               upDirection[1] * upDirection[1] + upDirection[0] * upDirection[0]);
+        ambientDir = ambientDir == vec3(0.0) ? normalize(vec3(5.0, -1.0, 0.0)) : normalize(ambientDir);
 
         inputs.NdotAmbDir = hasFillLights ? abs(dot(normal, ambientDir)) : 1.0;
 
         // Calculate the irradiance components: sun, fill lights and the sky.
         // Applying AO to both direct and ambient lighting enhances depth perception.
         // This is an artistic choice; physically, AO should only attenuate ambient lighting.
-        vec3 directOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${w}), ${T});
-        vec3 ambientOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${w}), ${E});
+        vec3 directOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${E}), factorDirect);
+        vec3 ambientOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${E}), factorAmbient);
         vec3 mainLightIrradianceComponent = mainLightIrradianceScale * inputs.NdotL * (1.0 - shadow) * mainLightIntensity * directOcclusionFactor;
         vec3 fillLightsIrradianceComponent = inputs.NdotAmbDir * mainLightIntensity * fillLightIntensity * directOcclusionFactor;
         // calculate ambient irradiance for localView and additionalLight for globalView
@@ -62,7 +64,7 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
         inputs.skyIrradianceToSurface = ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
         // Assemble the overall irradiance of the ground that illuminates the surface. for this we use the simple model that changes only the sky irradiance by the groundReflectance
         inputs.groundIrradianceToSurface = groundReflectance * ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
-      `),p.uniforms.add(new u(`lightingSpecularStrength`,e=>e.lighting.mainLight.specularStrength),new u(`lightingEnvironmentStrength`,e=>e.lighting.mainLight.environmentStrength)).code.add(d`
+      `),g.uniforms.add(o,s).code.add(m`
         vec3 horizonRingDir = inputs.RdotUP * upDirection - inputs.reflectedView;
         vec3 horizonRingH = normalize(horizonRingDir - viewDirection);
         inputs.NdotH_Horizon = dot(normal, horizonRingH);
@@ -71,7 +73,7 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
         vec3 horizonLightRadianceComponent = lightingEnvironmentStrength * normalDistribution(inputs.NdotH_Horizon, min(inputs.roughness + horizonLightDiffusion, 1.0)) * mainLightIntensity * fillLightIntensity;
 
         // calculateAmbientRadiance for localView and additionalLight for global view
-        vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance() * (1.0 - ${w}) + additionalLight;
+        vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance() * (1.0 - ${E}) + additionalLight;
         float normalDirectionModifier = mix(1., min(mix(0.1, 2.0, (inputs.NdotUP + 1.) * 0.5), 1.0), clamp(inputs.roughness * 5.0, 0.0 , 1.0));
 
         // Assemble the overall radiance of the sky that illuminates the surface
@@ -82,19 +84,19 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
 
         // Calculate average ambient radiance - This is used in the gamut mapping process to determine the black level for compression
         inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + groundReflectance);
-      `),p.constants.add(`additionalAmbientIrradianceFactor`,`float`,.02),p.code.add(d`
+      `),g.constants.add(`additionalAmbientIrradianceFactor`,`float`,.02),g.code.add(m`
         vec3 reflectedColorComponent = evaluateEnvironmentIllumination(inputs);
         float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
         vec3 additionalMaterialReflectanceComponent = inputs.albedoLinear * additionalAmbientIrradiance;
         vec3 linearColor = reflectedColorComponent + additionalMaterialReflectanceComponent;
 
-        ${f(S,`linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
+        ${h(w,`linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
 
-      ${C?`linearColor = blackLevelSoftCompression(linearColor, inputs.averageAmbientRadiance);`:`linearColor = max(vec3(0.0), linearColor - 0.005 * inputs.averageAmbientRadiance);`}
+      ${T?`linearColor = blackLevelSoftCompression(linearColor, inputs.averageAmbientRadiance);`:`linearColor = max(vec3(0.0), linearColor - 0.005 * inputs.averageAmbientRadiance);`}
 
         return delinearizeGamma(linearColor);
       }
-    `);break;case 5:case 6:p.constants.add(`terrainSpecularity`,`float`,S?.35:.5),p.uniforms.add(r,i).code.add(d`
+    `);break;case 5:case 6:g.constants.add(`terrainSpecularity`,`float`,w?.35:.5),g.uniforms.add(r,a).code.add(m`
         const float roughnessTerrain = 0.5;
 
         vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
@@ -102,12 +104,12 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
           PBRShadingInfo inputs;
           calculateSimplifiedInputs(inputs, normal, viewDirection, upDirection, albedo);
 
-          ${f(S,`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
+          ${h(w,`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
 
           // Applying AO to both direct and ambient lighting enhances depth perception.
           // This is an artistic choice; physically, AO should only attenuate ambient lighting.
-          vec3 directOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${w}), ${T});
-          vec3 ambientOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${w}), ${E});
+          vec3 directOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${E}), factorDirect);
+          vec3 ambientOcclusionFactor = mix(vec3(1.0), vec3(1.0 - ${E}), factorAmbient);
           vec3 mainLightIrradianceComponent = mainLightIrradianceScale * (1.0 - shadow) * inputs.NdotL * mainLightIntensity * directOcclusionFactor;
           vec3 ambientLightIrradianceComponent = ambientIrradianceScale * calculateAmbientIrradiance(normal) * ambientOcclusionFactor + additionalLight;
           vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
@@ -122,11 +124,11 @@ return mix(emission, compressedEmission, globalIlluminationEmissionCompressionWe
 
           vec3 linearColor = diffuseColor + specularComponent;
 
-          ${f(S,`linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
+          ${h(w,`linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
 
           return delinearizeGamma(linearColor);
         }
-      `);break;case 7:p.code.add(d`vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+      `);break;case 7:g.code.add(m`vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
 vec3 viewDirection, vec3 upDirection) {
 return albedo;
-}`)}}export{v as EvaluateSceneLighting,g as addAmbientBoostFactor,_ as lightingGlobalFactor};
+}`)}}export{b as EvaluateSceneLighting,y as addAmbientBoostFactor};

package/views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js

@@ -1,10 +1,10 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{MixExternalColor as e}from"../util/MixExternalColor.glsl.js";import{NoPerspectiveRead as t}from"../util/NoPerspective.glsl.js";import{addCameraPosition as n,addPixelRatio as r}from"../util/View.glsl.js";import{Float4PassUniform as i}from"../../shaderModules/Float4PassUniform.js";import{FloatBindUniform as a}from"../../shaderModules/FloatBindUniform.js";import{FloatPassUniform as o}from"../../shaderModules/FloatPassUniform.js";import{glsl as s,If as c}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as l}from"../../shaderModules/Texture2DPassUniform.js";import{isImagePattern as u}from"../../../materials/lineStippleUtils.js";import{computeTextureSize as d}from"../../../materials/stippleTextureRepository.js";import{ensureColor4 as f}from"../../../shaders/ensureColor4.js";function p(u,d){if(!d.stippleEnabled){u.fragment.code.add(s`float getStippleAlpha(float lineWidth) { return 1.0; }
+import{worldToScreenPerDistanceRatio as e,pixelRatio as t}from"../util/cameraUniforms.js";import{MixExternalColor as n}from"../util/MixExternalColor.glsl.js";import{NoPerspectiveRead as r}from"../util/NoPerspective.glsl.js";import{addCameraPosition as i}from"../util/View.glsl.js";import{Float4PassUniform as a}from"../../shaderModules/Float4PassUniform.js";import{FloatPassUniform as o}from"../../shaderModules/FloatPassUniform.js";import{glsl as s,If as c}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as l}from"../../shaderModules/Texture2DPassUniform.js";import{isImagePattern as u}from"../../../materials/lineStippleUtils.js";import{computeTextureSize as d}from"../../../materials/stippleTextureRepository.js";import{ensureColor4 as f}from"../../../shaders/ensureColor4.js";function p(u,d){if(!d.stippleEnabled){u.fragment.code.add(s`float getStippleAlpha(float lineWidth) { return 1.0; }
 void discardByStippleAlpha(float stippleAlpha, float threshold) {}
-vec4 blendStipple(vec4 color, float stippleAlpha) { return color; }`);return}let p=!(d.draped&&d.stipplePreferContinuous),{vertex:g,fragment:_}=u;d.draped||(n(g,d),g.uniforms.add(new a(`worldToScreenPerDistanceRatio`,({camera:e})=>1/e.screenPixelSizePerDistance)).code.add(s`float computeWorldToScreenRatio(vec3 segmentCenter) {
+vec4 blendStipple(vec4 color, float stippleAlpha) { return color; }`);return}let p=!(d.draped&&d.stipplePreferContinuous),{vertex:g,fragment:_}=u;d.draped||(i(g,d),g.uniforms.add(e).code.add(s`float computeWorldToScreenRatio(vec3 segmentCenter) {
 float segmentDistanceToCamera = length(segmentCenter - cameraPosition);
 return worldToScreenPerDistanceRatio / segmentDistanceToCamera;
-}`)),u.varyings.add(`vStippleDistance`,`float`),u.varyings.add(`vStippleDistanceLimits`,`vec2`),u.varyings.add(`vStipplePatternStretch`,`float`),g.code.add(s`
+}`)),u.varyings.add(`vStippleDistance`,`float`),u.varyings.add(`vStippleLimitsAndCaps`,`vec4`),u.varyings.add(`vStipplePatternStretch`,`float`),g.code.add(s`
     float discretizeStippleDistanceToScreenRatio(float stippleDistanceToScreenRatio) {
       float step = ${s.float(h)};
 
@@ -13,7 +13,7 @@ return worldToScreenPerDistanceRatio / segmentDistanceToCamera;
       discreteStippleDistanceToScreenRatio = exp(discreteStippleDistanceToScreenRatio);
       return discreteStippleDistanceToScreenRatio;
     }
-  `),r(g),g.code.add(s`
+  `),g.uniforms.add(t).code.add(s`
     vec2 computeStippleDistanceLimits(float startPseudoScreen, float segmentLengthPseudoScreen, float segmentLengthScreen, float patternLength) {
 
       // First check if the segment is long enough to support fully screen space patterns.
@@ -35,9 +35,10 @@ return worldToScreenPerDistanceRatio / segmentDistanceToCamera;
       }
       return vec2(startPseudoScreen, startPseudoScreen + segmentLengthPseudoScreen);
     }
-  `),_.uniforms.add(new l(`stipplePatternTexture`,e=>e.stippleTexture),new o(`stipplePatternPixelSizeInv`,e=>1/m(e))),d.stippleOffColorEnabled&&_.uniforms.add(new i(`stippleOffColor`,e=>f(e.stippleOffColor))),u.include(t);let v=d.worldSized&&d.imagePattern,{usePerspectiveCorrectStipple:y}=d,b=!d.worldSized;y&&u.varyings.add(`vStipplePerspective`,`vec4`),v?(u.varyings.add(`vStippleV`,`float`),u.fragment.include(e),_.code.add(s`vec4 getStippleColor(out bool isClamped) {
-vec2 aaCorrectedLimits = vStippleDistanceLimits + vec2(1.0, -1.0) / gl_FragCoord.w;
-isClamped = vStippleDistance < aaCorrectedLimits.x || vStippleDistance > aaCorrectedLimits.y;
+  `),_.uniforms.add(new l(`stipplePatternTexture`,e=>e.stippleTexture),new o(`stipplePatternPixelSizeInv`,e=>1/m(e))),d.stippleOffColorEnabled&&_.uniforms.add(new a(`stippleOffColor`,e=>f(e.stippleOffColor))),u.include(r);let v=d.worldSized&&d.imagePattern,{usePerspectiveCorrectStipple:y}=d;y&&u.varyings.add(`vStipplePerspective`,`vec4`),v?(u.varyings.add(`vStippleV`,`float`),u.fragment.include(n),_.code.add(s`vec4 getStippleColor(out bool isClamped) {
+vec2 aaCorrectedLimits = vStippleLimitsAndCaps.xy + vec2(1.0, -1.0) / gl_FragCoord.w;
+isClamped = (vStippleLimitsAndCaps.z <= 0.0 && vStippleDistance < aaCorrectedLimits.x) ||
+(vStippleLimitsAndCaps.w <= 0.0 && vStippleDistance > aaCorrectedLimits.y);
 float u = vStippleDistance * stipplePatternPixelSizeInv;
 float v = vStippleV == -1.0 ? 0.5 : vStippleV;
 return texture(stipplePatternTexture, vec2(u, v));
@@ -61,7 +62,21 @@ float opacity = mixExternalOpacity(color.a, 1.0, stippleColor.a, mixMode);
 return vec4(col, opacity);
 }`)):_.code.add(s`
     float getStippleSDF(out bool isClamped) {
-      float stippleDistance = noPerspectiveRead(${b?`clamp(vStippleDistance, vStippleDistanceLimits.x, vStippleDistanceLimits.y)`:`vStippleDistance`});
+      ${c(d.worldSized,s`
+          float unclampedStippleDistance = noPerspectiveRead(vStippleDistance);
+          float stippleDistancePerPixel = length(vec2(dFdx(unclampedStippleDistance), dFdy(unclampedStippleDistance)));
+        `,s`float stippleDistancePerPixel = 1.0;`)}
+
+      bool clampStart = vStippleLimitsAndCaps.z <= 0.0;
+      bool clampEnd = vStippleLimitsAndCaps.w <= 0.0;
+      float stippleDistance = vStippleDistance;
+      if (clampStart) {
+        stippleDistance = max(stippleDistance, vStippleLimitsAndCaps.x);
+      }
+      if (clampEnd) {
+        stippleDistance = min(stippleDistance, vStippleLimitsAndCaps.y);
+      }
+      stippleDistance = noPerspectiveRead(stippleDistance);
       float lineSizeInv = noPerspectiveRead(vLineSizeInv);
 
       ${c(y,s`
@@ -75,10 +90,9 @@ return vec4(col, opacity);
           stippleDistance = mix(stipplePerspective.x, stipplePerspective.y, perspectiveFactor);
         `)}
 
-      ${b?s`
-      vec2 aaCorrectedLimits = vStippleDistanceLimits + vec2(1.0, -1.0) / gl_FragCoord.w;
-      isClamped = vStippleDistance < aaCorrectedLimits.x || vStippleDistance > aaCorrectedLimits.y;
-      `:s`isClamped = false;`}
+        vec2 aaCorrectedLimits = vStippleLimitsAndCaps.xy + vec2(1.0, -1.0) * stippleDistancePerPixel / gl_FragCoord.w;
+      isClamped = (clampStart && vStippleDistance < aaCorrectedLimits.x) ||
+          (clampEnd && vStippleDistance > aaCorrectedLimits.y);
 
       float u = stippleDistance * stipplePatternPixelSizeInv * lineSizeInv;
       u = fract(u);

package/views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{Float3BindUniform as e}from"../../shaderModules/Float3BindUniform.js";import{glsl as t}from"../../shaderModules/glsl.js";const n=new e(`mainLightDirection`,e=>e.lighting.mainLight.direction),r=new e(`mainLightIntensity`,e=>e.lighting.mainLight.intensity);function i(e){e.uniforms.add(n,r),e.code.add(t`vec3 applyShading(vec3 shadingNormal, float shadow) {
+import{mainLightDirection as e,mainLightIntensity as t}from"./lightingUniforms.js";import{glsl as n}from"../../shaderModules/glsl.js";function r(r){r.uniforms.add(e,t).code.add(n`vec3 applyShading(vec3 shadingNormal, float shadow) {
 float dotVal = clamp(dot(shadingNormal, mainLightDirection), 0.0, 1.0);
 return mainLightIntensity * ((1.0 - shadow) * dotVal);
-}`)}export{i as applyShading,n as mainLightDirection,r as mainLightIntensity};
+}`)}export{r as applyShading};

package/views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js

@@ -1,35 +1,35 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{markerSizePerLineWidth as e}from"../../../../support/engineContent/marker.js";import{nearFar as t,metersPerRenderUnit as n,screenPixelSizePerDistance as r,renderPixelSizePerDistance as i}from"../util/cameraUniforms.js";import{addPixelRatio as a}from"../util/View.glsl.js";import{FloatBindUniform as o}from"../../shaderModules/FloatBindUniform.js";import{FloatPassUniform as s}from"../../shaderModules/FloatPassUniform.js";import{glsl as c,If as l}from"../../shaderModules/glsl.js";import{NoParameters as u}from"../../../../../webgl/NoParameters.js";class d extends u{constructor(){super(...arguments),this.markerScale=1}}function f(u,d){let f=u.vertex,p=d.hasScreenSizePerspective,m=d.worldSized,h=m&&!d.draped;a(f),f.constants.add(`markerSizePerLineWidth`,`float`,e),f.uniforms.add(new s(`markerScale`,({markerScale:e})=>e)),m&&f.uniforms.add(new o(`groundMetersToScreenRatio`,e=>1/(e.screenToPlanarDistanceRatio*e.planarDistanceToGroundRatio))),f.code.add(c`float getScreenMarkerSize(float lineWidth) {
+import{markerSizePerLineWidth as e}from"../../../../support/engineContent/marker.js";import{pixelRatio as t,nearFar as n,metersPerRenderUnit as r,screenPixelSizePerDistance as i,renderPixelSizePerDistance as a}from"../util/cameraUniforms.js";import{FloatPassUniform as o}from"../../shaderModules/FloatPassUniform.js";import{glsl as s,If as c}from"../../shaderModules/glsl.js";import{groundMetersToScreenRatio as l}from"../../../shaders/lineUniforms.js";import{NoParameters as u}from"../../../../../webgl/NoParameters.js";class d extends u{constructor(){super(...arguments),this.markerScale=1}}function f(u,d){let f=u.vertex,p=d.hasScreenSizePerspective,m=d.worldSized,h=m&&!d.draped;f.constants.add(`markerSizePerLineWidth`,`float`,e),f.uniforms.add(t,new o(`markerScale`,({markerScale:e})=>e)),m&&f.uniforms.add(l),f.code.add(s`float getScreenMarkerSize(float lineWidth) {
 return markerScale * markerSizePerLineWidth * lineWidth;
-}`),f.code.add(l(h,c`
+}`),f.code.add(c(h,s`
         float getLineWidth(vec3 pos) {
-          float size = getSize(${l(p,`pos`)});
+          float size = getSize(${c(p,`pos`)});
           float metersPerScreenPixel = max(-pos.z, nearFar[0]) * metersPerRenderUnit * screenPixelSizePerDistance;
           return max(size / metersPerScreenPixel, 1.0) * pixelRatio;
         }
-    `,c`
-        float getLineWidth(${l(d.lineWidthRequiresPosition,`vec3 pos`)}) {
-          float size = max(getSize(${l(p,`pos`)}), 1.0);
-          return ${l(m,`size * pixelRatio * groundMetersToScreenRatio`,`size * pixelRatio`)};
+    `,s`
+        float getLineWidth(${c(d.lineWidthRequiresPosition,`vec3 pos`)}) {
+          float size = max(getSize(${c(p,`pos`)}), 1.0);
+          return ${c(m,`size * pixelRatio * groundMetersToScreenRatio`,`size * pixelRatio`)};
         }
-    `)),h?f.uniforms.add(t,n,r):f.uniforms.add(i),f.code.add(l(h,c`
+    `)),h?f.uniforms.add(n,r,i):f.uniforms.add(a),f.code.add(c(h,s`
         float getWorldMarkerSize(vec3 pos) {
-          return markerScale * markerSizePerLineWidth * getSize(${l(p,`pos`)}) * 0.5 / metersPerRenderUnit;
+          return markerScale * markerSizePerLineWidth * getSize(${c(p,`pos`)}) * 0.5 / metersPerRenderUnit;
         }
-      `,c`
+      `,s`
         float getWorldMarkerSize(vec3 pos) {
           float distanceToCamera = length(pos);
           float screenToWorldRatio = renderPixelSizePerDistance * distanceToCamera * 0.5;
-          return getScreenMarkerSize(getLineWidth(${l(p,`pos`)})) * screenToWorldRatio;
+          return getScreenMarkerSize(getLineWidth(${c(p,`pos`)})) * screenToWorldRatio;
         }
-      `)),f.constants.add(`maxSegmentLengthFraction`,`float`,.45),f.code.add(l(h,c`bool areWorldMarkersHidden(vec3 pos, vec3 other) {
+      `)),f.constants.add(`maxSegmentLengthFraction`,`float`,.45),f.code.add(c(h,s`bool areWorldMarkersHidden(vec3 pos, vec3 other) {
 return getWorldMarkerSize(pos) > maxSegmentLengthFraction * length(pos - other);
-}`,c`
+}`,s`
         bool areWorldMarkersHidden(vec3 pos, vec3 other) {
           vec3 midPoint = mix(pos, other, 0.5);
           float distanceToCamera = length(midPoint);
           float screenToWorldRatio = renderPixelSizePerDistance * distanceToCamera * 0.5;
-          float worldMarkerSize = getScreenMarkerSize(getLineWidth(${l(p,`pos`)})) * screenToWorldRatio;
+          float worldMarkerSize = getScreenMarkerSize(getLineWidth(${c(p,`pos`)})) * screenToWorldRatio;
           float segmentLen = length(pos - other);
           return worldMarkerSize > maxSegmentLengthFraction * segmentLen;
         }

package/views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{glsl as e}from"../../shaderModules/glsl.js";function t(t,{spherical:n}){t.code.add(`vec3 normalize4(vec4 vector){ return normalize(vector.xyz / vector.w); }`),t.code.add(n?`vec3 getLocalUp(in vec3 pos, in vec3 origin) { return normalize(pos + origin); }
+import{glsl as e}from"../../shaderModules/glsl.js";function t(t,{spherical:n}){t.code.add(n?`vec3 getLocalUp(in vec3 pos, in vec3 origin) { return normalize(pos + origin); }
          vec3 getLocalUp(in vec3 pos) { return normalize(pos); }`:`vec3 getLocalUp(in vec3 pos, in vec3 origin) { return vec3(0.0, 0.0, 1.0); }
          vec3 getLocalUp(in vec3 pos) { return vec3(0.0, 0.0, 1.0); }`),n?t.code.add(e`mat3 getTBNMatrix(in vec3 n) {
 vec3 t = normalize(cross(vec3(0.0, 0.0, 1.0), n));

package/views/3d/webgl-engine/core/shaderLibrary/shading/ReadGlobalIllumination.glsl.js

@@ -1,24 +1,29 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{BooleanBindUniform as e}from"../../shaderModules/BooleanBindUniform.js";import{glsl as t}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as n}from"../../shaderModules/Texture2DBindUniform.js";import{blurSizePixels as r}from"../../../effects/globalIllumination/GlobalIllumination.js";function i(i,a){a.receiveGlobalIllumination?(i.uniforms.add(new e(`hasGlobalIlluminationTexture`,e=>e.globalIllumination!=null),new n(`globalIlluminationTexture`,e=>e.globalIllumination?.getTexture())),i.constants.add(`blurSizePixelsInverse`,`float`,1/r),i.code.add(t`vec3 readGlobalIlluminationOcclusionInverse() {
+import{BooleanBindUniform as e}from"../../shaderModules/BooleanBindUniform.js";import{glsl as t}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as n}from"../../shaderModules/Texture2DBindUniform.js";function r(r,i){i.receiveGlobalIllumination?(r.uniforms.add(new e(`hasGlobalIlluminationTexture`,e=>e.globalIllumination!=null),new n(`globalIlluminationTexture`,e=>e.globalIllumination?.getTexture())),r.constants.add(`globalIlluminationEmissionNoiseThreshold`,`float`,.01),r.code.add(t`vec3 readGlobalIlluminationOcclusionInverse() {
 if (!hasGlobalIlluminationTexture) {
 return vec3(1.0);
 }
-ivec2 texel = ivec2(gl_FragCoord.xy * blurSizePixelsInverse);
+ivec2 texel = ivec2(gl_FragCoord.xy);
 return vec3(texelFetch(globalIlluminationTexture, texel, 0).a);
 }
 vec3 readGlobalIlluminationOcclusion() {
 return 1.0 - readGlobalIlluminationOcclusionInverse();
 }
-vec4 readGlobalIlluminationEmissionInverse() {
-if (!hasGlobalIlluminationTexture) {
-return vec4(1.0);
+vec3 suppressBlackNoise(vec3 color) {
+float peak = max(color.r, max(color.g, color.b));
+if (peak <= globalIlluminationEmissionNoiseThreshold) {
+return vec3(0.0);
 }
-ivec2 texel = ivec2(gl_FragCoord.xy * blurSizePixelsInverse);
-return 1.0 - vec4(texelFetch(globalIlluminationTexture, texel, 0).rgb, 0.0);
+float correctedPeak = (peak - globalIlluminationEmissionNoiseThreshold) / (1.0 - globalIlluminationEmissionNoiseThreshold);
+return color * (correctedPeak / peak);
 }
 vec4 readGlobalIlluminationEmission() {
-return max((1.0 - readGlobalIlluminationEmissionInverse() - 0.01) / 0.99, 0.0);
-}`)):i.code.add(t`vec3 readGlobalIlluminationOcclusionInverse() { return vec3(1.0); }
+if (!hasGlobalIlluminationTexture) {
+return vec4(0.0);
+}
+ivec2 texel = ivec2(gl_FragCoord.xy);
+vec3 color = texelFetch(globalIlluminationTexture, texel, 0).rgb;
+return vec4(suppressBlackNoise(color), 0.0);
+}`)):r.code.add(t`vec3 readGlobalIlluminationOcclusionInverse() { return vec3(1.0); }
 vec3 readGlobalIlluminationOcclusion() { return vec3(0.0); }
-vec4 readGlobalIlluminationEmissionInverse() { return vec4(1.0); }
-vec4 readGlobalIlluminationEmission() { return vec4(0.0); }`)}export{i as ReadGlobalIllumination};
+vec4 readGlobalIlluminationEmission() { return vec4(0.0); }`)}export{r as ReadGlobalIllumination};

package/views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceRayMarching.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{projMatrix as t,nearFar as n}from"../util/cameraUniforms.js";import{FloatBindUniform as r}from"../../shaderModules/FloatBindUniform.js";import{If as i,glsl as a}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as o}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as s}from"../../shaderModules/Texture2DBindUniform.js";function c(c,l){let u=c.fragment;u.include(e),u.uniforms.add(t,n,new s(`depthMap`,e=>e.depth?.attachment),new r(`invResolutionHeight`,e=>1/e.camera.height),new o(`reprojectionMatrix`,e=>e.reprojection.matrix)).code.add(a`
+import{depthMap as e}from"../bindUniforms.js";import{ReadDepth as t}from"../output/ReadDepth.glsl.js";import{projMatrix as n,nearFar as r}from"../util/cameraUniforms.js";import{FloatBindUniform as i}from"../../shaderModules/FloatBindUniform.js";import{If as a,glsl as o}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as s}from"../../shaderModules/Matrix4BindUniform.js";function c(c,l){let u=c.fragment;u.include(t),u.uniforms.add(n,r,e,new i(`invResolutionHeight`,e=>1/e.camera.height),new s(`reprojectionMatrix`,e=>e.reprojection.matrix)).code.add(o`
   vec2 reprojectionCoordinate(vec3 projectionCoordinate) {
     vec4 clipDepthCoordinate = proj * vec4(0.0, 0.0, -projectionCoordinate.z, 1.0);
     vec4 reprojectedCoordinate = reprojectionMatrix * vec4(
@@ -154,7 +154,7 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{projMatrix as t,n
         }
       }
 
-      ${i(!l.clampRayToScreen,`if (projectedPosition.x <= 0.0  || projectedPosition.x >= 1.0) {
+      ${a(!l.clampRayToScreen,`if (projectedPosition.x <= 0.0  || projectedPosition.x >= 1.0) {
         return firstSegmentHit;
       }`)}
 
@@ -164,7 +164,7 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{projMatrix as t,n
       inverseW += inverseWStep;
       previousEstimatedDepthDifference = estimatedDepthDifference;
 
-      ${i(l.clampRayToScreen,`projectedPosition = clamp(projectedPosition, vec2(0.0), vec2(0.999));`)}
+      ${a(l.clampRayToScreen,`projectedPosition = clamp(projectedPosition, vec2(0.0), vec2(0.999));`)}
     }
     return firstSegmentHit;
   }
@@ -176,8 +176,8 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{projMatrix as t,n
       viewDirection,
       normal,
       rayStepOffset,
-      ${a.float(l.rayMarchMaxReach)},
-      ${a.float(l.rayMarchMaxSteps)}
+      ${o.float(l.rayMarchMaxReach)},
+      ${o.float(l.rayMarchMaxSteps)}
     );
   }
   `)}export{c as ScreenSpaceRayMarching};

package/views/3d/webgl-engine/core/shaderLibrary/shading/WaterColor.glsl.js

@@ -1,9 +1,9 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{FoamColor as e}from"./FoamRendering.glsl.js";import{Gamma as t}from"./Gamma.glsl.js";import{PhysicallyBasedRenderingWater as n}from"./PhysicallyBasedRendering.glsl.js";import{distanceFadeStart as r,distanceFadeEnd as i}from"./ScreenSpaceConstants.js";import{ScreenSpaceRayMarching as a}from"./ScreenSpaceRayMarching.glsl.js";import{viewMatrix as o}from"../util/cameraUniforms.js";import{CloudsParallaxShading as s}from"../util/CloudsParallaxShading.glsl.js";import{FloatBindUniform as c}from"../../shaderModules/FloatBindUniform.js";import{glsl as l}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as u}from"../../shaderModules/Texture2DBindUniform.js";import{ToneMapping as d}from"../../../shaders/ToneMapping.glsl.js";function f(f,p){let m=f.fragment;m.include(n,p),m.include(t),m.include(e),p.cloudReflections&&f.include(s,p),p.screenSpaceReflections&&f.include(a,p),m.include(d,p),m.constants.add(`fresnelSky`,`vec3`,[.02,1,15]),m.constants.add(`fresnelMaterial`,`vec2`,[.02,.1]),m.constants.add(`roughness`,`float`,.015),m.constants.add(`foamIntensityExternal`,`float`,1.7),m.constants.add(`ssrIntensity`,`float`,.65),m.constants.add(`ssrHeightFadeStart`,`float`,r),m.constants.add(`ssrHeightFadeEnd`,`float`,i),m.constants.add(`waterDiffusion`,`float`,.92),m.constants.add(`waterSeaColorMod`,`float`,.8),m.constants.add(`correctionViewingPowerFactor`,`float`,.4),m.constants.add(`skyZenitColor`,`vec3`,[.52,.68,.9]),m.constants.add(`skyColor`,`vec3`,[.67,.79,.9]),m.constants.add(`cloudFresnelModifier`,`vec2`,[1.2,.01]),m.code.add(l`PBRShadingWater shadingInfo;
+import{lastFrameColorTexture as e}from"../lastFrameUniforms.js";import{FoamColor as t}from"./FoamRendering.glsl.js";import{Gamma as n}from"./Gamma.glsl.js";import{lightingSpecularStrength as r,lightingEnvironmentStrength as i}from"./lightingUniforms.js";import{PhysicallyBasedRenderingWater as a}from"./PhysicallyBasedRendering.glsl.js";import{distanceFadeStart as o,distanceFadeEnd as s}from"./ScreenSpaceConstants.js";import{ScreenSpaceRayMarching as c}from"./ScreenSpaceRayMarching.glsl.js";import{viewMatrix as l}from"../util/cameraUniforms.js";import{CloudsParallaxShading as u,cloudsOpacity as d}from"../util/CloudsParallaxShading.glsl.js";import{FloatBindUniform as f}from"../../shaderModules/FloatBindUniform.js";import{glsl as p}from"../../shaderModules/glsl.js";import{ToneMapping as m}from"../../../shaders/ToneMapping.glsl.js";function h(h,g){let _=h.fragment;_.include(a,g),_.include(n),_.include(t),g.cloudReflections&&h.include(u,g),g.screenSpaceReflections&&h.include(c,g),_.include(m,g),_.constants.add(`fresnelSky`,`vec3`,[.02,1,15]),_.constants.add(`fresnelMaterial`,`vec2`,[.02,.1]),_.constants.add(`roughness`,`float`,.015),_.constants.add(`foamIntensityExternal`,`float`,1.7),_.constants.add(`ssrIntensity`,`float`,.65),_.constants.add(`ssrHeightFadeStart`,`float`,o),_.constants.add(`ssrHeightFadeEnd`,`float`,s),_.constants.add(`waterDiffusion`,`float`,.92),_.constants.add(`waterSeaColorMod`,`float`,.8),_.constants.add(`correctionViewingPowerFactor`,`float`,.4),_.constants.add(`skyZenitColor`,`vec3`,[.52,.68,.9]),_.constants.add(`skyColor`,`vec3`,[.67,.79,.9]),_.constants.add(`cloudFresnelModifier`,`vec2`,[1.2,.01]),_.code.add(p`PBRShadingWater shadingInfo;
 vec3 getSkyGradientColor(in float cosTheta, in vec3 horizon, in vec3 zenit) {
 float exponent = pow((1.0 - cosTheta), fresnelSky[2]);
 return mix(zenit, horizon, exponent);
-}`),m.uniforms.add(new c(`lightingSpecularStrength`,e=>e.lighting.mainLight.specularStrength),new c(`lightingEnvironmentStrength`,e=>e.lighting.mainLight.environmentStrength)),m.code.add(l`vec3 getWaterColor(in vec3 n, in vec3 v, in vec3 l, vec3 color, in vec3 lightIntensity, in vec3 localUp, in float shadow, float foamIntensity, vec3 viewPosition, vec3 position) {
+}`),_.uniforms.add(r,i).code.add(p`vec3 getWaterColor(in vec3 n, in vec3 v, in vec3 l, vec3 color, in vec3 lightIntensity, in vec3 localUp, in float shadow, float foamIntensity, vec3 viewPosition, vec3 position) {
 float reflectionHit = 0.0;
 float reflectionHitDiffused = 0.0;
 vec3 seaWaterColor = linearizeGamma(color);
@@ -37,10 +37,10 @@ foam = foamIntensity2FoamColor(foamIntensityExternal, foamIntensity, skyZenitCol
 }
 float correctionViewingFactor = pow(max(dot(v, localUp), 0.0), correctionViewingPowerFactor);
 vec3 normalCorrectedClouds = mix(localUp, n, correctionViewingFactor);
-vec3 reflectedWorld = normalize(reflect(-v, normalCorrectedClouds));`),p.cloudReflections&&m.uniforms.add(new c(`cloudsOpacity`,e=>e.clouds.opacity)).code.add(l`vec4 cloudsColor = renderClouds(reflectedWorld, position);
+vec3 reflectedWorld = normalize(reflect(-v, normalCorrectedClouds));`),g.cloudReflections&&_.uniforms.add(d).code.add(p`vec4 cloudsColor = renderClouds(reflectedWorld, position);
 cloudsColor.a = 1.0 - cloudsColor.a;
 cloudsColor = pow(cloudsColor, vec4(GAMMA));
-cloudsColor *= clamp(fresnelModifier.y * cloudFresnelModifier[0] - cloudFresnelModifier[1], 0.0, 1.0) * cloudsOpacity;`),p.screenSpaceReflections?m.uniforms.add(o,new u(`lastFrameColorTexture`,e=>e.reprojection.lastFrameColor?.getTexture()),new c(`fadeFactorSSR`,e=>e.screenSpaceReflections.fadeFactor)).code.add(l`vec3 viewDir = normalize(viewPosition);
+cloudsColor *= clamp(fresnelModifier.y * cloudFresnelModifier[0] - cloudFresnelModifier[1], 0.0, 1.0) * cloudsOpacity;`),g.screenSpaceReflections?_.uniforms.add(l,e,new f(`fadeFactorSSR`,e=>e.screenSpaceReflections.fadeFactor)).code.add(p`vec3 viewDir = normalize(viewPosition);
 vec4 viewNormalVectorCoordinate = view * vec4(n, 0.0);
 vec3 viewNormal = normalize(viewNormalVectorCoordinate.xyz);
 vec4 viewUp = view * vec4(localUp, 0.0);
@@ -60,7 +60,7 @@ reflectionHitDiffused * fresnelModifier.y * ssrIntensity;
 }
 float seaColorMod =  mix(waterSeaColorMod, waterSeaColorMod * 0.5, reflectionHitDiffused);
 vec3 waterRenderedColor = tonemapACES((1.0 - reflectionHitDiffused) * reflSky + reflectedColor +
-reflSea * seaColorMod + specular + foam);`):m.code.add(l`vec3 waterRenderedColor = tonemapACES(reflSky + reflSea * waterSeaColorMod + specular + foam);`),p.cloudReflections?p.screenSpaceReflections?m.code.add(l`return waterRenderedColor * (1.0 - (1.0 - reflectionHit) * cloudsColor.a) + (1.0 - reflectionHit) * cloudsColor.xyz;
-}`):m.code.add(l`return waterRenderedColor * (1.0 - cloudsColor.a) + cloudsColor.xyz;
-}`):m.code.add(l`return waterRenderedColor;
-}`)}export{f as WaterColor};
+reflSea * seaColorMod + specular + foam);`):_.code.add(p`vec3 waterRenderedColor = tonemapACES(reflSky + reflSea * waterSeaColorMod + specular + foam);`),g.cloudReflections?g.screenSpaceReflections?_.code.add(p`return waterRenderedColor * (1.0 - (1.0 - reflectionHit) * cloudsColor.a) + (1.0 - reflectionHit) * cloudsColor.xyz;
+}`):_.code.add(p`return waterRenderedColor * (1.0 - cloudsColor.a) + cloudsColor.xyz;
+}`):_.code.add(p`return waterRenderedColor;
+}`)}export{h as WaterColor};

package/views/3d/webgl-engine/core/shaderLibrary/shading/evaluateSceneLightingFragment.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{EvaluateAmbientOcclusion as e}from"./EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as n,lightingGlobalFactor as r}from"./EvaluateSceneLighting.glsl.js";import{mainLightIntensity as i}from"./MainLighting.glsl.js";import{readFragmentShadow as a}from"./readFragmentShadow.glsl.js";import{addCameraPosition as o}from"../util/View.glsl.js";import{glsl as s}from"../../shaderModules/glsl.js";function c(c,l){let{vertex:u,fragment:d}=c;c.include(a,l),d.include(t,l),d.include(e,l),n(d),o(d,l),u.main.add(`forwardLinearDepthToReadShadow();`),d.uniforms.add(i,r,u.uniforms.get(`localOrigin`)).code.add(s`vec4 evaluateSceneLightingFragment(vec3 vpos, vec3 normal, vec4 albedo) {
+import{EvaluateAmbientOcclusion as e}from"./EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as n}from"./EvaluateSceneLighting.glsl.js";import{mainLightIntensity as r,lightingGlobalFactor as i}from"./lightingUniforms.js";import{readFragmentShadow as a}from"./readFragmentShadow.glsl.js";import{addCameraPosition as o}from"../util/View.glsl.js";import{glsl as s}from"../../shaderModules/glsl.js";function c(c,l){let{vertex:u,fragment:d}=c;c.include(a,l),d.include(t,l),d.include(e,l),n(d),o(d,l),u.main.add(`forwardLinearDepthToReadShadow();`),d.uniforms.add(r,i,u.uniforms.get(`localOrigin`)).code.add(s`vec4 evaluateSceneLightingFragment(vec3 vpos, vec3 normal, vec4 albedo) {
 vec3 posWorld = vpos + localOrigin;
 float additionalAmbientScale = additionalDirectedAmbientLight(posWorld);
 float shadow = readFragmentShadow(additionalAmbientScale);

package/views/3d/webgl-engine/core/shaderLibrary/shading/lightingUniforms.js

@@ -0,0 +1,2 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import{Float3BindUniform as e}from"../../shaderModules/Float3BindUniform.js";import{FloatBindUniform as t}from"../../shaderModules/FloatBindUniform.js";const n=new e(`mainLightDirection`,e=>e.lighting.mainLight.direction),r=new e(`mainLightIntensity`,e=>e.lighting.mainLight.intensity),i=new t(`lightingGlobalFactor`,e=>e.lighting.globalFactor),a=new t(`lightingSpecularStrength`,e=>e.lighting.mainLight.specularStrength),o=new t(`lightingEnvironmentStrength`,e=>e.lighting.mainLight.environmentStrength);export{o as lightingEnvironmentStrength,i as lightingGlobalFactor,a as lightingSpecularStrength,n as mainLightDirection,r as mainLightIntensity};

package/views/3d/webgl-engine/core/shaderLibrary/shading/pbrGlobals.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{Gamma as e}from"./Gamma.glsl.js";import{mainLightDirection as t}from"./MainLighting.glsl.js";import{pbrShadingInfo as n}from"./pbrShadingInfo.glsl.js";import{glsl as r}from"../../shaderModules/glsl.js";function i(i){i.include(n),i.include(e),i.uniforms.add(t).code.add(r`void calculateCommonInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
+import{Gamma as e}from"./Gamma.glsl.js";import{mainLightDirection as t}from"./lightingUniforms.js";import{pbrShadingInfo as n}from"./pbrShadingInfo.glsl.js";import{glsl as r}from"../../shaderModules/glsl.js";function i(i){i.include(n),i.include(e),i.uniforms.add(t).code.add(r`void calculateCommonInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
 vec3 h = normalize(mainLightDirection - viewDirection);
 inputs.NdotV = clamp(abs(dot(normal, -viewDirection)), 0.001, 1.0);
 inputs.NdotUP = clamp(dot(normal, upDirection), -1.0, 1.0);

package/views/3d/webgl-engine/core/shaderLibrary/shading/readShadow.glsl.js

@@ -1,25 +1,25 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{__decorate as e}from"tslib";import{ForwardLinearDepthConfiguration as t}from"../ForwardLinearDepth.glsl.js";import{forwardLinearDepthToReadShadow as n}from"../forwardLinearDepthToReadShadow.glsl.js";import{calculateUVZShadowPass as r,calculateUVZShadowDraw as i,ReadShadowMapOrigin as a}from"./calculateUVZShadow.glsl.js";import{FloatBindUniform as o}from"../../shaderModules/FloatBindUniform.js";import{glsl as s,If as c}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as l}from"../../shaderModules/Texture2DBindUniform.js";import{Texture2DShadowBindUniform as u}from"../../shaderModules/Texture2DShadowBindUniform.js";import{parameter as d}from"../../shaderTechnique/ShaderTechniqueConfiguration.js";class f extends a{}class p extends a{}class m extends t{constructor(){super(...arguments),this.hasShadowHighlights=!1,this.receiveShadows=!0}}e([d()],m.prototype,`hasShadowHighlights`,void 0),e([d()],m.prototype,`receiveShadows`,void 0);function h(e,t){t.receiveShadows&&e.fragment.include(r),_(e,t)}function g(e,t){t.receiveShadows&&e.fragment.include(i),_(e,t)}function _(e,t){e.include(n,t);let{hasShadowHighlights:r,receiveShadows:i,spherical:a}=t;i&&(v(e.fragment,r),e.fragment.code.add(s`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
+import{__decorate as e}from"tslib";import{shadowHighlight as t}from"../bindUniforms.js";import{ForwardLinearDepthConfiguration as n}from"../ForwardLinearDepth.glsl.js";import{forwardLinearDepthToReadShadow as r}from"../forwardLinearDepthToReadShadow.glsl.js";import{calculateUVZShadowPass as i,calculateUVZShadowDraw as a,ReadShadowMapOrigin as o}from"./calculateUVZShadow.glsl.js";import{lightingGlobalFactor as s}from"./lightingUniforms.js";import{glsl as c,If as l}from"../../shaderModules/glsl.js";import{Texture2DShadowBindUniform as u}from"../../shaderModules/Texture2DShadowBindUniform.js";import{parameter as d}from"../../shaderTechnique/ShaderTechniqueConfiguration.js";class f extends o{}class p extends o{}class m extends n{constructor(){super(...arguments),this.hasShadowHighlights=!1,this.receiveShadows=!0}}e([d()],m.prototype,`hasShadowHighlights`,void 0),e([d()],m.prototype,`receiveShadows`,void 0);function h(e,t){t.receiveShadows&&e.fragment.include(i),_(e,t)}function g(e,t){t.receiveShadows&&e.fragment.include(a),_(e,t)}function _(e,t){e.include(r,t);let{hasShadowHighlights:n,receiveShadows:i,spherical:a}=t;i&&(v(e.fragment,n),e.fragment.code.add(c`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
 vec3 uvzShadow = calculateUVZShadow(_worldPos, _linearDepth, textureSize(shadowMap, 0));
 return readShadowMaps(uvzShadow);
 }
-float readShadowMap(const in vec3 _worldPos ) { return readShadowMap(_worldPos, linearDepth); }`)),e.fragment.uniforms.add(new o(`lightingGlobalFactor`,({lighting:e})=>e.globalFactor)).code.add(s`
+float readShadowMap(const in vec3 _worldPos ) { return readShadowMap(_worldPos, linearDepth); }`)),e.fragment.uniforms.add(s).code.add(c`
       float getShadow(float additionalAmbientScale, float shadow) {
-        float ambient = ${c(a,`lightingGlobalFactor * (1.0 - additionalAmbientScale)`,`0.0`)};
+        float ambient = ${l(a,`lightingGlobalFactor * (1.0 - additionalAmbientScale)`,`0.0`)};
         return max(ambient, shadow);
       }
 
       float readShadow(float additionalAmbientScale, vec3 vpos) {
-        return getShadow(additionalAmbientScale, ${c(i,`readShadowMap(vpos)`,`0.0`)});
+        return getShadow(additionalAmbientScale, ${l(i,`readShadowMap(vpos)`,`0.0`)});
       }
-    `)}function v(e,t,n=`gl_FragCoord.xy`){t&&e.uniforms.add(new l(`shadowHighlight`,({shadowHighlight:e})=>e?.getTexture())),e.uniforms.add(new u(`shadowMap`,({shadowMap:e})=>e.getOutput(5)??e.getOutput(7))).code.add(s`
+    `)}function v(e,n,r=`gl_FragCoord.xy`){n&&e.uniforms.add(t),e.uniforms.add(new u(`shadowMap`,({shadowMap:e})=>e.getOutput(5)??e.getOutput(7))).code.add(c`
     float readShadowMaps(const in vec3 uvzShadow) {
       if (uvzShadow.z < 0.0) {
         return 0.0;
       }
 
       float shadow1 = texture(shadowMap, uvzShadow);
-      ${c(t,`float shadow2 = texelFetch(shadowHighlight, ivec2(${n}), 0).r;
+      ${l(n,`float shadow2 = texelFetch(shadowHighlight, ivec2(${r}), 0).r;
          return shadow1 > shadow2 ? shadow1 : shadow2;`,`return shadow1;`)}
     }
   `)}export{m as ReadShadowMapConfiguration,f as ReadShadowMapDrawParameters,p as ReadShadowMapPassParameters,g as readShadowDraw,v as readShadowMaps,h as readShadowPass};

package/views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";import{hasArea as t,width as n,height as r}from"../../../../../../geometry/support/aaBoundingRect.js";import{isColor as i}from"../ShaderOutput.js";import{mainLightDirection as a,mainLightIntensity as o}from"../shading/MainLighting.glsl.js";import{WaterColor as s}from"../shading/WaterColor.glsl.js";import{BlendColorsPremultiplied as c}from"../util/BlendColorsPremultiplied.glsl.js";import{Float4DrawUniform as l}from"../../shaderModules/Float4DrawUniform.js";import{FloatPassUniform as u}from"../../shaderModules/FloatPassUniform.js";import{glsl as d}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as f}from"../../shaderModules/Texture2DPassUniform.js";import{Texture2DUintPassUniform as p}from"../../shaderModules/Texture2DUintPassUniform.js";import{Uniform as m}from"../../../../../webgl/Uniform.js";function h(e,t){let{vertex:n,fragment:r}=e;n.uniforms.add(new l(`overlayTexOffset`,(e,n)=>C(t.spherical,e,n)),new l(`overlayTexScale`,(e,n)=>w(t.spherical,e,n))),r.uniforms.add(new l(`overlayTexOffset`,(e,n)=>C(t.spherical,e,n)),new l(`overlayTexScale`,(e,n)=>w(t.spherical,e,n))),r.constants.add(`overlayOpacity`,`float`,1),r.uniforms.add(new f(`ovColorTex`,(e,n)=>g(e,n,t.isGround===!0))),x(e,t)}function g(e,t,n){let r=_(e,t,n);return r==null?null:t.overlay?.getTexture(r)}function _(e,t,n){return e.identifier===0?i(t.output)?!e.occludedGround||t.overlay?.allSourcesOccluders?v(n):4:t.output===3||t.output===4?v(n):t.output===11?5:null:e.identifier===2?2:null}function v(e){return+!e}function y(e,t){let{vertex:n,fragment:r}=e;n.uniforms.add(new E(`overlayTexOffset`),new E(`overlayTexScale`)),r.uniforms.add(new u(`overlayOpacity`,e=>e.overlayOpacity)),t.output!==10&&r.uniforms.add(new f(`ovColorTex`,(e,t)=>t.overlay?.getTexture(e.overlayContent))),x(e,t)}function b(e,t){switch(e){case 0:case 1:case 2:return t.slot===9&&!t.overlay?.allSourcesOccluders?4:0;case 3:case 4:return 0;case 10:return 2;case 5:case 7:case 8:case 9:return null;case 11:return 5}return null}function x(e,t){let{hasWater:n,output:r}=t;n&&e.include(s,t);let{vertex:i,fragment:l,varyings:u}=e;u.add(`vtcOverlay`,`vec4`);let f=r===10;i.code.add(d`void setOverlayVTC(in vec2 uv) {
+import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";import{hasArea as t,width as n,height as r}from"../../../../../../geometry/support/aaBoundingRect.js";import{isColor as i}from"../ShaderOutput.js";import{mainLightDirection as a,mainLightIntensity as o}from"../shading/lightingUniforms.js";import{WaterColor as s}from"../shading/WaterColor.glsl.js";import{BlendColorsPremultiplied as c}from"../util/BlendColorsPremultiplied.glsl.js";import{Float4DrawUniform as l}from"../../shaderModules/Float4DrawUniform.js";import{FloatPassUniform as u}from"../../shaderModules/FloatPassUniform.js";import{glsl as d}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as f}from"../../shaderModules/Texture2DPassUniform.js";import{Texture2DUintPassUniform as p}from"../../shaderModules/Texture2DUintPassUniform.js";import{Uniform as m}from"../../../../../webgl/Uniform.js";function h(e,t){let{vertex:n,fragment:r}=e;n.uniforms.add(new l(`overlayTexOffset`,(e,n)=>C(t.spherical,e,n)),new l(`overlayTexScale`,(e,n)=>w(t.spherical,e,n))),r.uniforms.add(new l(`overlayTexOffset`,(e,n)=>C(t.spherical,e,n)),new l(`overlayTexScale`,(e,n)=>w(t.spherical,e,n))),r.constants.add(`overlayOpacity`,`float`,1),r.uniforms.add(new f(`ovColorTex`,(e,n)=>g(e,n,t.isGround===!0))),x(e,t)}function g(e,t,n){let r=_(e,t,n);return r==null?null:t.overlay?.getTexture(r)}function _(e,t,n){return e.identifier===0?i(t.output)?!e.occludedGround||t.overlay?.allSourcesOccluders?v(n):4:t.output===3||t.output===4?v(n):t.output===11?5:null:e.identifier===2?2:null}function v(e){return+!e}function y(e,t){let{vertex:n,fragment:r}=e;n.uniforms.add(new E(`overlayTexOffset`),new E(`overlayTexScale`)),r.uniforms.add(new u(`overlayOpacity`,e=>e.overlayOpacity)),t.output!==10&&r.uniforms.add(new f(`ovColorTex`,(e,t)=>t.overlay?.getTexture(e.overlayContent))),x(e,t)}function b(e,t){switch(e){case 0:case 1:case 2:return t.slot===9&&!t.overlay?.allSourcesOccluders?4:0;case 3:case 4:return 0;case 10:return 2;case 5:case 7:case 8:case 9:return null;case 11:return 5}return null}function x(e,t){let{hasWater:n,output:r}=t;n&&e.include(s,t);let{vertex:i,fragment:l,varyings:u}=e;u.add(`vtcOverlay`,`vec4`);let f=r===10;i.code.add(d`void setOverlayVTC(in vec2 uv) {
 vtcOverlay = vec4(uv, uv) * overlayTexScale + overlayTexOffset;
 }`),l.code.add(d`bool isValid(vec2 uv, vec2 dxdy) {
 return (uv.x >= 0.0 + dxdy.x) && (uv.x <= 1.0 - dxdy.x) && (uv.y >= 0.0 + dxdy.y) && (uv.y <= 1.0 - dxdy.y);

package/views/3d/webgl-engine/core/shaderLibrary/util/CloudsParallaxShading.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{fromValues as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{earth as t}from"../../../../../../geometry/support/Ellipsoid.js";import{cloudsHeight as n}from"../../../../environment/weather.js";import{EvaluateAmbientLighting as r}from"../shading/EvaluateAmbientLighting.glsl.js";import{mainLightDirection as i,mainLightIntensity as a}from"../shading/MainLighting.glsl.js";import{LookupCloudsFromTextureArray as o}from"./LookupCloudsFromTextureArray.glsl.js";import{BooleanBindUniform as s}from"../../shaderModules/BooleanBindUniform.js";import{Float3BindUniform as c}from"../../shaderModules/Float3BindUniform.js";import{FloatBindUniform as l}from"../../shaderModules/FloatBindUniform.js";import{glsl as u}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as d}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DArrayBindUniform as f}from"../../shaderModules/Texture2DArrayBindUniform.js";function p(t,n){let p=t.fragment;p.constants.add(`radiusCloudsSquared`,`float`,m).code.add(u`vec3 intersectWithCloudLayer(vec3 dir, vec3 cameraPosition, vec3 spherePos) {
+import{fromValues as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{earth as t}from"../../../../../../geometry/support/Ellipsoid.js";import{cloudsHeight as n}from"../../../../environment/weather.js";import{EvaluateAmbientLighting as r}from"../shading/EvaluateAmbientLighting.glsl.js";import{mainLightDirection as i,mainLightIntensity as a}from"../shading/lightingUniforms.js";import{LookupCloudsFromTextureArray as o}from"./LookupCloudsFromTextureArray.glsl.js";import{BooleanBindUniform as s}from"../../shaderModules/BooleanBindUniform.js";import{Float3BindUniform as c}from"../../shaderModules/Float3BindUniform.js";import{FloatBindUniform as l}from"../../shaderModules/FloatBindUniform.js";import{glsl as u}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as d}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DArrayBindUniform as f}from"../../shaderModules/Texture2DArrayBindUniform.js";function p(t,n){let p=t.fragment;p.constants.add(`radiusCloudsSquared`,`float`,m).code.add(u`vec3 intersectWithCloudLayer(vec3 dir, vec3 cameraPosition, vec3 spherePos) {
 float B = 2.0 * dot(cameraPosition, dir);
 float C = dot(cameraPosition, cameraPosition) - radiusCloudsSquared;
 float det = B * B - 4.0 * C;
@@ -27,7 +27,7 @@ vec4 s = lookupCloudsFromTextureArray(cubeMap, rayDir);
 bool readRG = readChannelsRG ^^ readOtherChannel;
 s = readRG ? vec4(vec3(s.r), s.g) : vec4(vec3(s.b), s.a);
 return length(s) == 0.0 ? vec4(s.rgb, 1.0) : s;
-}`),p.uniforms.add(new c(`anchorPoint`,e=>e.clouds.parallax.anchorPoint),new c(`anchorPointNew`,e=>e.clouds.parallaxNew.anchorPoint),new d(`rotationClouds`,e=>e.clouds.parallax.transform),new d(`rotationCloudsNew`,e=>e.clouds.parallaxNew.transform),new l(`cloudsOpacity`,e=>e.clouds.opacity),new l(`fadeFactor`,e=>e.clouds.fadeFactor),new s(`crossFade`,e=>e.clouds.fadeState===3)).code.add(u`vec4 renderClouds(vec3 worldRay, vec3 cameraPosition) {
+}`),p.uniforms.add(new c(`anchorPoint`,e=>e.clouds.parallax.anchorPoint),new c(`anchorPointNew`,e=>e.clouds.parallaxNew.anchorPoint),new d(`rotationClouds`,e=>e.clouds.parallax.transform),new d(`rotationCloudsNew`,e=>e.clouds.parallaxNew.transform),h,new l(`fadeFactor`,e=>e.clouds.fadeFactor),new s(`crossFade`,e=>e.clouds.fadeState===3)).code.add(u`vec4 renderClouds(vec3 worldRay, vec3 cameraPosition) {
 vec3 intersectionPoint = intersectWithCloudLayer(worldRay, cameraPosition, anchorPoint);
 vec3 worldRayRotated = rotateDirectionToAnchorPoint(rotationClouds, normalize(intersectionPoint));
 vec3 worldRayRotatedCorrected = correctForPlanetCurvature(worldRayRotated);
@@ -46,4 +46,4 @@ float totalTransmittance = length(cloudColor.rgb) == 0.0 ?
 1.0 :
 clamp(cloudColor.a * cloudsOpacity + (1.0 - cloudsOpacity), 0.0 , 1.0);
 return vec4(cloudColor.rgb, totalTransmittance);
-}`)}const m=(t.radius+n)**2;export{p as CloudsParallaxShading};
+}`)}const m=(t.radius+n)**2,h=new l(`cloudsOpacity`,e=>e.clouds.opacity);export{p as CloudsParallaxShading,h as cloudsOpacity};

package/views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{translate as e}from"../../../../../../core/libs/gl-matrix-2/math/mat4.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as n}from"../../../../../../core/libs/gl-matrix-2/math/vec3.js";import{ZEROS as r,create as i}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{projMatrix as a}from"./cameraUniforms.js";import{Float3BindUniform as o}from"../../shaderModules/Float3BindUniform.js";import{Float3DrawUniform as s}from"../../shaderModules/Float3DrawUniform.js";import{FloatBindUniform as c}from"../../shaderModules/FloatBindUniform.js";import{Matrix4BindUniform as l}from"../../shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as u}from"../../shaderModules/Matrix4DrawUniform.js";function d(e,t){t.instancedDoublePrecision?e.constants.add(`cameraPosition`,`vec3`,r):e.uniforms.add(new s(`cameraPosition`,({origin:e},{camera:t})=>n(m,t.viewInverseTransposeMatrix[3]-e[0],t.viewInverseTransposeMatrix[7]-e[1],t.viewInverseTransposeMatrix[11]-e[2])))}function f(t,r){if(!r.instancedDoublePrecision){t.uniforms.add(a,new u(`view`,(t,n)=>e(p,n.camera.viewMatrix,t.origin)),new s(`localOrigin`,e=>e.origin));return}let i=({camera:e})=>n(m,e.viewInverseTransposeMatrix[3],e.viewInverseTransposeMatrix[7],e.viewInverseTransposeMatrix[11]);t.uniforms.add(a,new l(`view`,t=>e(p,t.camera.viewMatrix,i(t))),new o(`localOrigin`,e=>i(e)))}const p=t(),m=i();function h(e){e.uniforms.add(new c(`pixelRatio`,e=>e.camera.pixelRatio/e.overlayStretch))}export{d as addCameraPosition,h as addPixelRatio,f as addProjViewLocalOrigin};
+import{translate as e}from"../../../../../../core/libs/gl-matrix-2/math/mat4.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as n}from"../../../../../../core/libs/gl-matrix-2/math/vec3.js";import{ZEROS as r,create as i}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{projMatrix as a}from"./cameraUniforms.js";import{Float3BindUniform as o}from"../../shaderModules/Float3BindUniform.js";import{Float3DrawUniform as s}from"../../shaderModules/Float3DrawUniform.js";import{Matrix4BindUniform as c}from"../../shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as l}from"../../shaderModules/Matrix4DrawUniform.js";function u(e,t){t.instancedDoublePrecision?e.constants.add(`cameraPosition`,`vec3`,r):e.uniforms.add(new s(`cameraPosition`,({origin:e},{camera:t})=>n(m,t.viewInverseTransposeMatrix[3]-e[0],t.viewInverseTransposeMatrix[7]-e[1],t.viewInverseTransposeMatrix[11]-e[2])))}function d(t,n){n.instancedDoublePrecision?t.uniforms.add(a,new c(`view`,t=>e(p,t.camera.viewMatrix,f(t))),new o(`localOrigin`,e=>f(e))):t.uniforms.add(a,new l(`view`,(t,n)=>e(p,n.camera.viewMatrix,t.origin)),new s(`localOrigin`,e=>e.origin))}function f({camera:e}){return n(m,e.viewInverseTransposeMatrix[3],e.viewInverseTransposeMatrix[7],e.viewInverseTransposeMatrix[11])}const p=t(),m=i();export{u as addCameraPosition,d as addProjViewLocalOrigin};

package/views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{set as e}from"../../../../../../core/libs/gl-matrix-2/math/vec2.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/vec2f64.js";import{Float2BindUniform as n}from"../../shaderModules/Float2BindUniform.js";import{Float4BindUniform as r}from"../../shaderModules/Float4BindUniform.js";import{FloatBindUniform as i}from"../../shaderModules/FloatBindUniform.js";import{Matrix4BindUniform as a}from"../../shaderModules/Matrix4BindUniform.js";const o=new a(`view`,({camera:e})=>e.viewMatrix),s=new a(`inverseViewMatrix`,({camera:e})=>e.inverseViewMatrix),c=new a(`proj`,({camera:e})=>e.projectionMatrix),l=new a(`inverseProjectionMatrix`,({camera:e})=>e.inverseProjectionMatrix),u=new a(`viewNormal`,({camera:e})=>e.viewInverseTransposeMatrix),d=new n(`nearFar`,({camera:e})=>e.nearFar),f=new r(`viewport`,({camera:e})=>e.fullViewport),p=new i(`pixelRatio`,({camera:e})=>e.pixelRatio),m=new i(`screenPixelSizePerDistance`,({camera:e})=>e.screenPixelSizePerDistance),h=new i(`renderPixelSizePerDistance`,({camera:e})=>e.renderPixelSizePerDistance),g=new i(`metersPerRenderUnit`,e=>e.metersPerRenderUnit),_=new n(`inverseScreenSize`,({camera:t})=>e(v,1/t.fullWidth,1/t.fullHeight)),v=t();export{l as inverseProjectionMatrix,_ as inverseScreenSize,s as inverseViewMatrix,g as metersPerRenderUnit,d as nearFar,p as pixelRatio,c as projMatrix,h as renderPixelSizePerDistance,m as screenPixelSizePerDistance,o as viewMatrix,u as viewNormal,f as viewport};
+import{set as e}from"../../../../../../core/libs/gl-matrix-2/math/vec2.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/vec2f64.js";import{Float2BindUniform as n}from"../../shaderModules/Float2BindUniform.js";import{Float3BindUniform as r}from"../../shaderModules/Float3BindUniform.js";import{Float4BindUniform as i}from"../../shaderModules/Float4BindUniform.js";import{FloatBindUniform as a}from"../../shaderModules/FloatBindUniform.js";import{Matrix4BindUniform as o}from"../../shaderModules/Matrix4BindUniform.js";const s=new o(`view`,({camera:e})=>e.viewMatrix),c=new o(`inverseViewMatrix`,({camera:e})=>e.inverseViewMatrix),l=new o(`proj`,({camera:e})=>e.projectionMatrix),u=new o(`inverseProjectionMatrix`,({camera:e})=>e.inverseProjectionMatrix),d=new r(`cameraPosition`,({camera:e})=>e.eye),f=new o(`viewNormal`,({camera:e})=>e.viewInverseTransposeMatrix),p=new n(`nearFar`,({camera:e})=>e.nearFar),m=new i(`viewport`,({camera:e})=>e.fullViewport),h=new a(`pixelRatio`,e=>e.camera.pixelRatio/e.overlayStretch),g=new a(`screenPixelSizePerDistance`,({camera:e})=>e.screenPixelSizePerDistance),_=new a(`worldToScreenPerDistanceRatio`,({camera:e})=>1/e.screenPixelSizePerDistance),v=new a(`renderPixelSizePerDistance`,({camera:e})=>e.renderPixelSizePerDistance),y=new a(`metersPerRenderUnit`,e=>e.metersPerRenderUnit),b=new n(`inverseScreenSize`,({camera:t})=>e(S,1/t.fullWidth,1/t.fullHeight)),x=new n(`pixelToNDC`,({camera:t})=>e(S,2/t.fullViewport[2],2/t.fullViewport[3])),S=t();export{d as cameraPosition,u as inverseProjectionMatrix,b as inverseScreenSize,c as inverseViewMatrix,y as metersPerRenderUnit,p as nearFar,h as pixelRatio,x as pixelToNDC,l as projMatrix,v as renderPixelSizePerDistance,g as screenPixelSizePerDistance,s as viewMatrix,f as viewNormal,m as viewport,_ as worldToScreenPerDistanceRatio};