@arcgis/core 6.0.0-next.27 → 6.0.0-next.29

package/chunks/BlendLayers.glsl.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{BackgroundGrid as e}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/BackgroundGrid.glsl.js";import{TileBackground as t}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileBackground.glsl.js";import{TileComposite as n}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileComposite.glsl.js";import{Float3PassUniform as r}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as a}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as s}from"../views/webgl/ShaderBuilder.js";function c(c){let l=new s,u=l.fragment;if(l.include(n),c.background===1){let t=c.output===2;return t?u.uniforms.add(new r(`backgroundColor`,e=>e.backgroundColor)):u.include(e),u.main.add(a`fragColor = vec4(${t?a`backgroundColor`:a`gridColor(uv)`}, 1.0);`),l}return l.include(t,c),u.uniforms.add(new o(`tex`,e=>e.texture),new i(`opacity`,e=>e.opacity)).main.add(a`fragColor = blendLayers(uv, texture(tex, uv), opacity);`),l}const l=Object.freeze(Object.defineProperty({__proto__:null,build:c},Symbol.toStringTag,{value:`Module`}));export{l as B,c as b};
+import{BackgroundGrid as e}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/BackgroundGrid.glsl.js";import{blendLayers as t}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/blendLayers.glsl.js";import{TileComposite as n}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileComposite.glsl.js";import{Float3PassUniform as r}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{Texture2DPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as o}from"../views/webgl/ShaderBuilder.js";function s(s){let c=new o,l=c.fragment;return c.include(n),s.background===1?(s.output===2?l.uniforms.add(new r(`backgroundColor`,e=>e.backgroundColor)).main.add(`fragColor = vec4(backgroundColor, 1.0);`):(l.include(e),l.main.add(`fragColor = vec4(gridColor(uv), 1.0);`)),c):(c.include(t,s),l.uniforms.add(new a(`tex`,e=>e.texture),new i(`opacity`,e=>e.opacity)).main.add(`fragColor = blendLayers(uv, texture(tex, uv), opacity);`),c)}const c=Object.freeze(Object.defineProperty({__proto__:null,build:s},Symbol.toStringTag,{value:`Module`}));export{c as B,s as b};

package/chunks/Component.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{waterNormals as t}from"../views/3d/webgl-engine/core/shaderLibrary/bindUniforms.js";import{forwardLinearDepthToWriteShadow as ee}from"../views/3d/webgl-engine/core/shaderLibrary/forwardLinearDepthToWriteShadow.glsl.js";import{isColor as te,isShadow as n}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{slicePass as r}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{TextureCoordinateAttribute as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as o}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VertexPosition as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js";import{DepthConversion as c}from"../views/3d/webgl-engine/core/shaderLibrary/output/DepthConversion.glsl.js";import{outputDepth as l}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as u}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{OutputHighlightOverlay as ne}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlightOverlay.js";import{computeFragmentNormals as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeFragmentNormals.glsl.js";import{ComputeMaterialColor as re}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeMaterialColor.glsl.js";import{ComputeNormalTextureDraw as ie}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{lightingGlobalFactor as p,mainLightIntensity as m,mainLightDirection as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/lightingUniforms.js";import{NormalUtils as ae}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{pbrGlobals as oe}from"../views/3d/webgl-engine/core/shaderLibrary/shading/pbrGlobals.glsl.js";import{PhysicallyBasedRenderingParameters as se}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadBaseColorTexture as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{readShadowPass as _}from"../views/3d/webgl-engine/core/shaderLibrary/shading/readShadow.glsl.js";import{OverlayIM as ce}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as v}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as y}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{FloatDrawUniform as b}from"../views/3d/webgl-engine/core/shaderModules/FloatDrawUniform.js";import{If as x,glsl as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{applySnow as le}from"../views/3d/webgl-engine/effects/snowcover/applySnow.glsl.js";import{alphaCutoff as C}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as ue}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as de,sphereDepthInterpolate as w}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as T}from"../views/webgl/ShaderBuilder.js";function E(E){let D=new T,{vertex:O,fragment:k}=D;D.include(s,E),D.include(o,E),D.include(a,E),D.include(i,E),D.include(e,E),D.include(v,E),k.include(r,E),D.include(g,E);let{output:A,pbrMode:j,hasNormalTexture:M,snowCover:N,receiveShadows:P,shadeNormals:F,spherical:I,sphericalSR:L,overlayEnabled:R,componentDataType:fe,vertexDiscardMode:z,renderOccluded:B,isGroundSlice:V,groundTransparencyMode:pe}=E,H=te(A),U=j===1||j===2,W=pe===2,G=W&&(A===3||A===4);U&&(D.include(se,E),M&&D.include(ie,E));let K=n(A),q=A===11,me=A===10,J=A===4,he=K&&fe===1,Y=de(E),X=(R||G)&&I,Z=L===1;(H||J)&&(D.include(re,E),k.include(C)),(R||G)&&(k.include(f,E),D.include(ce,E),X?(D.varyings.add(`vPositionForDraping`,`vec3`),k.uniforms.add(new y(`useENUForGlobalOverlayUV`,e=>e.useENUForGlobalOverlayUV),new b(`overlayMapScaleU`,e=>e.toMapSpace[2]),new b(`overlayReferenceU`,e=>e.toMapSpace[0])),k.constants.add(`overlayWorldWidth`,`float`,Z?2*Math.PI*Y:360),Z?(k.constants.add(`pRadius`,`float`,Y),k.constants.add(`halfSemiMajorAxis`,`float`,.5*Y)):k.constants.add(`rad2deg1`,`float`,180/Math.PI),k.constants.add(`invRadius`,`float`,1/Y).code.add(S`
+import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{waterNormals as t}from"../views/3d/webgl-engine/core/shaderLibrary/bindUniforms.js";import{forwardLinearDepthToWriteShadow as n}from"../views/3d/webgl-engine/core/shaderLibrary/forwardLinearDepthToWriteShadow.glsl.js";import{isColor as r,isShadow as ee}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{slicePass as te}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{TextureCoordinateAttribute as ne}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as re}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as ie}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VertexPosition as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js";import{DepthConversion as a}from"../views/3d/webgl-engine/core/shaderLibrary/output/DepthConversion.glsl.js";import{outputDepth as o}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as s}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{OutputHighlightOverlay as c}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlightOverlay.js";import{computeFragmentNormals as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeFragmentNormals.glsl.js";import{ComputeMaterialColor as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeMaterialColor.glsl.js";import{ComputeNormalTextureDraw as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{getLocalUp as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/getLocalUp.glsl.js";import{lightingGlobalFactor as m,mainLightIntensity as h,mainLightDirection as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/lightingUniforms.js";import{NormalUtils as ae}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{pbrGlobals as oe}from"../views/3d/webgl-engine/core/shaderLibrary/shading/pbrGlobals.glsl.js";import{PhysicallyBasedRenderingParameters as se}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadBaseColorTexture as ce}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{readShadowPass as le}from"../views/3d/webgl-engine/core/shaderLibrary/shading/readShadow.glsl.js";import{OverlayIM as ue}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as de}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as fe}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{FloatDrawUniform as _}from"../views/3d/webgl-engine/core/shaderModules/FloatDrawUniform.js";import{If as v,glsl as y}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{applySnow as pe}from"../views/3d/webgl-engine/effects/snowcover/applySnow.glsl.js";import{alphaCutoff as b}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as me}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as x,sphereDepthInterpolate as S}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as C}from"../views/webgl/ShaderBuilder.js";function w(w){let T=new C,{vertex:E,fragment:D}=T;T.include(i,w),T.include(ie,w),T.include(re,w),T.include(ne,w),T.include(e,w),T.include(de,w),D.include(te,w),T.include(ce,w);let{output:O,pbrMode:k,hasNormalTexture:A,snowCover:j,receiveShadows:M,shadeNormals:N,spherical:P,sphericalSR:F,overlayEnabled:I,componentDataType:L,vertexDiscardMode:R,renderOccluded:z,isGroundSlice:B,groundTransparencyMode:he}=w,V=r(O),H=k===1||k===2,U=he===2,W=U&&(O===3||O===4);H&&(T.include(se,w),A&&T.include(d,w));let G=ee(O),K=O===11,ge=O===10,q=O===4,_e=G&&L===1,J=x(w),Y=(I||W)&&P,X=F===1;(V||q)&&(T.include(u,w),D.include(b)),(I||W)&&(D.include(f,w),T.include(ue,w),Y?(T.varyings.add(`vPositionForDraping`,`vec3`),D.uniforms.add(new fe(`useENUForGlobalOverlayUV`,e=>e.useENUForGlobalOverlayUV),new _(`overlayMapScaleU`,e=>e.toMapSpace[2]),new _(`overlayReferenceU`,e=>e.toMapSpace[0])),D.constants.add(`overlayWorldWidth`,`float`,X?2*Math.PI*J:360),X?(D.constants.add(`pRadius`,`float`,J),D.constants.add(`halfSemiMajorAxis`,`float`,.5*J)):D.constants.add(`rad2deg1`,`float`,180/Math.PI),D.constants.add(`invRadius`,`float`,1/J).code.add(y`
           vec2 projectOverlay(vec3 pos) { return pos.xy / (1.0 + invRadius * pos.z); }
 
           vec2 selectOverlayUVNorm(vec2 normUV, float offsetUNorm) {
@@ -31,12 +31,12 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
             float sinLat = wPos.z / oRadius;
             vec2 posMap;
 
-            ${x(Z,S`
+            ${v(X,y`
                 posMap = vec2(
                   oLonRad * pRadius,
                   halfSemiMajorAxis * log((1.0 + sinLat) / (1.0 - sinLat))
                 );
-              `,S`
+              `,y`
                 float oLatRad = asin(clamp(sinLat,-1.0,1.0));
                 posMap = vec2(rad2deg1 * oLonRad, rad2deg1 * oLatRad);
               `)}
@@ -49,14 +49,14 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
               ? selectLocalOverlayUVs(projectOverlay(vPositionForDraping))
               : selectMapOverlayUVs(overlayMapUVFromWorldPosition());
           }
-        `)):O.code.add(`vec2 projectOverlay(vec3 pos) { return pos.xy; }`));let Q=R&&H&&j===4;Q&&(D.varyings.add(`tbnTangent`,`vec3`),D.varyings.add(`tbnBiTangent`,`vec3`),D.varyings.add(`upNormal`,`vec3`));let ge=z===0,_e=z===2;if(D.include(_,E),D.include(ee,E),O.include(C),O.main.add(S`
+        `)):E.code.add(`vec2 projectOverlay(vec3 pos) { return pos.xy; }`));let Z=I&&V&&k===4;Z&&P&&(E.include(p,w),T.varyings.add(`tbnTangent`,`vec3`),T.varyings.add(`tbnBiTangent`,`vec3`));let Q=R===0,ve=R===2;if(T.include(le,w),T.include(n,w),E.include(b),E.main.add(y`
     bool castShadows;
     vec4 externalColor = forwardExternalColor(castShadows);
-    ${x(he,`if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }`)}
-    ${x(!ge,`if (externalColor.a ${_e?`>`:`<=`} opacityCutoff) {
+    ${v(_e,`if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }`)}
+    ${v(!Q,`if (externalColor.a ${ve?`>`:`<=`} opacityCutoff) {
          gl_Position = vec4(vec3(1e38), 1.0); return;
        }`)}
-    ${x(q,`externalColor.a = 1.0;`)}
+    ${v(K,`externalColor.a = 1.0;`)}
 
     forwardPosition(readElevationOffset());
     forwardNormal();
@@ -66,14 +66,11 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
     forwardLinearDepthToWriteShadow();
     forwardEmissiveStrength();
     forwardObjectAndLayerIdColor();
-    ${x(Q,I?S`
-            upNormal = normalize(positionWorld());
-            tbnTangent = normalize(cross(vec3(0.0, 0.0, 1.0), upNormal));
-            tbnBiTangent = normalize(cross(upNormal, tbnTangent));`:S`
-            upNormal = vec3(0.0, 0.0, 1.0);
-            tbnTangent = vec3(1.0, 0.0, 0.0);
-            tbnBiTangent = vec3(0.0, 1.0, 0.0);`)}
-    ${x(R||G,x(I,`vPositionForDraping = positionForDraping();
+    ${v(Z&&P,y`
+        vec3 upNormal = getLocalUp(positionWorld());
+        tbnTangent = normalize(cross(vec3(0.0, 0.0, 1.0), upNormal));
+        tbnBiTangent = normalize(cross(upNormal, tbnTangent));`)}
+    ${v(I||W,v(P,`vPositionForDraping = positionForDraping();
          vtcOverlay = vec4(0.0);`,`setOverlayVTC(projectOverlay(positionForDraping()));`))}
 
     if (externalColor.a < alphaCutoff) {
@@ -81,12 +78,12 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
       return;
     }
-  `),H)return D.include(d,E),D.include(ue,E),k.include(f,E),k.include(le,E),k.include(ae,E),k.code.add(S`
+  `),V)return T.include(l,w),T.include(me,w),D.include(f,w),D.include(pe,w),D.include(ae,w),D.code.add(y`
       float evaluateShadow() {
-        return ${P?`readShadowMap(vPositionWorldCameraRelative)`:`0.0`};
+        return ${M?`readShadowMap(vPositionWorldCameraRelative)`:`0.0`};
       }
-    `).main.add(S`
-      ${x(!V,`discardBySlice(vPositionWorldCameraRelative);`)}
+    `).main.add(y`
+      ${v(!B,`discardBySlice(vPositionWorldCameraRelative);`)}
 
       vec4 textureColor = readBaseColorTexture();
       discardOrAdjustAlpha(textureColor);
@@ -94,15 +91,15 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       // When rendering the occluded overlay, we still need to read the base color texture because we need to use the
       // same discard logic. However after that to render only the draped overlay, we simply set the base texture color
       // to zero.
-      ${x(B,S`textureColor = vec4(0);`)}
+      ${v(z,y`textureColor = vec4(0);`)}
 
-      ${x(R,S`
-        vec4 overlayUVs = ${X?`componentOverlayUVs()`:`vtcOverlay`};
+      ${v(I,y`
+        vec4 overlayUVs = ${Y?`componentOverlayUVs()`:`vtcOverlay`};
 
         vec4 overlayColor = getCombinedOverlayColor(overlayUVs);
 
         /* Early discard to only emit when we have overlay */
-        ${x(B,S`if (overlayColor.a < alphaCutoff) { discard; }`)}
+        ${v(z,y`if (overlayColor.a < alphaCutoff) { discard; }`)}
         `)}
 
       vec4 externalColor;
@@ -110,81 +107,81 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       readExternalColor(externalColor, externalColorMixMode);
 
       vec4 materialColor = computeMaterialColor(textureColor, externalColor, externalColorMixMode);
-      ${x(W,`materialColor = vec4(0.0);`)}
-    `),U?(I&&k.uniforms.add(p),k.include(oe),k.uniforms.add(m).main.add(S`
+      ${v(U,`materialColor = vec4(0.0);`)}
+    `),H?(P&&D.uniforms.add(m),D.include(oe),D.uniforms.add(h).main.add(y`
         applyPBRFactors();
-        ${x(j===1,`if (externalColorMixMode == 3) mrr = vec3(0.0, 0.6, 0.2);`)}
-        ${x(M,`mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);`)}
+        ${v(k===1,`if (externalColorMixMode == 3) mrr = vec3(0.0, 0.6, 0.2);`)}
+        ${v(A,`mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);`)}
 
         vec3 viewDirection = normalize(vPositionWorldCameraRelative);
         vec3 upNormal = getLocalUp(positionWorld());
-        vec3 shadingNormal = ${M?`computeTextureNormal(tangentSpace, vuv0)`:`fragmentShadingNormal`};
+        vec3 shadingNormal = ${A?`computeTextureNormal(tangentSpace, vuv0)`:`fragmentShadingNormal`};
 
         float ssao = occlusion * evaluateAmbientOcclusionInverse();
-        ${x(N,S`float snow = applySnow(fragmentFaceNormal, normalize(positionWorld(), materialColor.rgb, ssao));
+        ${v(j,y`float snow = applySnow(fragmentFaceNormal, upNormal, materialColor.rgb, ssao);
                  shadingNormal = mix(shadingNormal, fragmentFaceNormal, snow);`)}
-        ${x(R,`materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);`)}
+        ${v(I,`materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);`)}
 
         vec3 additionalLight = evaluateAdditionalLighting(1.0 - ssao, positionWorld());
-        ${x(I,`float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());`)}
-        ${x(I,`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`,`float shadow = evaluateShadow();`)}
+        ${v(P,`float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());`)}
+        ${v(P,`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`,`float shadow = evaluateShadow();`)}
         vec4 shadedColor = vec4(evaluateSceneLighting(shadingNormal, materialColor.rgb, shadow, 1.0 - ssao, additionalLight, viewDirection, upNormal), materialColor.a);
-      `)):(I&&k.uniforms.add(p),Q&&k.uniforms.add(t),k.uniforms.add(h).main.add(S`
-        ${x(I,`float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());`)}
-        float shadow = ${P?I?`max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())`:`evaluateShadow()`:I?`lightingGlobalFactor * (1.0 - additionalAmbientScale)`:`0.0`};
+      `)):(P&&D.uniforms.add(m),Z&&D.uniforms.add(t),D.uniforms.add(g).main.add(y`
+        ${v(P,`float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());`)}
+        float shadow = ${M?P?`max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())`:`evaluateShadow()`:P?`lightingGlobalFactor * (1.0 - additionalAmbientScale)`:`0.0`};
         float ssao = evaluateAmbientOcclusionInverse();
 
-        ${x(P&&F!==1,S`
+        ${v(M&&N!==1,y`
             float dotFL = dot(fragmentFaceNormal, mainLightDirection);
             if( dotFL <= 0.0) shadow = 1.0;
         `)}
-        ${x(N,`float snow = applySnow(fragmentFaceNormal, normalize(positionWorld()), materialColor.rgb, ssao);`)}
+        vec3 upNormal = getLocalUp(positionWorld());
+        ${v(j,`float snow = applySnow(fragmentFaceNormal, upNormal, materialColor.rgb, ssao);`)}
 
         vec3 viewDirection = normalize(vPositionWorldCameraRelative);
-        vec3 upNormal = getLocalUp(positionWorld());
 
         // At global scale we create some additional ambient light based on the main light to simulate global illumination
         vec3 additionalLight = evaluateAdditionalLighting(1.0 - ssao, positionWorld());
 
-        ${x(R,`materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);`)}
+        ${v(I,`materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);`)}
 
         vec4 shadedColor = vec4(evaluateSceneLighting(fragmentShadingNormal, materialColor.rgb, shadow, 1.0 - ssao, additionalLight, viewDirection, upNormal), materialColor.a);
-        ${x(Q,S`vec4 overlayWaterMask = getOverlayColor(waterNormals, overlayUVs);
+        ${v(Z,y`vec4 overlayWaterMask = getOverlayColor(waterNormals, overlayUVs);
                  float waterNormalLength = length(overlayWaterMask);
                  if (waterNormalLength > 0.95) {
-                   mat3 tbnMatrix = mat3(tbnTangent, tbnBiTangent, upNormal);
+                   mat3 tbnMatrix = ${P?`mat3(tbnTangent, tbnBiTangent, upNormal)`:`mat3(1.0)`};
                    vec4 waterColorLinear = getOverlayWaterColor(overlayWaterMask, overlayColor, -normalize(vPositionWorldCameraRelative), shadow, upNormal, tbnMatrix, vPosition_view, positionWorld());
                    vec4 waterColorNonLinear = delinearizeGamma(vec4(waterColorLinear.xyz, 1.0));
                    // un-gamma the ground color to mix in linear space
                    shadedColor = mix(shadedColor, waterColorNonLinear, waterColorLinear.w);
                  }`)}
-      `)),k.main.add(`
-      ${x(V,`if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;`)}
+      `)),D.main.add(`
+      ${v(B,`if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;`)}
 
-      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${x(N,`, snow`)});
-    `),E.sphereDepthInterpolate&&(D.include(w,E),D.fragment.include(c),k.main.add(S`vec3 worldRay = normalize(vPositionWorldCameraRelative);
+      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${v(j,`, snow`)});
+    `),w.sphereDepthInterpolate&&(T.include(S,w),T.fragment.include(a),D.main.add(y`vec3 worldRay = normalize(vPositionWorldCameraRelative);
 vec3 viewRay = normalize(vPosition_view);
-gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linearizeDepth(gl_FragCoord.z)));`)),D;let $=K||A===8;return $&&D.include(l,E),J&&D.include(d,E),R&&D.include(ne,E),D.include(u,E),k.main.add(S`
-    ${x(!V,`discardBySlice(vPositionWorldCameraRelative);`)}
+gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linearizeDepth(gl_FragCoord.z)));`)),T;let $=G||O===8;return $&&T.include(o,w),q&&T.include(l,w),I&&T.include(c,w),T.include(s,w),D.main.add(y`
+    ${v(!B,`discardBySlice(vPositionWorldCameraRelative);`)}
 
     vec4 textureColor = readBaseColorTexture();
     discardOrAdjustAlpha(textureColor);
 
-    ${x(G,S`
-      vec4 overlayUVs = ${X?`componentOverlayUVs()`:`vtcOverlay`};
+    ${v(W,y`
+      vec4 overlayUVs = ${Y?`componentOverlayUVs()`:`vtcOverlay`};
       if (getCombinedOverlayColor(overlayUVs).a < alphaCutoff) {
         discard;
       }
       `)}
 
-    ${x($,`outputDepth(linearDepth);`)}
-    ${x(J,S`
+    ${v($,`outputDepth(linearDepth);`)}
+    ${v(q,y`
         vec4 externalColor;
         int externalColorMixMode;
         readExternalColor(externalColor, externalColorMixMode);
 
         vec4 materialColor = computeMaterialColor(textureColor, externalColor, externalColorMixMode);
-        ${x(V,S`
+        ${v(B,y`
             if (rejectBySlice(vPositionWorldCameraRelative)) {
               materialColor.a *= groundSliceOpacity;
             }
@@ -192,5 +189,5 @@ gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linear
 
         fragColor = vec4(vec3(0.5) + 0.5 * fragmentFaceNormalView, materialColor.a);
       `)}
-    ${x(q,R?X?`fragColor = getOverlayColorTexel(componentOverlayUVs());`:`fragColor = getOverlayColorTexel();`:`outputObjectAndLayerIdColor();`)}
-    ${x(me,x(R,X?S`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded(componentOverlayUVs()));`:S`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,S`calculateOcclusionAndOutputHighlight();`))}`),D}const D=Object.freeze(Object.defineProperty({__proto__:null,build:E},Symbol.toStringTag,{value:`Module`}));export{D as C,E as b};
+    ${v(K,I?Y?`fragColor = getOverlayColorTexel(componentOverlayUVs());`:`fragColor = getOverlayColorTexel();`:`outputObjectAndLayerIdColor();`)}
+    ${v(ge,v(I,Y?y`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded(componentOverlayUVs()));`:y`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,y`calculateOcclusionAndOutputHighlight();`))}`),T}const T=Object.freeze(Object.defineProperty({__proto__:null,build:w},Symbol.toStringTag,{value:`Module`}));export{T as C,w as b};

package/chunks/EmissionComposite.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{__decorate as e}from"tslib";import{Gamma as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{FloatBindUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{parameter as a}from"../views/3d/webgl-engine/core/shaderTechnique/ShaderTechniqueConfiguration.js";import{BlurEmissionPassParameters as o,applyEmissiveGlow as s}from"../views/3d/webgl-engine/effects/glow/applyEmissiveGlow.glsl.js";import{FloatBlendScaleConfiguration as c,floatBlendScale as l}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ScreenSpacePassAtmosphere as u}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{ToneMapping as d}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";class p extends c{constructor(){super(...arguments),this.applyBlur=!0}}e([a()],p.prototype,`applyBlur`,void 0);class m extends o{}function h(e){let a=new f,o=a.fragment;return a.include(u,{needUVs:!0,needEyeDirection:!0}),a.outputs.add(`fragColor`,`vec4`,0),o.include(t),o.include(d),e.applyBlur?(o.include(s,e),o.code.add(`vec3 readEmission() { return applyEmissiveGlow(); }`)):(o.include(l,e),o.uniforms.add(new i(`emissionTexture`,({emission:e})=>e?.attachment)).code.add(`vec3 readEmission() { return texture(emissionTexture, uv).rgb * floatBlendInputScale; }`)),o.uniforms.add(new i(`colorTexture`,({color:e})=>e),new n(`inputScale`,({lighting:e})=>1.2-.5*e.noonFactor)).main.add(r`vec4 color = texture(colorTexture, uv);
+import{__decorate as e}from"tslib";import{Gamma as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{FloatBindUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{parameter as a}from"../views/3d/webgl-engine/core/shaderTechnique/ShaderTechniqueConfiguration.js";import{EmissiveGlowConfiguration as o,EmissiveGlowPassParameters as s,applyEmissiveGlow as c}from"../views/3d/webgl-engine/effects/glow/applyEmissiveGlow.glsl.js";import{floatBlendScale as l}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ScreenSpacePassAtmosphere as u}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{ToneMapping as d}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";class p extends o{constructor(){super(...arguments),this.applyBlur=!0}}e([a()],p.prototype,`applyBlur`,void 0);class m extends s{}function h(e){let a=new f,o=a.fragment;return a.include(u,{needUVs:!0,needEyeDirection:!0}),a.outputs.add(`fragColor`,`vec4`,0),o.include(t),o.include(d),e.applyBlur?(o.include(c,e),o.code.add(`vec3 readEmission() { return applyEmissiveGlow(); }`)):(o.include(l,e),o.uniforms.add(new i(`emissionTexture`,({emission:e})=>e?.attachment)).code.add(`vec3 readEmission() { return texture(emissionTexture, uv).rgb * floatBlendInputScale; }`)),o.uniforms.add(new i(`colorTexture`,({color:e})=>e),new n(`inputScale`,({lighting:e})=>1.2-.5*e.noonFactor)).main.add(r`vec4 color = texture(colorTexture, uv);
 color = vec4(linearizeGamma(color.rgb), color.a);
 vec3 emission = readEmission() * inputScale;
 vec3 toneMapped = tonemapKhronosNeutral(color.rgb + emission);

package/chunks/Fog.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/vec3f64.js";import{mainDepth as t}from"../views/3d/webgl-engine/core/shaderLibrary/bindUniforms.js";import{ReadDepth as n}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{Gamma as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{ColorConversion as i}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{Float3PassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as s}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{BlurEmissionPassParameters as l,applyEmissiveGlow as u}from"../views/3d/webgl-engine/effects/glow/applyEmissiveGlow.glsl.js";import{getDistanceFalloff as d}from"../views/3d/webgl-engine/effects/raymarching/DistanceFalloff.glsl.js";import{ScreenSpacePassAtmosphere as f}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{ToneMapping as p}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";class h extends l{constructor(){super(...arguments),this.fogColor=e(),this.strength=0,this.amount=0,this.fogColorDistanceWeight=.85,this.inputScale=1}}function g(e){let l=new m,{outputs:h,fragment:g}=l;h.add(`fragColor`,`vec4`,0),l.include(f,{needUVs:!0,needEyeDirection:!0}),g.uniforms.add(t,new o(`fogStrength`,e=>e.strength),new o(`fogAmount`,e=>e.amount),new a(`fogColor`,e=>e.fogColor),new o(`fogColorDistanceWeight`,e=>e.fogColorDistanceWeight)).constants.add(`f16Epsilon`,`float`,6103515625e-14),g.include(d),g.include(r),g.include(p),g.include(n),g.include(i),g.main.add(s`float depth = -1.0;
+import{create as e}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{mainDepth as t}from"../views/3d/webgl-engine/core/shaderLibrary/bindUniforms.js";import{ReadDepth as n}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{Gamma as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{ColorConversion as i}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{Float3PassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as s}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{EmissiveGlowPassParameters as l,applyEmissiveGlow as u}from"../views/3d/webgl-engine/effects/glow/applyEmissiveGlow.glsl.js";import{getDistanceFalloff as d}from"../views/3d/webgl-engine/effects/raymarching/DistanceFalloff.glsl.js";import{ScreenSpacePassAtmosphere as f}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{ToneMapping as p}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";class h extends l{constructor(){super(...arguments),this.fogColor=e(),this.strength=0,this.amount=0,this.fogColorDistanceWeight=.85,this.inputScale=1}}function g(e){let l=new m,{outputs:h,fragment:g}=l;h.add(`fragColor`,`vec4`,0),l.include(f,{needUVs:!0,needEyeDirection:!0}),g.uniforms.add(t,new o(`fogStrength`,e=>e.strength),new o(`fogAmount`,e=>e.amount),new a(`fogColor`,e=>e.fogColor),new o(`fogColorDistanceWeight`,e=>e.fogColorDistanceWeight)).constants.add(`f16Epsilon`,`float`,6103515625e-14),g.include(d),g.include(r),g.include(p),g.include(n),g.include(i),g.main.add(s`float depth = -1.0;
 float depthSample = depthFromTexture(mainDepth, uv);
 if(depthSample < 1.0 && depthSample > 0.0){
 vec3 cameraSpaceRay = normalize(eyeDir);

package/chunks/GaussianSplat.glsl.js

@@ -1,20 +1,20 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{calculateUVZShadowPass as e}from"../views/3d/webgl-engine/core/shaderLibrary/shading/calculateUVZShadow.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{lightingGlobalFactor as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/lightingUniforms.js";import{NormalUtils as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{readShadowPass as a,readShadowMaps as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/readShadow.glsl.js";import{cameraPosition as s}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{RgbNormalizedDepthEncoding as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{glsl as l,If as u}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as d}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{GaussianSplatPerspectivePass as f,GaussianSplatFading as p,gaussianSplatPerspectiveVertex as m}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{getGaussianSplatAlphaCutoffValue as h}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";function _(_){let{receiveShadows:v,spherical:y}=_,b=v&&_.fragmentShading,x=b&&_.preciseDepth,S=new g,{varyings:C,vertex:w,fragment:T,outputs:E}=S;C.add(`vColor`,`vec4`),x&&C.add(`shadowReceiverRay`,`vec3`),S.include(f,_),_.fadingEnabled&&w.include(p),w.uniforms.add(s);let D=b?T:w;D.uniforms.add(s),D.include(t,_),D.include(i,_),n(D),D.uniforms.add(r),b?S.include(a,_):v&&(w.include(e),_.hasShadowHighlights&&w.code.add(l`ivec2 getShadowHighlightCoordinates() {
+import{calculateUVZShadowPass as e}from"../views/3d/webgl-engine/core/shaderLibrary/shading/calculateUVZShadow.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{lightingGlobalFactor as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/lightingUniforms.js";import{NormalUtils as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{positionOutsideClipSpace as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{readShadowPass as o,readShadowMaps as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/readShadow.glsl.js";import{cameraPosition as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{RgbNormalizedDepthEncoding as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{glsl as u,If as d}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as f}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{gaussianSplatPerspective as p,gaussianSplatFading as m}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{getGaussianSplatAlphaCutoffValue as h}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";function _(_){let{receiveShadows:v,spherical:y}=_,b=v&&_.fragmentShading,x=b&&_.preciseDepth,S=new g,{varyings:C,vertex:w,fragment:T,outputs:E}=S;C.add(`vColor`,`vec4`),C.add(`gaussianCoordinates`,`vec2`),C.add(`gaussianLogFalloffCutoff`,`float`),C.add(`fragmentPositionCameraRelative`,`vec3`),_.preciseDepth&&C.add(`rayGaussianFactor`,`vec4`),x&&C.add(`shadowReceiverRay`,`vec3`),S.include(p,_),_.fadingEnabled&&w.include(m),w.uniforms.add(c);let D=b?T:w;D.uniforms.add(c),D.include(t,_),D.include(i,_),n(D),D.uniforms.add(r),b?S.include(o,_):v&&(w.include(e),_.hasShadowHighlights&&w.code.add(u`ivec2 getShadowHighlightCoordinates() {
 vec2 screenUV = gl_Position.xy / gl_Position.w * 0.5 + 0.5;
 ivec2 screenPixel = ivec2(screenUV / inverseScreenSize);
 return clamp(screenPixel, ivec2(0), textureSize(shadowHighlight, 0) - 1);
-}`),o(w,_.hasShadowHighlights,`getShadowHighlightCoordinates()`)),E.add(`fragColor`,`vec4`,0),E.add(`fragDepthColor`,`vec4`,1);let O=h(_.alphaCutoff),k=l`float groundLightAlignment = dot(upNormal, mainLightDirection);
+}`),s(w,_.hasShadowHighlights,`getShadowHighlightCoordinates()`)),E.add(`fragColor`,`vec4`,0),E.add(`fragDepthColor`,`vec4`,1);let O=h(_.alphaCutoff),k=u`float groundLightAlignment = dot(upNormal, mainLightDirection);
 float additionalAmbientScale = additionalDirectedAmbientLight(groundLightAlignment);
-vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,A=l`
+vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,A=u`
     vec3 viewDirection = normalize(fragmentPositionCameraRelative - cameraPosition);
     vec3 upNormal = getLocalUp(fragmentPositionCameraRelative, cameraPosition);
     ${k}
-    float shadow = ${y?l`lightingGlobalFactor * (1.0 - additionalAmbientScale)`:l`0.0`};
-    ${u(v,l`
-        ${_.preciseDepth?l`
-                float receiverDepth = gaussianSplatRayDepth();
+    float shadow = ${y?u`lightingGlobalFactor * (1.0 - additionalAmbientScale)`:u`0.0`};
+    ${d(v,u`
+        ${_.preciseDepth?u`
+                float receiverDepth = computeGaussianRayDepth(rayGaussianFactor);
                 vec3 receiverPosition = transpose(mat3(view)) * rayView * receiverDepth;
-              `:l`
+              `:u`
                 float receiverDepth = -viewPos.z;
                 vec3 receiverPosition = fragmentPositionCameraRelative;
               `}
@@ -22,18 +22,19 @@ vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoos
         shadow = max(shadow, readShadowMaps(uvzShadow));
       `)}
     vColor.rgb = evaluateSceneLighting(upNormal, vColor.rgb, shadow, 0.0, additionalLight, viewDirection, upNormal);
-  `,j=l`
+  `,j=u`
     vec3 viewDirection = normalize(fragmentPositionCameraRelative - cameraPosition);
     vec3 upNormal = getLocalUp(fragmentPositionCameraRelative, cameraPosition);
     ${k}
-    ${x?l`
+    ${x?u`
             float shadow = max(
               lightingGlobalFactor * (1.0 - additionalAmbientScale),
               readShadowMap(shadowReceiverRay * receiverDepth, receiverDepth)
             );
           `:`float shadow = readShadow(additionalAmbientScale, fragmentPositionCameraRelative);`}
     shadedColor = evaluateSceneLighting(upNormal, vColor.rgb, shadow, 0.0, additionalLight, viewDirection, upNormal);
-  `;return w.main.add(`
+  `;return w.main.add(u`
+    gl_Position = ${a};
     uint gaussianIndex = fetchOrderedGaussianIndex(uint(gl_InstanceID));
     uvec4 packedGaussian = fetchPackedGaussian(gaussianIndex);
 
@@ -42,34 +43,77 @@ vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoos
     float opacity = vColor.a;
 
     // Apply per-page fading before the early alpha rejection.
-    ${u(_.fadingEnabled,l`opacity = applyGaussianSplatFading(opacity, gaussianIndex);
-vColor.a = opacity;`)}
+    ${d(_.fadingEnabled,u`
+        opacity = applyGaussianSplatFading(opacity, gaussianIndex);
+        vColor.a = opacity;
+      `)}
+
+    if (opacity < ${u.float(O)}) {
+      return;
+    }
+
+    vec3 cameraRelativePosition = fetchGaussianCameraRelativePosition(gaussianIndex, packedGaussian);
+    if (rejectGaussianPosition(cameraRelativePosition)) {
+      return;
+    }
+
+    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1.0);
+    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {
+      return;
+    }
 
-    ${m(_,O)}
+    vec3 gaussianScale = unpackScale(packedGaussian);
+    mat3 gaussianRotation = quaternionToRotationMatrix(unpackQuaternion(packedGaussian));
+    GaussianSplatProjection projection;
+    if (!projectGaussianSplat(
+      viewPos.xyz, gaussianScale, gaussianRotation,
+      ${u.float(O)}, ${u.float(Math.log(O))}, opacity, projection
+    )) {
+      return;
+    }
+
+    gaussianCoordinates = projection.coordinates;
+    gaussianLogFalloffCutoff = projection.logFalloffCutoff;
+    fragmentPositionCameraRelative = cameraRelativePosition + transpose(mat3(view)) * projection.viewOffset;
+
+    ${d(_.preciseDepth,u`
+        vec3 rayView = reconstructViewRay(projection.clipPosition.xy, inverseProjectionMatrix);
+        rayGaussianFactor = computeGaussianRayFactor(
+          rayView, cameraRelativePosition, gaussianScale, gaussianRotation, mat3(view)
+        );
+      `)}
+    gl_Position = projection.clipPosition;
     vColor.a = opacity;
-    ${u(x,`shadowReceiverRay = transpose(mat3(view)) * rayView;`)}
+    ${d(x,`shadowReceiverRay = transpose(mat3(view)) * rayView;`)}
 
     // Per-fragment lighting preserves crisp shadow borders; vertex lighting reduces overdraw cost.
-    ${u(b,`forwardLinearDepth(-viewPos.z);`,A)}
-  `),T.include(c),T.main.add(`
+    ${d(b,`forwardLinearDepth(-viewPos.z);`,A)}
+  `),T.include(l),T.main.add(u`
+    if (rejectGaussianPosition(fragmentPositionCameraRelative)) {
+      discard;
+    }
+    float gaussianExponent = evaluateGaussianExponent(gaussianCoordinates);
+    if (gaussianExponent > 0.0 || gaussianExponent < gaussianLogFalloffCutoff) {
+      discard;
+    }
     float gaussianFalloff = exp(gaussianExponent);
 
     // Cap at 0.99 to avoid blending issues, such as seams between overlapping Gaussians.
     float alpha = min(.99f, vColor.a * gaussianFalloff);
 
-    ${u(x,l`float receiverDepth = gaussianSplatRayDepth();`)}
+    ${d(_.preciseDepth,u`float receiverDepth = computeGaussianRayDepth(rayGaussianFactor);`)}
     vec3 shadedColor = vColor.rgb;
-    ${u(b,j)}
+    ${d(b,j)}
     fragColor = vec4(shadedColor * alpha, alpha);
 
     // We simulate first hit based depth using the shared opacity threshold.
     // This works because we render in front-to-back order,
     // i.e. the first hit that counts completely saturates the alpha channel
     // and further splats do not contribute.
-    float depthHit = step(${l.float(d)}, alpha);
+    float depthHit = step(${u.float(f)}, alpha);
     vec3 encodedDepth = vec3(0.0);
     if (depthHit > 0.0) {
-      encodedDepth = encodeNormalizedDepthToRGB(${x?`delinearizeDepth(-receiverDepth)`:`gaussianSplatDepth()`});
+      encodedDepth = encodeNormalizedDepthToRGB(${_.preciseDepth?`delinearizeDepth(-receiverDepth)`:`gl_FragCoord.z`});
     }
     fragDepthColor = vec4(encodedDepth, depthHit);
   `),S}const v=Object.freeze(Object.defineProperty({__proto__:null,build:_},Symbol.toStringTag,{value:`Module`}));export{v as G,_ as b};

package/chunks/GaussianSplatDepth.glsl.js

@@ -1,11 +1,60 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{If as e,glsl as t}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as n}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{GaussianSplatPerspectivePass as r,GaussianSplatFading as i,gaussianSplatPerspectiveVertex as a}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{ShaderBuilder as o}from"../views/webgl/ShaderBuilder.js";function s(s){let{fadingEnabled:c}=s,l=new o,{fragment:u,vertex:d}=l;return l.include(r,s),s.fadingEnabled&&l.vertex.include(i),s.writeNormals&&l.outputs.add(`fragNormal`,`vec4`,0),d.main.add(t`
+import{positionOutsideClipSpace as e}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{If as t,glsl as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as r}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{gaussianSplatPerspective as i,gaussianSplatFading as a}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{ShaderBuilder as o}from"../views/webgl/ShaderBuilder.js";function s(s){let{fadingEnabled:c}=s,l=new o,{fragment:u,vertex:d,varyings:f}=l;return l.include(i,s),f.add(`gaussianCoordinates`,`vec2`),f.add(`gaussianLogFalloffCutoff`,`float`),f.add(`fragmentPositionCameraRelative`,`vec3`),s.preciseDepth&&f.add(`rayGaussianFactor`,`vec4`),s.fadingEnabled&&l.vertex.include(a),s.writeNormals&&l.outputs.add(`fragNormal`,`vec4`,0),d.main.add(n`
+    gl_Position = ${e};
     uint gaussianIndex = fetchOrderedGaussianIndex(uint(gl_InstanceID));
     uvec4 packedGaussian = fetchPackedGaussian(gaussianIndex);
 
     float opacity = unpackOpacity(packedGaussian);
 
-    ${e(c,t`opacity = applyGaussianSplatFading(opacity, gaussianIndex);`)}
+    ${t(c,n`opacity = applyGaussianSplatFading(opacity, gaussianIndex);`)}
 
-    ${a(s,n)}
-  `),s.preciseDepth&&u.main.add(`gl_FragDepth = gaussianSplatDepth();`),s.writeNormals&&u.main.add(`fragNormal = vec4(0.0);`),l}const c=Object.freeze(Object.defineProperty({__proto__:null,build:s},Symbol.toStringTag,{value:`Module`}));export{c as G,s as b};
+    if (opacity < ${n.float(r)}) {
+      return;
+    }
+
+    vec3 cameraRelativePosition = fetchGaussianCameraRelativePosition(gaussianIndex, packedGaussian);
+    if (rejectGaussianPosition(cameraRelativePosition)) {
+      return;
+    }
+
+    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1.0);
+    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {
+      return;
+    }
+
+    vec3 gaussianScale = unpackScale(packedGaussian);
+    mat3 gaussianRotation = quaternionToRotationMatrix(unpackQuaternion(packedGaussian));
+    GaussianSplatProjection projection;
+    if (!projectGaussianSplat(
+      viewPos.xyz, gaussianScale, gaussianRotation,
+      ${n.float(r)}, ${n.float(Math.log(r))}, opacity, projection
+    )) {
+      return;
+    }
+
+    gaussianCoordinates = projection.coordinates;
+    gaussianLogFalloffCutoff = projection.logFalloffCutoff;
+    fragmentPositionCameraRelative = cameraRelativePosition + transpose(mat3(view)) * projection.viewOffset;
+
+    ${t(s.preciseDepth,n`
+        vec3 rayView = reconstructViewRay(projection.clipPosition.xy, inverseProjectionMatrix);
+        rayGaussianFactor = computeGaussianRayFactor(
+          rayView, cameraRelativePosition, gaussianScale, gaussianRotation, mat3(view)
+        );
+      `)}
+    gl_Position = projection.clipPosition;
+  `),u.main.add(n`
+    if (rejectGaussianPosition(fragmentPositionCameraRelative)) {
+      discard;
+    }
+    ${s.normalizedCutoff?n`
+            if (dot(gaussianCoordinates, gaussianCoordinates) > 1.0) {
+              discard;
+            }
+          `:n`
+            float gaussianExponent = evaluateGaussianExponent(gaussianCoordinates);
+            if (gaussianExponent > 0.0 || gaussianExponent < gaussianLogFalloffCutoff) {
+              discard;
+            }
+          `}
+  `),s.preciseDepth&&u.main.add(n`gl_FragDepth = delinearizeDepth(-computeGaussianRayDepth(rayGaussianFactor));`),s.writeNormals&&u.main.add(`fragNormal = vec4(0.0);`),l}const c=Object.freeze(Object.defineProperty({__proto__:null,build:s},Symbol.toStringTag,{value:`Module`}));export{c as G,s as b};