@arcgis/core 6.0.0-next.7 → 6.0.0-next.9

package/views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js

@@ -1,27 +1,27 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/mat3f64.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{DoublePrecision as n}from"../util/DoublePrecision.glsl.js";import{Float3DrawUniform as r}from"../../shaderModules/Float3DrawUniform.js";import{Float3PassUniform as i}from"../../shaderModules/Float3PassUniform.js";import{If as a,glsl as o}from"../../shaderModules/glsl.js";import{IntegerDrawUniform as s}from"../../shaderModules/IntegerDrawUniform.js";import{Matrix3DrawUniform as c}from"../../shaderModules/Matrix3DrawUniform.js";import{Matrix3PassUniform as l}from"../../shaderModules/Matrix3PassUniform.js";import{Matrix4BindUniform as u}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DPassUniform as d}from"../../shaderModules/Texture2DPassUniform.js";import{ViewingModeConfiguration as f}from"../../../materials/ViewingModeConfiguration.js";import{NoParameters as p}from"../../../../../webgl/NoParameters.js";class m extends f{}function h(e,t){let{attributes:f,vertex:p,varyings:m,fragment:h}=e;p.include(n),f.add(`position`,`vec3`),m.add(`vPositionWorldCameraRelative`,`vec3`),m.add(`vPosition_view`,`vec3`,{invariant:!0}),p.uniforms.add(new i(`transformWorldFromViewTH`,e=>e.transformWorldFromViewTH),new i(`transformWorldFromViewTL`,e=>e.transformWorldFromViewTL),new l(`transformViewFromCameraRelativeRS`,e=>e.transformViewFromCameraRelativeRS),new u(`transformProjFromView`,e=>e.camera.projectionMatrix));let{vertexPositionRotationType:g,useTransformationTexture:_}=t,v=g===1,y=g===2,b=v||y;_?p.uniforms.add(new s(`transformationDrawId`,e=>e.transformationDrawId),new d(`transformationTexture`,e=>e.transformationTexture)):(p.uniforms.add(new r(`transformWorldFromModelTH`,e=>e.transformWorldFromModelTH),new r(`transformWorldFromModelTL`,e=>e.transformWorldFromModelTL)),b&&p.uniforms.add(new c(`transformWorldFromModelRS`,e=>e.transformWorldFromModelRS))),p.code.add(o`
-      ${a(b,o`
+import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/mat3f64.js";import{create as t}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{projMatrix as n}from"../util/cameraUniforms.js";import{DoublePrecision as r}from"../util/DoublePrecision.glsl.js";import{Float3DrawUniform as i}from"../../shaderModules/Float3DrawUniform.js";import{Float3PassUniform as a}from"../../shaderModules/Float3PassUniform.js";import{If as o,glsl as s}from"../../shaderModules/glsl.js";import{IntegerDrawUniform as c}from"../../shaderModules/IntegerDrawUniform.js";import{Matrix3DrawUniform as l}from"../../shaderModules/Matrix3DrawUniform.js";import{Matrix3PassUniform as u}from"../../shaderModules/Matrix3PassUniform.js";import{Texture2DPassUniform as d}from"../../shaderModules/Texture2DPassUniform.js";import{ViewingModeConfiguration as f}from"../../../materials/ViewingModeConfiguration.js";import{NoParameters as p}from"../../../../../webgl/NoParameters.js";class m extends f{}function h(e,t){let{attributes:f,vertex:p,varyings:m,fragment:h}=e;p.include(r),f.add(`position`,`vec3`),m.add(`vPositionWorldCameraRelative`,`vec3`),m.add(`vPosition_view`,`vec3`,{invariant:!0}),p.uniforms.add(new a(`transformWorldFromViewTH`,e=>e.transformWorldFromViewTH),new a(`transformWorldFromViewTL`,e=>e.transformWorldFromViewTL),new u(`transformViewFromCameraRelativeRS`,e=>e.transformViewFromCameraRelativeRS),n);let{vertexPositionRotationType:g,useTransformationTexture:_}=t,v=g===1,y=g===2,b=v||y;_?p.uniforms.add(new c(`transformationDrawId`,e=>e.transformationDrawId),new d(`transformationTexture`,e=>e.transformationTexture)):(p.uniforms.add(new i(`transformWorldFromModelTH`,e=>e.transformWorldFromModelTH),new i(`transformWorldFromModelTL`,e=>e.transformWorldFromModelTL)),b&&p.uniforms.add(new l(`transformWorldFromModelRS`,e=>e.transformWorldFromModelRS))),p.code.add(s`
+      ${o(b,s`
           mat3 modelTransformation() {
-          ${a(_,o`
+          ${o(_,s`
                 return mat3(
                   texelFetch(transformationTexture, ivec2(2, transformationDrawId), 0).xyz,
                   texelFetch(transformationTexture, ivec2(3, transformationDrawId), 0).xyz,
                   texelFetch(transformationTexture, ivec2(4, transformationDrawId), 0).xyz
-                );`,o`return transformWorldFromModelRS;`)}
+                );`,s`return transformWorldFromModelRS;`)}
           }
         `)}
 
       vec3 originL() {
-        return ${a(_,o`texelFetch(transformationTexture, ivec2(0, transformationDrawId), 0).xyz;`,o`transformWorldFromModelTL;`)}
+        return ${o(_,s`texelFetch(transformationTexture, ivec2(0, transformationDrawId), 0).xyz;`,s`transformWorldFromModelTL;`)}
       }
 
       vec3 originH() {
-        return ${a(_,o`texelFetch(transformationTexture, ivec2(1, transformationDrawId), 0).xyz;`,o`transformWorldFromModelTH;`)};
+        return ${o(_,s`texelFetch(transformationTexture, ivec2(1, transformationDrawId), 0).xyz;`,s`transformWorldFromModelTH;`)};
       }
 
       vec3 positionWorldCameraRelative() {
 
-      vec3 rotatedModelPosition = ${a(v,o`modelTransformation() *`)} position;
+      vec3 rotatedModelPosition = ${o(v,s`modelTransformation() *`)} position;
 
       vec3 transform_CameraRelativeFromModel = dpAdd(
         originL(),
@@ -34,20 +34,20 @@ import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/mat3f6
     }
 
     vec3 positionForDraping() {
-      return ${a(y,o`modelTransformation() *`)} position;
+      return ${o(y,s`modelTransformation() *`)} position;
     }
-  `),p.code.add(o`
+  `),p.code.add(s`
     void forwardPosition(float fOffset) {
       vPositionWorldCameraRelative = positionWorldCameraRelative();
       if (fOffset != 0.0) {
-        vPositionWorldCameraRelative += fOffset * ${t.spherical?o`normalize(transformWorldFromViewTL + vPositionWorldCameraRelative)`:o`vec3(0.0, 0.0, 1.0)`};
+        vPositionWorldCameraRelative += fOffset * ${t.spherical?s`normalize(transformWorldFromViewTL + vPositionWorldCameraRelative)`:s`vec3(0.0, 0.0, 1.0)`};
       }
 
       vPosition_view = transformViewFromCameraRelativeRS * vPositionWorldCameraRelative;
-      gl_Position = transformProjFromView * vec4(vPosition_view, 1.0);
+      gl_Position = proj * vec4(vPosition_view, 1.0);
     }
-  `),h.uniforms.add(new i(`transformWorldFromViewTL`,e=>e.transformWorldFromViewTL)),p.code.add(o`vec3 positionWorld() {
+  `),h.uniforms.add(new a(`transformWorldFromViewTL`,e=>e.transformWorldFromViewTL)),p.code.add(s`vec3 positionWorld() {
 return transformWorldFromViewTL + vPositionWorldCameraRelative;
-}`),h.code.add(o`vec3 positionWorld() {
+}`),h.code.add(s`vec3 positionWorld() {
 return transformWorldFromViewTL + vPositionWorldCameraRelative;
 }`)}class g extends p{constructor(){super(...arguments),this.transformWorldFromViewTH=t(),this.transformWorldFromViewTL=t(),this.transformViewFromCameraRelativeRS=e()}}class _ extends p{constructor(){super(...arguments),this.transformWorldFromModelRS=e(),this.transformWorldFromModelTH=t(),this.transformWorldFromModelTL=t(),this.transformationDrawId=0}}export{h as VertexPosition,m as VertexPositionConfiguration,_ as VertexPositionDrawParameters,g as VertexPositionPassParameters};

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

@@ -0,0 +1,2 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import{Texture2DBindUniform as e}from"../shaderModules/Texture2DBindUniform.js";const t=new e(`depthMap`,e=>e.depth?.attachment),n=new e(`mainDepth`,e=>e.mainDepth),r=new e(`waterNormals`,e=>e.overlay?.getTexture(3)),i=new e(`shadowHighlight`,e=>e.shadowHighlight?.getTexture());export{t as depthMap,n as mainDepth,i as shadowHighlight,r as waterNormals};

package/views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{addVerticalOffset as e}from"../attributes/VerticalOffset.glsl.js";import{viewport as t,viewNormal as n}from"../util/cameraUniforms.js";import{ScreenSizePerspective as r,addScreenSizePerspectiveAlignment as i}from"../util/ScreenSizePerspective.glsl.js";import{addProjViewLocalOrigin as a,addCameraPosition as o,addPixelRatio as s}from"../util/View.glsl.js";import{FloatBindUniform as c}from"../../shaderModules/FloatBindUniform.js";import{FloatPassUniform as l}from"../../shaderModules/FloatPassUniform.js";import{glsl as u}from"../../shaderModules/glsl.js";const d=.5;function f(f,p){let m=f.vertex;f.include(r),f.attributes.add(`position`,`vec3`),f.vertex.inputs.add(`position`,()=>`position`),f.attributes.add(`normal`,`vec3`),p.hasVertexCenterOffset?f.attributes.add(`centerOffset`,`vec3`):m.constants.add(`centerOffset`,`vec3`,[0,0,0]),f.attributes.add(`groundDistance`,`float`),a(m,p),o(m,p),m.uniforms.add(t,new l(`polygonOffset`,e=>e.shaderPolygonOffset),new c(`aboveGround`,e=>e.camera.aboveGround?1:-1)),p.hasVerticalOffset&&e(m),m.code.add(u`struct ProjectHUDAux {
+import{addVerticalOffset as e}from"../attributes/VerticalOffset.glsl.js";import{viewport as t,viewNormal as n,pixelRatio as r}from"../util/cameraUniforms.js";import{ScreenSizePerspective as i,addScreenSizePerspectiveAlignment as a}from"../util/ScreenSizePerspective.glsl.js";import{addProjViewLocalOrigin as o,addCameraPosition as s}from"../util/View.glsl.js";import{FloatBindUniform as c}from"../../shaderModules/FloatBindUniform.js";import{FloatPassUniform as l}from"../../shaderModules/FloatPassUniform.js";import{glsl as u}from"../../shaderModules/glsl.js";const d=.5;function f(f,p){let m=f.vertex;f.include(i),f.attributes.add(`position`,`vec3`),f.vertex.inputs.add(`position`,()=>`position`),f.attributes.add(`normal`,`vec3`),p.hasVertexCenterOffset?f.attributes.add(`centerOffset`,`vec3`):m.constants.add(`centerOffset`,`vec3`,[0,0,0]),f.attributes.add(`groundDistance`,`float`),o(m,p),s(m,p),m.uniforms.add(t,new l(`polygonOffset`,e=>e.shaderPolygonOffset),new c(`aboveGround`,e=>e.camera.aboveGround?1:-1)),p.hasVerticalOffset&&e(m),m.code.add(u`struct ProjectHUDAux {
 vec3 posModel;
 vec3 posView;
 vec3 vnormal;
@@ -39,7 +39,7 @@ return groundRelative;
         posModel += modelOffset;
         posView += viewOffset;
       }
-    `)),p.screenCenterOffsetUnitsEnabled&&s(m),p.hasScreenSizePerspective&&i(m),m.code.add(u`
+    `)),p.screenCenterOffsetUnitsEnabled&&m.uniforms.add(r),p.hasScreenSizePerspective&&a(m),m.code.add(u`
     vec4 projectPositionHUD(out ProjectHUDAux aux) {
       float pointGroundDistance = groundDistance;
       aux.posModel = position;

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

@@ -0,0 +1,2 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import{Texture2DBindUniform as e}from"../shaderModules/Texture2DBindUniform.js";const t=new e(`lastFrameColorTexture`,e=>e.reprojection.lastFrameColor?.getTexture());export{t as lastFrameColorTexture};

package/views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{HighlightReadBitmap as e}from"../HighlightReadBitmap.glsl.js";import{glsl as t}from"../../shaderModules/glsl.js";import{Integer2BindUniform as n}from"../../shaderModules/Integer2BindUniform.js";import{IntegerBindUniform as r}from"../../shaderModules/IntegerBindUniform.js";import{Texture2DBindUniform as i}from"../../shaderModules/Texture2DBindUniform.js";import{Texture2DUintBindUniform as a}from"../../shaderModules/Texture2DUintBindUniform.js";function o(o,s){let{fragment:c}=o,{output:l,draped:u,hasHighlightMixTexture:d}=s;l===10?(c.uniforms.add(new r(`highlightLevel`,e=>e.highlightLevel??0),new n(`highlightMixOrigin`,e=>e.highlightMixOrigin)),o.outputs.add(`fragHighlight`,`uvec2`,0),o.include(e),d?c.uniforms.add(new a(`highlightMixTexture`,e=>e.highlightMixTexture)).code.add(t`uvec2 getAccumulatedHighlight() {
+import{mainDepth as e}from"../bindUniforms.js";import{HighlightReadBitmap as t}from"../HighlightReadBitmap.glsl.js";import{glsl as n}from"../../shaderModules/glsl.js";import{Integer2BindUniform as r}from"../../shaderModules/Integer2BindUniform.js";import{IntegerBindUniform as i}from"../../shaderModules/IntegerBindUniform.js";import{Texture2DUintBindUniform as a}from"../../shaderModules/Texture2DUintBindUniform.js";function o(o,s){let{fragment:c}=o,{output:l,draped:u,hasHighlightMixTexture:d}=s;l===10?(c.uniforms.add(new i(`highlightLevel`,e=>e.highlightLevel??0),new r(`highlightMixOrigin`,e=>e.highlightMixOrigin)),o.outputs.add(`fragHighlight`,`uvec2`,0),o.include(t),d?c.uniforms.add(new a(`highlightMixTexture`,e=>e.highlightMixTexture)).code.add(n`uvec2 getAccumulatedHighlight() {
 return texelFetch(highlightMixTexture, ivec2(gl_FragCoord.xy) - highlightMixOrigin, 0).rg;
 }
 void outputHighlight(bool occluded) {
@@ -19,14 +19,14 @@ uvec2 combinedHighlight = getAccumulatedHighlight();
 combinedHighlight[li] |= bits;
 fragHighlight = combinedHighlight;
 }
-}`):c.code.add(t`void outputHighlight(bool occluded) {
+}`):c.code.add(n`void outputHighlight(bool occluded) {
 uint bits = occluded ? 3u : 1u;
 fragHighlight = uvec2(bits, 0);
-}`),u?c.code.add(t`bool isHighlightOccluded() {
+}`),u?c.code.add(n`bool isHighlightOccluded() {
 return false;
-}`):c.uniforms.add(new i(`depthTexture`,e=>e.mainDepth)).code.add(t`bool isHighlightOccluded() {
-float sceneDepth = texelFetch(depthTexture, ivec2(gl_FragCoord.xy), 0).x;
+}`):c.uniforms.add(e).code.add(n`bool isHighlightOccluded() {
+float sceneDepth = texelFetch(mainDepth, ivec2(gl_FragCoord.xy), 0).x;
 return gl_FragCoord.z > sceneDepth + 5e-7;
-}`),c.code.add(t`void calculateOcclusionAndOutputHighlight() {
+}`),c.code.add(n`void calculateOcclusionAndOutputHighlight() {
 outputHighlight(isHighlightOccluded());
-}`)):c.code.add(t`void calculateOcclusionAndOutputHighlight() {}`)}export{o as OutputHighlight};
+}`)):c.code.add(n`void calculateOcclusionAndOutputHighlight() {}`)}export{o as OutputHighlight};

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(`globalIlluminationOcclusionBoost`,`float`,1.2),p.constants.add(`globalIlluminationEmissionBoost`,`float`,2.25),p.constants.add(`globalIlluminationEmissionCompressionWeight`,`float`,.75),p.code.add(d`vec3 evaluateGlobalIlluminationOcclusion() {
+}`);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 = 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,7 +1,7 @@
 /* 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(`vStippleLimitsAndCaps`,`vec4`),u.varyings.add(`vStipplePatternStretch`,`float`),g.code.add(s`
@@ -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,7 +35,7 @@ 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;y&&u.varyings.add(`vStipplePerspective`,`vec4`),v?(u.varyings.add(`vStippleV`,`float`),u.fragment.include(e),_.code.add(s`vec4 getStippleColor(out bool isClamped) {
+  `),_.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);

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/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);