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

package/chunks/ComponentShader.glsl.js

@@ -1,13 +1,12 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{ForwardLinearDepthToWriteShadowMap as o}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as r,isShadow as a}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePass as l}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 t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as n}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{OutputDepth as d}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as g}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{ReadDepth as m}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{computeFragmentNormals as v}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 h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as w,addLightingGlobalFactor as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as b,addMainLightDirection as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{PhysicallyBasedRenderingParameters as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{PiUtils as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{ReadBaseColorTexture as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{ReadShadowMapPassFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as S}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{OverlayIM as O}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as j}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as N}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{If as $,glsl as T}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as D}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{SnowCover as R}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as M}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as P,sphereDepthInterpolate as W}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as A}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as F}from"../webscene/support/AlphaCutoff.js";function U(U){const V=new A,{vertex:z,fragment:B}=V;V.include(s,U),V.include(n,U),V.include(t,U),V.include(i,U),V.include(e,U),V.include(j,U),B.include(l,U),V.include(x,U),V.include(S,U);const{output:E,pbrMode:_,hasNormalTexture:I,snowCover:G,receiveShadows:H,shadeNormals:k,spherical:q,sphericalSR:J,overlayEnabled:K,componentDataType:Q,vertexDiscardMode:X,renderOccluded:Y,isGroundSlice:Z}=U,ee=1===_||2===_;ee&&(V.include(y,U),I&&V.include(h,U));const oe=a(E),re=11===E,ae=oe&&1===Q,le=P(U);K&&(B.include(w,U),V.include(O,U),z.include(C),z.uniforms.add(new N("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV)),B.uniforms.add(new N("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV)),z.constants.add("invRadius","float",1/le).code.add(`vec2 projectOverlay(vec3 pos) { return pos.xy ${$(q,"/ (1.0 + invRadius * pos.z)")}; }`));const ie=K&&r(E)&&4===_;ie&&(V.varyings.add("tbnTangent","vec3"),V.varyings.add("tbnBiTangent","vec3"),V.varyings.add("groundNormal","vec3"));const te=0===X,ne=2===X,se=1-1/255;if(V.include(L,U),V.include(o,U),z.main.add(T`
+import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{ForwardLinearDepthToWriteShadowMap as o}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as a,isShadow as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePass as l}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 t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as n}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{OutputDepth as d}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as g}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{ReadDepth as m}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{computeFragmentNormals as v}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 h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as w,addLightingGlobalFactor as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as b,addMainLightDirection as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{PhysicallyBasedRenderingParameters as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{PiUtils as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{ReadBaseColorTexture as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{ReadShadowMapPassFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{OverlayIM as S}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as O}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as j}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{If as N,glsl as $}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as R}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{SnowCover as T}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as M}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as D,sphereDepthInterpolate as W}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as P}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as A}from"../webscene/support/AlphaCutoff.js";function F(F){const U=new P,{vertex:V,fragment:z}=U;U.include(s,F),U.include(n,F),U.include(t,F),U.include(i,F),U.include(e,F),U.include(O,F),z.include(l,F),U.include(x,F);const{output:B,pbrMode:E,hasNormalTexture:_,snowCover:I,receiveShadows:G,shadeNormals:H,spherical:k,sphericalSR:q,overlayEnabled:J,componentDataType:K,vertexDiscardMode:Q,renderOccluded:X,isGroundSlice:Y}=F,Z=1===E||2===E;Z&&(U.include(y,F),_&&U.include(h,F));const ee=r(B),oe=11===B,ae=ee&&1===K,re=D(F);J&&(z.include(w,F),U.include(S,F),V.include(C),V.uniforms.add(new j("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV)),z.uniforms.add(new j("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV)),V.constants.add("invRadius","float",1/re).code.add(`vec2 projectOverlay(vec3 pos) { return pos.xy ${N(k,"/ (1.0 + invRadius * pos.z)")}; }`));const le=J&&a(B)&&4===E;le&&(U.varyings.add("tbnTangent","vec3"),U.varyings.add("tbnBiTangent","vec3"),U.varyings.add("groundNormal","vec3"));const ie=0===Q,te=2===Q,ne=1-1/255;if(U.include(L,F),U.include(o,F),V.main.add($`
     bool castShadows;
     vec4 externalColor = forwardExternalColor(castShadows);
-    ${$(ae,"if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }")}
-    ${$(!te,`{ if (externalColor.a ${ne?">":"<="} ${T.float(se)}) { gl_Position = vec4(vec3(1e38), 1.0); return; } }`)}
-    ${$(re,"externalColor.a = 1.0;")}
+    ${N(ae,"if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }")}
+    ${N(!ie,`{ if (externalColor.a ${te?">":"<="} ${$.float(ne)}) { gl_Position = vec4(vec3(1e38), 1.0); return; } }`)}
+    ${N(oe,"externalColor.a = 1.0;")}
 
     forwardPosition(readElevationOffset());
-    forwardViewPosDepth(vPosition_view);
     forwardNormal();
     forwardTextureCoordinates();
     forwardVertexColor();
@@ -15,27 +14,26 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
     forwardLinearDepthToWriteShadowMap();
     forwardEmissiveStrength();
     forwardObjectAndLayerIdColor();
-    ${$(ie,q?T`
+    ${N(le,k?$`
             groundNormal = normalize(positionWorld());
             tbnTangent = normalize(cross(vec3(0.0, 0.0, 1.0), groundNormal));
-            tbnBiTangent = normalize(cross(groundNormal, tbnTangent));`:T`
+            tbnBiTangent = normalize(cross(groundNormal, tbnTangent));`:$`
             groundNormal = vec3(0.0, 0.0, 1.0);
             tbnTangent = vec3(1.0, 0.0, 0.0);
             tbnBiTangent = vec3(0.0, 1.0, 0.0);`)}
-    ${$(K,$(q,"\n        if (useENUForGlobalOverlayUV) {\n          setOverlayVTC(projectOverlay(position));\n        } else {\n          vtcOverlay = vec4(0.0); // Definite assignment\n        }\n      ","setOverlayVTC(projectOverlay(position));"))}
+    ${N(J,N(k,"\n        if (useENUForGlobalOverlayUV) {\n          setOverlayVTC(projectOverlay(position));\n        } else {\n          vtcOverlay = vec4(0.0); // Definite assignment\n        }\n      ","setOverlayVTC(projectOverlay(position));"))}
 
-    if (externalColor.a < ${T.float(F)}) {
+    if (externalColor.a < ${$.float(A)}) {
       // Discard this vertex
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
       return;
     }
-  `),r(E))return V.include(u,U),V.include(v,U),B.include(w,U),V.include(M,U),B.include(R,U),B.constants.add("pRadius","float",le).code.add(T`
+  `),a(B))return U.include(u,F),U.include(v,F),z.include(w,F),U.include(M,F),z.include(T,F),z.constants.add("pRadius","float",re).code.add($`
       float evaluateShadow() {
-        return ${H?"readShadowMap(vPositionWorldCameraRelative, linearDepth)":"0.0"};
+        return ${G?"readShadowMap(vPositionWorldCameraRelative, linearDepth)":"0.0"};
       }
-    `).main.add(T`
-      ${$(!Z,"discardBySlice(vPositionWorldCameraRelative);")}
-      discardByTerrainDepth();
+    `).main.add($`
+      ${N(!Y,"discardBySlice(vPositionWorldCameraRelative);")}
 
       vec4 textureColor = readBaseColorTexture();
       discardOrAdjustAlpha(textureColor);
@@ -43,10 +41,10 @@ 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.
-      ${$(Y,T`textureColor = vec4(0);`)}
+      ${N(X,$`textureColor = vec4(0);`)}
 
-      ${$(K,T`
-        ${$(q,T`
+      ${N(J,$`
+        ${N(k,$`
             vec4 overlayUVs;
             if (useENUForGlobalOverlayUV) {
               overlayUVs = vtcOverlay;
@@ -59,7 +57,7 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
               float oLonRad = atan(wPos.y, wPos.x);
               float sinLat = wPos.z / oRadius;
 
-              ${$(1===J,T`
+              ${N(1===q,$`
                   const float halfSemiMajorAxis = 0.5 * pRadius;
                   vec2 posWM = vec2(
                     oLonRad * pRadius,
@@ -67,19 +65,19 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
                   );
 
                   vec2 overlayUV = posWM;
-              `,T`
+              `,$`
                 float oLatRad = asin(clamp(sinLat,-1.0,1.0));
                 vec2 posWgs84 = vec2(rad2deg1 * oLonRad, rad2deg1 * oLatRad);
                 vec2 overlayUV = posWgs84;
               `)}
               overlayUVs = vec4(overlayUV, overlayUV) * overlayTexScale + overlayTexOffset;
             }
-          `,T`vec4 overlayUVs = vtcOverlay;`)}
+          `,$`vec4 overlayUVs = vtcOverlay;`)}
 
         vec4 overlayColor = getOverlayColor(ovColorTex, overlayUVs);
 
         /* Early discard to only emit when we have overlay */
-        ${$(Y,T`if (overlayColor.a < ${T.float(F)}) { discard; }`)}
+        ${N(X,$`if (overlayColor.a < ${$.float(A)}) { discard; }`)}
         `)}
 
       vec4 externalColor;
@@ -87,47 +85,47 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       readExternalColor(externalColor, externalColorMixMode);
 
       vec4 materialColor = computeMaterialColor(textureColor, externalColor, externalColorMixMode);
-    `),ee?(b(B),q&&p(B),B.main.add(T`
+    `),Z?(b(z),k&&p(z),z.main.add($`
         applyPBRFactors();
-        ${$(1===_,T`if (externalColorMixMode == 3) {
+        ${N(1===E,$`if (externalColorMixMode == 3) {
               mrr = vec3(0.0, 0.6, 0.2);
             }`)}
         float additionalIrradiance = 0.02 * mainLightIntensity[2];
-        ${$(I,"mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);")}
-        vec3 shadingNormal = ${I?"computeTextureNormal(tangentSpace, vuv0)":"fragmentShadingNormal"};
-        vec3 groundNormal = ${q?T`normalize(positionWorld())`:T`vec3(0.0, 0.0, 1.0)`};
+        ${N(_,"mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);")}
+        vec3 shadingNormal = ${_?"computeTextureNormal(tangentSpace, vuv0)":"fragmentShadingNormal"};
+        vec3 groundNormal = ${k?$`normalize(positionWorld())`:$`vec3(0.0, 0.0, 1.0)`};
 
         vec3 viewDir = normalize(vPositionWorldCameraRelative);
         float ssao = 1.0 - occlusion * evaluateAmbientOcclusionInverse();
-        ${$(G,T`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
+        ${N(I,$`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
                  materialColor.rgb = mix(materialColor.rgb, vec3(1.1), snow);
                  ssao = mix(ssao, 0.5 * ssao, snow);
                  shadingNormal = mix(shadingNormal, fragmentFaceNormal, snow);`)}
-        ${$(K,"materialColor = materialColor * (1.0 - overlayColor.a) + overlayColor;")}
+        ${N(J,"materialColor = materialColor * (1.0 - overlayColor.a) + overlayColor;")}
 
         vec3 additionalLight = evaluateAdditionalLighting(ssao, positionWorld());
-        ${$(q,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
-        ${q?T`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`:"float shadow = evaluateShadow();"}
+        ${N(k,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
+        ${k?$`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`:"float shadow = evaluateShadow();"}
         vec4 shadedColor = vec4(evaluateSceneLightingPBR(shadingNormal, materialColor.rgb, shadow, ssao, additionalLight, viewDir, groundNormal, mrr, additionalIrradiance), materialColor.a);
-        `)):(f(B),q&&p(B),ie&&B.uniforms.add(new D("ovNormalTex",e=>e.overlay?.getTexture(3))),B.main.add(T`
-        ${$(q,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
-        float shadow = ${H?q?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())":"evaluateShadow()":q?"lightingGlobalFactor * (1.0 - additionalAmbientScale)":"0.0"};
+        `)):(f(z),k&&p(z),le&&z.uniforms.add(new R("ovNormalTex",e=>e.overlay?.getTexture(3))),z.main.add($`
+        ${N(k,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
+        float shadow = ${G?k?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())":"evaluateShadow()":k?"lightingGlobalFactor * (1.0 - additionalAmbientScale)":"0.0"};
 
-        ${$(H&&1!==k,T`
+        ${N(G&&1!==H,$`
             float dotFL = dot(fragmentFaceNormal, mainLightDirection);
             if( dotFL <= 0.0) shadow = 1.0;
         `)}
-        ${$(G,T`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
+        ${N(I,$`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
                materialColor.rgb = mix(materialColor.rgb, vec3(1), snow);`)}
 
         // At global scale we create some additional ambient light based on the main light to simulate global illumination
         float ssao = evaluateAmbientOcclusion();
         vec3 additionalLight = evaluateAdditionalLighting(ssao, positionWorld());
 
-        ${$(K,"materialColor = materialColor * (1.0 - overlayColor.a) + overlayColor;")}
+        ${N(J,"materialColor = materialColor * (1.0 - overlayColor.a) + overlayColor;")}
 
         vec4 shadedColor = vec4(evaluateSceneLighting(fragmentShadingNormal, materialColor.rgb, shadow, ssao, additionalLight), materialColor.a);
-        ${$(ie,T`vec4 overlayWaterMask = getOverlayColor(ovNormalTex, vtcOverlay);
+        ${N(le,$`vec4 overlayWaterMask = getOverlayColor(ovNormalTex, vtcOverlay);
                  float waterNormalLength = length(overlayWaterMask);
                  if (waterNormalLength > 0.95) {
                    mat3 tbnMatrix = mat3(tbnTangent, tbnBiTangent, groundNormal);
@@ -136,19 +134,19 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
                    // un-gamma the ground color to mix in linear space
                    shadedColor = mix(shadedColor, waterColorNonLinear, waterColorLinear.w);
                  }`)}
-      `)),B.main.add(`\n      ${$(Z,"if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;")}\n\n      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${$(G,", snow")});\n    `),U.sphereDepthInterpolate&&(V.include(W,U),V.fragment.include(m),B.main.add(T`if (sphereFade()>0.0) {
+      `)),z.main.add(`\n      ${N(Y,"if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;")}\n\n      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${N(I,", snow")});\n    `),F.sphereDepthInterpolate&&(U.include(W,F),U.fragment.include(m),z.main.add($`if (sphereFade()>0.0) {
 vec3 worldRay = normalize(vPositionWorldCameraRelative);
 vec3 viewRay = normalize(vPosition_view);
 gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linearizeDepth(gl_FragCoord.z)));
 } else {
 gl_FragDepth = gl_FragCoord.z;
-}`)),V;const de=4===E,ge=10===E,ce=oe||8===E||9===E;return ce&&V.include(d,U),de&&V.include(v,U),K&&V.include(c,U),V.include(g,U),B.main.add(T`
-    ${$(!Z,"discardBySlice(vPositionWorldCameraRelative);")}
+}`)),U;const se=4===B,de=10===B,ge=ee||8===B||9===B;return ge&&U.include(d,F),se&&U.include(v,F),J&&U.include(c,F),U.include(g,F),z.main.add($`
+    ${N(!Y,"discardBySlice(vPositionWorldCameraRelative);")}
 
     vec4 textureColor = readBaseColorTexture();
     discardOrAdjustAlpha(textureColor);
 
-    ${$(ce,"outputDepth(linearDepth);")}
-    ${$(de,T`fragColor = vec4(vec3(0.5) + 0.5 * fragmentFaceNormalView, 1.0);`)}
-    ${$(re,K?"fragColor = getOverlayColorTexel();":"outputObjectAndLayerIdColor();")}
-    ${$(ge,$(K,T`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,T`calculateOcclusionAndOutputHighlight();`))}`),V}const V=Object.freeze(Object.defineProperty({__proto__:null,build:U},Symbol.toStringTag,{value:"Module"}));export{V as C,U as b};
+    ${N(ge,"outputDepth(linearDepth);")}
+    ${N(se,$`fragColor = vec4(vec3(0.5) + 0.5 * fragmentFaceNormalView, 1.0);`)}
+    ${N(oe,J?"fragColor = getOverlayColorTexel();":"outputObjectAndLayerIdColor();")}
+    ${N(de,N(J,$`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,$`calculateOcclusionAndOutputHighlight();`))}`),U}const U=Object.freeze(Object.defineProperty({__proto__:null,build:F},Symbol.toStringTag,{value:"Module"}));export{U as C,F as b};

package/chunks/DefaultMaterial.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstanceColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstanceColor.glsl.js";import{InstancedDoublePrecision as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{MaskedColorDefinition as s,CreateMaskedFromNaNColor as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/MaskedColor.glsl.js";import{NormalAttribute as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{SymbolColor as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/SymbolColor.glsl.js";import{TextureCoordinateAttribute as c}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as g}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as m}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VerticalOffset as u}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as v}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{ComputeNormalTexturePass as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateAmbientOcclusion as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as b,addAmbientBoostFactor as f,addLightingGlobalFactor as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{PhysicallyBasedRendering as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as j,ReadShadowMapDrawFragment as P}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as M}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{colorTextureUV as T,normalTextureUV as N,emissiveTextureUV as S,occlusionTextureUV as O,metallicRoughnessTextureUV as V}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TextureTransformUV.glsl.js";import{VisualVariables as $}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as A}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{MixExternalColor as D}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{addProjViewLocalOrigin as U,addCameraPosition as I}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as B}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as E}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as k}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{If as _,glsl as R}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as F}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as W}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{colorMixModes as z}from"../views/3d/webgl-engine/materials/internal/MaterialUtil.js";import{outputColorHighlightOLID as G}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as H}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as q}from"../webscene/support/AlphaCutoff.js";function J(J){const K=new H,{attributes:Q,vertex:X,fragment:Y,varyings:Z}=K,{output:ee,normalType:re,offsetBackfaces:oe,spherical:ie,snowCover:ae,pbrMode:le,textureAlphaPremultiplied:se,instancedDoublePrecision:ne,hasVertexColors:te,hasVertexTangents:de,hasColorTexture:ce,hasNormalTexture:ge,hasNormalTextureTransform:me,hasColorTextureTransform:ue}=J;if(U(X,J),Q.add("position","vec3"),Z.add("vpos","vec3",{invariant:!0}),K.include($,J),K.include(l,J),K.include(u,J),K.include(T,J),!r(ee))return K.include(v,J),K;K.include(N,J),K.include(S,J),K.include(O,J),K.include(V,J),I(X,J),K.include(t,J),K.include(i);const ve=0===re||1===re;return ve&&oe&&K.include(e),K.include(p,J),K.include(m,J),K.include(a,J),Z.add("vPositionLocal","vec3"),K.include(c,J),K.include(d,J),K.include(g,J),X.uniforms.add(new E("externalColor",e=>e.externalColor,{supportsNaN:!0})),Z.add("vcolorExt","vec4"),K.include(M,J),X.include(s),X.include(n),K.include(ne?j:P,J),X.main.add(R`
+import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstanceColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstanceColor.glsl.js";import{InstancedDoublePrecision as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{MaskedColorDefinition as s,CreateMaskedFromNaNColor as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/MaskedColor.glsl.js";import{NormalAttribute as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{SymbolColor as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/SymbolColor.glsl.js";import{TextureCoordinateAttribute as c}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as m}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as g}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VerticalOffset as u}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as v}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{ComputeNormalTexturePass as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateAmbientOcclusion as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as w,addAmbientBoostFactor as f,addLightingGlobalFactor as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{PhysicallyBasedRendering as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as j,ReadShadowMapDrawFragment as P}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{colorTextureUV as M,normalTextureUV as N,emissiveTextureUV as S,occlusionTextureUV as O,metallicRoughnessTextureUV as T}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TextureTransformUV.glsl.js";import{VisualVariables as V}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as $}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{MixExternalColor as A}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{addProjViewLocalOrigin as D,addCameraPosition as U}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as I}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as E}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as k}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{If as B,glsl as _}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as R}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as F}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{colorMixModes as W}from"../views/3d/webgl-engine/materials/internal/MaterialUtil.js";import{outputColorHighlightOLID as z}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as G}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as H}from"../webscene/support/AlphaCutoff.js";function q(q){const J=new G,{attributes:K,vertex:Q,fragment:X,varyings:Y}=J,{output:Z,normalType:ee,offsetBackfaces:re,spherical:oe,snowCover:ie,pbrMode:ae,textureAlphaPremultiplied:le,instancedDoublePrecision:se,hasVertexColors:ne,hasVertexTangents:te,hasColorTexture:de,hasNormalTexture:ce,hasNormalTextureTransform:me,hasColorTextureTransform:ge}=q;if(D(Q,q),K.add("position","vec3"),Q.inputs.add("position",()=>"position"),Y.add("vpos","vec3",{invariant:!0}),J.include(V,q),J.include(l,q),J.include(u,q),J.include(M,q),!r(Z))return J.include(v,q),J;J.include(N,q),J.include(S,q),J.include(O,q),J.include(T,q),U(Q,q),J.include(t,q),J.include(i);const ue=0===ee||1===ee;return ue&&re&&J.include(e),J.include(p,q),J.include(g,q),J.include(a,q),Y.add("vPositionLocal","vec3"),J.include(c,q),J.include(d,q),J.include(m,q),Q.uniforms.add(new E("externalColor",e=>e.externalColor,{supportsNaN:!0})),Y.add("vcolorExt","vec4"),Q.include(s),Q.include(n),J.include(se?j:P,q),Q.main.add(_`
     forwardVertexColor();
 
     MaskedColor maskedColor =
@@ -11,13 +11,12 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
     vpos = getVertexInLocalOriginSpace();
     vPositionLocal = vpos - view[3].xyz;
     vpos = subtractOrigin(vpos);
-    ${_(ve,"vNormalWorld = dpNormal(vvLocalNormal(normalModel()));")}
+    ${B(ue,"vNormalWorld = dpNormal(vvLocalNormal(normalModel()));")}
     vpos = addVerticalOffset(vpos, localOrigin);
-    ${_(de,"vTangent = dpTransformVertexTangent(tangent);")}
+    ${B(te,"vTangent = dpTransformVertexTangent(tangent);")}
     gl_Position = transformPosition(proj, view, vpos);
-    ${_(ve&&oe,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);")}
+    ${B(ue&&re,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);")}
 
-    forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
     forwardTextureCoordinates();
     forwardColorUV();
     forwardNormalUV();
@@ -25,19 +24,18 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
     forwardOcclusionUV();
     forwardMetallicRoughnessUV();
 
-    if (opacityMixMode != ${R.int(z.ignore)} && vcolorExt.a < ${R.float(q)}) {
+    if (opacityMixMode != ${_.int(W.ignore)} && vcolorExt.a < ${_.float(H)}) {
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
     }
     forwardLinearDepthToReadShadowMap();
-  `),Y.include(b,J),Y.include(w,J),K.include(A,J),Y.include(o,J),K.include(G,J),I(Y,J),Y.uniforms.add(X.uniforms.get("localOrigin"),new B("ambient",e=>e.ambient),new B("diffuse",e=>e.diffuse),new k("opacity",e=>e.opacity),new k("layerOpacity",e=>e.layerOpacity)),ce&&Y.uniforms.add(new F("tex",e=>e.texture)),K.include(L,J),Y.include(C,J),Y.include(D),K.include(x,J),Y.include(W,J),f(Y),h(Y),y(Y),Y.main.add(R`
+  `),X.include(w,q),X.include(b,q),J.include($,q),X.include(o,q),J.include(z,q),U(X,q),X.uniforms.add(Q.uniforms.get("localOrigin"),new I("ambient",e=>e.ambient),new I("diffuse",e=>e.diffuse),new k("opacity",e=>e.opacity),new k("layerOpacity",e=>e.layerOpacity)),de&&X.uniforms.add(new R("tex",e=>e.texture)),J.include(L,q),X.include(C,q),X.include(A),J.include(x,q),X.include(F,q),f(X),h(X),y(X),X.main.add(_`
     discardBySlice(vpos);
-    discardByTerrainDepth();
-    ${ce?R`
-            vec4 texColor = texture(tex, ${ue?"colorUV":"vuv0"});
-            ${_(se,"texColor.rgb /= texColor.a;")}
-            discardOrAdjustAlpha(texColor);`:R`vec4 texColor = vec4(1.0);`}
+    ${de?_`
+            vec4 texColor = texture(tex, ${ge?"colorUV":"vuv0"});
+            ${B(le,"texColor.rgb /= texColor.a;")}
+            discardOrAdjustAlpha(texColor);`:_`vec4 texColor = vec4(1.0);`}
     shadingParams.viewDirection = normalize(vpos - cameraPosition);
-    ${2===re?R`vec3 normal = screenDerivativeNormal(vPositionLocal);`:R`shadingParams.normalView = vNormalWorld;
+    ${2===ee?_`vec3 normal = screenDerivativeNormal(vPositionLocal);`:_`shadingParams.normalView = vNormalWorld;
                 vec3 normal = shadingNormal(shadingParams);`}
     applyPBRFactors();
     float ssao = evaluateAmbientOcclusionInverse() * getBakedOcclusion();
@@ -48,13 +46,13 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
     float shadow = readShadow(additionalAmbientScale, vpos);
 
     vec3 matColor = max(ambient, diffuse);
-    vec3 albedo = mixExternalColor(${_(te,"vColor.rgb *")} matColor, texColor.rgb, vcolorExt.rgb, colorMixMode);
-    float opacity_ = layerOpacity * mixExternalOpacity(${_(te,"vColor.a * ")} opacity, texColor.a, vcolorExt.a, opacityMixMode);
+    vec3 albedo = mixExternalColor(${B(ne,"vColor.rgb *")} matColor, texColor.rgb, vcolorExt.rgb, colorMixMode);
+    float opacity_ = layerOpacity * mixExternalOpacity(${B(ne,"vColor.a * ")} opacity, texColor.a, vcolorExt.a, opacityMixMode);
 
-    ${ge?`mat3 tangentSpace = computeTangentSpace(${de?"normal":"normal, vpos, vuv0"});\n           vec3 shadingNormal = computeTextureNormal(tangentSpace, ${me?"normalUV":"vuv0"});`:"vec3 shadingNormal = normal;"}
-    vec3 normalGround = ${ie?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
+    ${ce?`mat3 tangentSpace = computeTangentSpace(${te?"normal":"normal, vpos, vuv0"});\n           vec3 shadingNormal = computeTextureNormal(tangentSpace, ${me?"normalUV":"vuv0"});`:"vec3 shadingNormal = normal;"}
+    vec3 normalGround = ${oe?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
 
-    ${_(ae,R`
+    ${B(ie,_`
           float snow = getSnow(normal, normalGround);
           albedo = mix(albedo, vec3(1), snow);
           shadingNormal = mix(shadingNormal, normal, snow);
@@ -62,10 +60,10 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
 
     vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
 
-    ${1===le||2===le?R`
+    ${1===ae||2===ae?_`
             float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
-            ${_(ae,"mrr = applySnowToMRR(mrr, snow);")}
-            vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);`:R`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
+            ${B(ie,"mrr = applySnowToMRR(mrr, snow);")}
+            vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);`:_`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
     vec4 finalColor = vec4(shadedColor, opacity_);
-    outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${_(ae,", snow")});
-  `),K}const K=Object.freeze(Object.defineProperty({__proto__:null,build:J},Symbol.toStringTag,{value:"Module"}));export{K as D,J as b};
+    outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${B(ie,", snow")});
+  `),J}const J=Object.freeze(Object.defineProperty({__proto__:null,build:q},Symbol.toStringTag,{value:"Module"}));export{J as D,q as b};

package/chunks/EdgeShader.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{terrainDepthTest as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{Float2BindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{FloatBindUniform as d}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as l,If as a}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{AdjustProjectedPosition as r}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/AdjustProjectedPosition.glsl.js";import{DiscardNonSilhouetteEdges as c}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/DiscardNonSilhouetteEdges.glsl.js";import{DistanceFalloff as p}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/DistanceFalloff.glsl.js";import{EdgeUtil as P}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/EdgeUtil.glsl.js";import{LineAmplitude as u}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/LineAmplitude.glsl.js";import{LineOffset as f}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/LineOffset.glsl.js";import{UnpackAttributes as g}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/UnpackAttributes.glsl.js";import{ShaderBuilder as v}from"../views/webgl/ShaderBuilder.js";import{Uniform as m}from"../views/webgl/Uniform.js";function x(i){const m=new v,{vertex:x,fragment:L,varyings:A,attributes:b}=m;i.legacy&&x.uniforms.add(new h("model"),new h("localView")),m.include(r,i),m.include(P,i),m.include(u,i),m.include(g,i),m.include(f,i),L.include(o,i),m.include(c,i),m.include(n,i),m.include(p,i),A.add("vColor","vec4"),A.add("vRadius","float"),A.add("vPosition","vec3",{invariant:!0}),A.add("vWorldPosition","vec3",{invariant:!0}),A.add("vLineLengthPixels","float"),A.add("vSizeFalloffFactor","float"),x.uniforms.add(new s("pixelToNDC",({camera:i})=>e(w,2/i.fullViewport[2],2/i.fullViewport[3])),new t("viewport",e=>e.camera.fullViewport),new d("pixelRatio",e=>e.camera.pixelRatio)),b.add("position0","vec3"),b.add("position1","vec3"),b.add("variantOffset","float"),b.add("variantStroke","float"),b.add("variantExtension","float");const j=1===i.type,V=2===i.type,C=1/255,S=1;return x.code.add(l`
+import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Float2BindUniform as n}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{FloatBindUniform as t}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as d,If as l}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{AdjustProjectedPosition as a}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/AdjustProjectedPosition.glsl.js";import{DiscardNonSilhouetteEdges as r}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/DiscardNonSilhouetteEdges.glsl.js";import{DistanceFalloff as c}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/DistanceFalloff.glsl.js";import{EdgeUtil as p}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/EdgeUtil.glsl.js";import{LineAmplitude as P}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/LineAmplitude.glsl.js";import{LineOffset as u}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/LineOffset.glsl.js";import{UnpackAttributes as f}from"../views/3d/webgl-engine/shaders/sources/edgeRenderer/UnpackAttributes.glsl.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";import{Uniform as v}from"../views/webgl/Uniform.js";function m(i){const v=new g,{vertex:m,fragment:h,varyings:L,attributes:A}=v;i.legacy&&m.uniforms.add(new w("model"),new w("localView")),v.include(a,i),v.include(p,i),v.include(P,i),v.include(f,i),v.include(u,i),h.include(o,i),v.include(r,i),v.include(c,i),L.add("vColor","vec4"),L.add("vRadius","float"),L.add("vPosition","vec3",{invariant:!0}),L.add("vWorldPosition","vec3",{invariant:!0}),L.add("vLineLengthPixels","float"),L.add("vSizeFalloffFactor","float"),m.uniforms.add(new n("pixelToNDC",({camera:i})=>e(x,2/i.fullViewport[2],2/i.fullViewport[3])),new s("viewport",e=>e.camera.fullViewport),new t("pixelRatio",e=>e.camera.pixelRatio)),A.add("position0","vec3"),A.add("position1","vec3"),A.add("variantOffset","float"),A.add("variantStroke","float"),A.add("variantExtension","float");const b=1===i.type,j=2===i.type,V=1/255,C=1;return m.code.add(d`
     void calculateGeometricOutputs(vec3 viewPosV0, vec3 viewPosV1, vec3 worldPosV0, vec3 worldPosV1, vec3 worldNormal, UnpackedAttributes unpackedAttributes) {
       vec2 sideness = unpackedAttributes.sideness;
       vec2 sidenessNorm = unpackedAttributes.sidenessNorm;
@@ -7,7 +7,6 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
       vWorldPosition = mix(worldPosV0, worldPosV1, sidenessNorm.y).xyz;
 
       vec3 viewPos = mix(viewPosV0, viewPosV1, sidenessNorm.y);
-      forwardViewPosDepth(viewPos);
 
       vec4 projPosV0 = projFromViewPosition(viewPosV0);
       vec4 projPosV1 = projFromViewPosition(viewPosV1);
@@ -34,8 +33,8 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
       float extendedLineLengthPixels = lineLengthPixels + extensionLengthPixels + extensionLengthPixels;
 
       // Line size with padding
-      float halfAAPaddedLineWidthAndAmplitudePixels = lineWidthAndAmplitudePixels * 0.5 + ${l.float(S)};
-      float aaPaddedRoundedCapSizePixels = lineWidthPixels * 0.5 + ${l.float(S)};
+      float halfAAPaddedLineWidthAndAmplitudePixels = lineWidthAndAmplitudePixels * 0.5 + ${d.float(C)};
+      float aaPaddedRoundedCapSizePixels = lineWidthPixels * 0.5 + ${d.float(C)};
 
       // Half line width in NDC including padding for anti aliasing
       vec2 halfAAPaddedLineWidthAndAmplitudeNDC = halfAAPaddedLineWidthAndAmplitudePixels * pixelToNDC;
@@ -70,12 +69,12 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
       vLineLengthPixels = extendedLineLengthPixels;
 
       // discard short edges below a certain length threshold
-      ${a(j||V,l`if (lineLengthPixels <= 3.0 ${a(V," && unpackedAttributes.type <= 0.0")}) {
+      ${l(b||j,d`if (lineLengthPixels <= 3.0 ${l(j," && unpackedAttributes.type <= 0.0")}) {
                 gl_Position = vec4(10.0, 10.0, 10.0, 1.0);
                 return;
              }`)}
       gl_Position = projPos;
-    }`),x.main.add(l`
+    }`),m.main.add(d`
     ComponentData component = readComponentData();
     UnpackedAttributes unpackedAttributes = unpackAttributes(component);
 
@@ -87,7 +86,7 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
     vColor = component.color;
 
     // Discard fully transparent edges
-    if (vColor.a < ${l.float(C)}) {
+    if (vColor.a < ${d.float(V)}) {
       gl_Position = vec4(10.0, 10.0, 10.0, 1.0);
       return;
     }
@@ -100,7 +99,7 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
     calculateGeometricOutputs(viewPosV0, viewPosV1, worldPosV0, worldPosV1, worldNormal(component), unpackedAttributes);
 
     // Specific computation for different edge styles
-    calculateStyleOutputs(unpackedAttributes);`),L.code.add(l`float lineWithCapsDistance(float radius, vec2 position, float lineLength) {
+    calculateStyleOutputs(unpackedAttributes);`),h.code.add(d`float lineWithCapsDistance(float radius, vec2 position, float lineLength) {
 float positionX = position.x - calculateLineOffset();
 if (radius < 1.0) {
 float coverageX = clamp(min(radius, positionX + 0.5) - max(-radius, positionX - 0.5), 0.0, 1.0);
@@ -111,9 +110,8 @@ else {
 float positionOnCap = position.y - clamp(position.y, 0.0, lineLength);
 return length(vec2(positionX, positionOnCap)) - radius;
 }
-}`),L.main.add(l`discardByTerrainDepth();
-float radius = vRadius * calculateLinePressure();
+}`),h.main.add(d`float radius = vRadius * calculateLinePressure();
 float distance = lineWithCapsDistance(radius, vPosition.xy, vLineLengthPixels);
 float coverage = clamp(0.5 - distance, 0.0, 1.0);
 discardBySlice(vWorldPosition);
-fragColor = vec4(vColor.rgb, vColor.a * coverage);`),m}const w=i();class h extends m{constructor(e){super(e,"mat4")}}const L=Object.freeze(Object.defineProperty({__proto__:null,build:x},Symbol.toStringTag,{value:"Module"}));export{L as E,x as b};
+fragColor = vec4(vColor.rgb, vColor.a * coverage);`),v}const x=i();class w extends v{constructor(e){super(e,"mat4")}}const h=Object.freeze(Object.defineProperty({__proto__:null,build:m},Symbol.toStringTag,{value:"Module"}));export{h as E,m as b};

package/chunks/GaussianSplat.glsl.js

@@ -1,14 +1,14 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{splatAtlasTextureWidth as i,elementsPerSplatPage as t}from"../views/3d/support/gaussianSplatting/GaussianSplatAtlasPages.js";import{RejectBySlicePass as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{EvaluateSceneLighting as r,addAmbientBoostFactor as s,addLightingGlobalFactor as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{positionOutsideClipSpace as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{ReadShadowMapPassFragment as m,ReadShadowMapPassVertex as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ComputeCovariance as v}from"../views/3d/webgl-engine/core/shaderLibrary/util/ComputeCovariance.glsl.js";import{GaussianSplatUnpackingPassParameters as p,GaussianSplatUnpacking as f}from"../views/3d/webgl-engine/core/shaderLibrary/util/GaussianSplatUnpacking.glsl.js";import{QuaternionToRotationMatrix as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/QuaternionToRotationMatrix.glsl.js";import{RgbNormalizedDepthEncoding as x}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{Float2BindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as y}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as b}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as P}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as C}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as S,If as D}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as R}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DUintPassUniform as M}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUintPassUniform.js";import{getGaussianSplatAlphaCutoffValue as z}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as j}from"../views/webgl/ShaderBuilder.js";class F extends p{constructor(){super(...arguments),this.clipMinCameraRelative=n(),this.clipMaxCameraRelative=n(),this.focalLength=-1,this.minSplatRadius=-1,this.tanFov=a(),this.origin=n()}}function T(a){const{clippingEnabled:n,fragmentShadows:i,hasSlicePlane:t,spherical:p}=a,F=new j;F.varyings.add("vColor","vec4"),F.varyings.add("conicOpacity","vec4"),F.varyings.add("gaussianLogAlphaCutoff","float"),F.varyings.add("offsetFromCenter","vec2"),L(a)&&F.varyings.add("fragmentPositionCameraRelative","vec3"),F.vertex.uniforms.add(new M("splatOrderTexture",e=>e.splatOrder),new M("splatFadingTexture",e=>e.splatFading),new M("splatAtlasTexture",e=>e.splatAtlas),new C("focalLength",e=>e.focalLength),new C("minSplatRadius",e=>e.minSplatRadius),new y("tanFov",e=>e.tanFov),new w("inverseScreenSize",({camera:a})=>e(A,1/a.fullWidth,1/a.fullHeight)),new R("proj",e=>e.camera.projectionMatrix),new R("view",e=>e.camera.viewMatrix),new w("nearFar",e=>e.camera.nearFar),new b("cameraPosition",e=>e.camera.eye)),n&&(F.vertex.uniforms.add(new P("clipMin",e=>e.clipMinCameraRelative),new P("clipMax",e=>e.clipMaxCameraRelative)),F.fragment.uniforms.add(new P("clipMin",e=>e.clipMinCameraRelative),new P("clipMax",e=>e.clipMaxCameraRelative))),F.vertex.include(f),F.vertex.include(h),F.vertex.include(v),F.vertex.include(o,a),i?(F.fragment.uniforms.add(new b("cameraPosition",e=>e.camera.eye)),F.fragment.include(r,a)):F.vertex.include(r,a),F.include(c,a),s(i?F.fragment:F.vertex),l(i?F.fragment:F.vertex),F.include(u,a),F.include(i?m:g,a),F.outputs.add("fragColor","vec4",0),F.outputs.add("fragDepthColor","vec4",1);const T=z(a.alphaCutoff),B=Math.log(T),O=S`float groundLightAlignment = dot(groundNormal, mainLightDirection);
+import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{splatAtlasTextureWidth as i,elementsPerSplatPage as t}from"../views/3d/support/gaussianSplatting/GaussianSplatAtlasPages.js";import{RejectBySlicePass as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{EvaluateSceneLighting as r,addAmbientBoostFactor as s,addLightingGlobalFactor as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{positionOutsideClipSpace as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{ReadShadowMapPassFragment as m,ReadShadowMapPassVertex as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{ComputeCovariance as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/ComputeCovariance.glsl.js";import{GaussianSplatUnpackingPassParameters as v,GaussianSplatUnpacking as p}from"../views/3d/webgl-engine/core/shaderLibrary/util/GaussianSplatUnpacking.glsl.js";import{QuaternionToRotationMatrix as f}from"../views/3d/webgl-engine/core/shaderLibrary/util/QuaternionToRotationMatrix.glsl.js";import{RgbNormalizedDepthEncoding as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{Float2BindUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as y}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as b}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as P}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as C,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as R}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DUintPassUniform as D}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUintPassUniform.js";import{getGaussianSplatAlphaCutoffValue as M}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as z}from"../views/webgl/ShaderBuilder.js";class j extends v{constructor(){super(...arguments),this.clipMinCameraRelative=n(),this.clipMaxCameraRelative=n(),this.focalLength=-1,this.minSplatRadius=-1,this.tanFov=a(),this.origin=n()}}function F(a){const{clippingEnabled:n,fragmentShadows:i,hasSlicePlane:t,spherical:v}=a,j=new z;j.varyings.add("vColor","vec4"),j.varyings.add("conicOpacity","vec4"),j.varyings.add("gaussianLogAlphaCutoff","float"),j.varyings.add("offsetFromCenter","vec2"),L(a)&&j.varyings.add("fragmentPositionCameraRelative","vec3"),j.vertex.uniforms.add(new D("splatOrderTexture",e=>e.splatOrder),new D("splatFadingTexture",e=>e.splatFading),new D("splatAtlasTexture",e=>e.splatAtlas),new P("focalLength",e=>e.focalLength),new P("minSplatRadius",e=>e.minSplatRadius),new w("tanFov",e=>e.tanFov),new x("inverseScreenSize",({camera:a})=>e(T,1/a.fullWidth,1/a.fullHeight)),new R("proj",e=>e.camera.projectionMatrix),new R("view",e=>e.camera.viewMatrix),new x("nearFar",e=>e.camera.nearFar),new y("cameraPosition",e=>e.camera.eye)),n&&(j.vertex.uniforms.add(new b("clipMin",e=>e.clipMinCameraRelative),new b("clipMax",e=>e.clipMaxCameraRelative)),j.fragment.uniforms.add(new b("clipMin",e=>e.clipMinCameraRelative),new b("clipMax",e=>e.clipMaxCameraRelative))),j.vertex.include(p),j.vertex.include(f),j.vertex.include(g),j.vertex.include(o,a),i?(j.fragment.uniforms.add(new y("cameraPosition",e=>e.camera.eye)),j.fragment.include(r,a)):j.vertex.include(r,a),j.include(c,a),s(i?j.fragment:j.vertex),l(i?j.fragment:j.vertex),j.include(i?m:u,a),j.outputs.add("fragColor","vec4",0),j.outputs.add("fragDepthColor","vec4",1);const F=M(a.alphaCutoff),k=Math.log(F),B=C`float groundLightAlignment = dot(groundNormal, mainLightDirection);
 float additionalAmbientScale = additionalDirectedAmbientLight(groundLightAlignment);
-vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,E=S`
-    vec3 groundNormal = ${p?S`normalize(cameraRelativePosition + cameraPosition)`:S`vec3(0.0, 0.0, 1.0)`};
-    ${O}
+vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,O=C`
+    vec3 groundNormal = ${v?C`normalize(cameraRelativePosition + cameraPosition)`:C`vec3(0.0, 0.0, 1.0)`};
+    ${B}
     float shadow = readShadowVertex(additionalAmbientScale, cameraRelativePosition, -viewPos.z);
     vColor.rgb = evaluateSceneLighting(groundNormal, vColor.rgb, shadow, 0.0, additionalLight);
-  `,N=S`
-    vec3 groundNormal = ${p?S`normalize(fragmentPositionCameraRelative + cameraPosition)`:S`vec3(0.0, 0.0, 1.0)`};
-    ${O}
+  `,E=C`
+    vec3 groundNormal = ${v?C`normalize(fragmentPositionCameraRelative + cameraPosition)`:C`vec3(0.0, 0.0, 1.0)`};
+    ${B}
     float shadow = readShadow(additionalAmbientScale, fragmentPositionCameraRelative);
     shadedColor = evaluateSceneLighting(groundNormal, vColor.rgb, shadow, 0.0, additionalLight);
-  `;return F.vertex.main.add(`\n    uint instanceID = uint(gl_InstanceID);\n\n    // Transform the instanceID into 2D coordinates\n    uint orderTextureWidth = uint(textureSize(splatOrderTexture, 0).x);\n    uint x = instanceID % orderTextureWidth;\n    uint y = instanceID / orderTextureWidth;\n\n    // Fetch the index of the remaining frontmost Gaussian\n    uint gaussianIndex = texelFetch(splatOrderTexture, ivec2(x, y), 0).r;\n\n    // Fetch the packed Gaussian according to the index\n    uint gaussianIndexX = gaussianIndex & ${I}u;\n    uint gaussianIndexY = gaussianIndex >> ${$}u;\n    uvec4 packedGaussian = texelFetch(splatAtlasTexture, ivec2(gaussianIndexX, gaussianIndexY), 0);\n\n    uint pageNum = gaussianIndex >> ${k}u;\n\n    // Unpack the Gaussian\n    vColor = unpackColor(packedGaussian);\n\n    // Handle fading\n    ${D(a.fadingEnabled,"\n      uint fadingTextureWidth = uint(textureSize(splatFadingTexture, 0).x);\n      uint fadeX = pageNum  % fadingTextureWidth;\n      uint fadeY = pageNum  / fadingTextureWidth;\n      uint opacityModifierByte = texelFetch(splatFadingTexture, ivec2(fadeX , fadeY), 0).r;\n      float opacityModifier = float(opacityModifierByte) / 255.0;\n      vColor.a *= opacityModifier;\n      ")}\n\n    // set default position outside clipspace for early returns\n    gl_Position = ${d};\n\n    if(vColor.a < ${T}) {\n      return;\n    }\n\n    // Delay the page header fetch until the splat survives the opacity reject.\n    uint headerIndex = gaussianIndex | ${G}u;\n    uint headerIndexX = headerIndex & ${I}u;\n    uint headerIndexY = headerIndex >> ${$}u;\n    uvec4 packedHeader = texelFetch(splatAtlasTexture, ivec2(headerIndexX, headerIndexY), 0);\n\n    vec3 tileOriginRelativePosition = unpackTileOriginRelativePosition(packedGaussian);\n    vec3 cameraRelativePosition = unpackCameraRelativeGaussianPosition(packedHeader, tileOriginRelativePosition);\n\n    ${D(n,"\n      if (cameraRelativePosition.x < clipMin.x || cameraRelativePosition.y < clipMin.y || cameraRelativePosition.z < clipMin.z ||\n        cameraRelativePosition.x > clipMax.x || cameraRelativePosition.y > clipMax.y || cameraRelativePosition.z > clipMax.z) {\n        return;\n      }\n      ")}\n\n    ${D(t,"if (rejectBySlice(cameraRelativePosition)) {\n        return;\n      }")}\n\n    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1);\n\n    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {\n      return;\n    }\n\n    vec3 scale = unpackScale(packedGaussian);\n    vec4 quaternion = unpackQuaternion(packedGaussian);\n    mat3 rotation = quaternionToRotationMatrix(quaternion);\n\n    vec3 covarianceA;\n    vec3 covarianceB;\n    computeCovariance3D(rotation, scale.xyz, covarianceA, covarianceB);\n\n    float covariance3D[6] = float[6](covarianceA.x, covarianceA.y, covarianceA.z, covarianceB.x, covarianceB.y, covarianceB.z);\n\n    vec3 covariance2D = computeCovariance2D(viewPos.xyz, focalLength, tanFov, covariance3D, view);\n\n    // Invert covariance (EWA algorithm)\n    float determinant = (covariance2D.x * covariance2D.z - covariance2D.y * covariance2D.y);\n    if (determinant <= 0.) {\n      return;\n    }\n\n    // Compute the Gaussians extent in screen space by finding the eigenvalues lambda1 and lambda2\n    // of the 2D covariance matrix\n    float mid = 0.5 * (covariance2D.x + covariance2D.z);\n    float radius = length(vec2((covariance2D.x - covariance2D.z) * 0.5, covariance2D.y));\n    float lambda1 = mid + radius;\n    float lambda2 = mid - radius;\n\n\n    // Fold the per-splat opacity into the log cutoff so the vertex-side ellipse\n    // bound matches the fragment alpha discard after fading.\n    gaussianLogAlphaCutoff = ${B} - log(vColor.a);\n        // Compute the extents along the principal axes\n    float gaussianEllipseThreshold = max(0.0, -2.0 * gaussianLogAlphaCutoff);\n    float l1 = ceil(sqrt(lambda1 * gaussianEllipseThreshold));\n    float l2 = ceil(sqrt(lambda2 * gaussianEllipseThreshold));\n\n    float maxRadius = max(l1, l2);\n\n    // Ignore gaussians with very small contribution, with tolerance based on the quality profile\n    if(minSplatRadius > 0.0) {\n      float effectiveSize = maxRadius * vColor.a;\n      if(effectiveSize < minSplatRadius) {\n        return;\n      }\n    }\n\n    vec4 projPos = proj * viewPos;\n    float invW = 1. / (projPos.w + 1e-7);\n    vec3 ndcPos = projPos.xyz * invW;\n    vec2 clipSpacePixelScale = 2.0 * inverseScreenSize;\n\n    // Screen space frustum culling\n    vec2 radiusNDC = maxRadius * clipSpacePixelScale;\n\n    if (any(greaterThan(abs(ndcPos.xy) - radiusNDC, vec2(1.0)))) {\n        return;\n    }\n\n    // Compute the principal diagonal direction (eigenvector for lambda1)\n    vec2 diagonalVector = normalize(vec2(covariance2D.y, lambda1 - covariance2D.x));\n\n    vec2 majorAxis = l1 * diagonalVector;\n    vec2 minorAxis = l2 * vec2(diagonalVector.y, -diagonalVector.x);\n\n    // This maps vertex IDs 0, 1, 2, 3 to (-1,-1), (1,-1), (-1,1), (1,1)\n    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.0;\n    offsetFromCenter = corner.x * majorAxis + corner.y * minorAxis;\n\n    ${D(L(a),"float viewSpacePixelScale = -viewPos.z / focalLength;\n      vec3 fragmentViewOffset = vec3(offsetFromCenter * viewSpacePixelScale, 0.0);\n      fragmentPositionCameraRelative = cameraRelativePosition + transpose(mat3(view)) * fragmentViewOffset;")}\n\n    float invDeterminant = 1. / determinant;\n\n    // We use a conic function to derive the opacity\n    vec3 conic = vec3(covariance2D.z, -covariance2D.y, covariance2D.x) * invDeterminant;\n    conicOpacity = vec4(conic, vColor.a);\n\n    forwardViewPosDepth(viewPos.xyz);\n\n    // Handle environment (scene lighting) per vertex, delay to fragment shader if fragment shadows are enabled\n    // for a crisper shadow border at the cost of more computations in the fragment shader\n    ${D(i,"forwardLinearDepth(-viewPos.z);",E)}\n\n    // Convert from screen-space to clip-space using center + offset\n    vec2 clipPos = ndcPos.xy + offsetFromCenter * clipSpacePixelScale - inverseScreenSize;\n\n    gl_Position = vec4(clipPos, ndcPos.z, 1.0);\n\n  `),F.fragment.include(x),F.fragment.include(o,a),F.fragment.main.add(`\n    ${D(n,"if (fragmentPositionCameraRelative.x < clipMin.x || fragmentPositionCameraRelative.y < clipMin.y || fragmentPositionCameraRelative.z < clipMin.z ||\n        fragmentPositionCameraRelative.x > clipMax.x || fragmentPositionCameraRelative.y > clipMax.y || fragmentPositionCameraRelative.z > clipMax.z) {\n        discard;\n      }")}\n    ${D(t,"if (rejectBySlice(fragmentPositionCameraRelative)) { discard; }")}\n\n    // Evaluate the 2D elliptical Gaussian exponent using the general conic form: Ax^2+2Bxy+Cy^2\n    float x = offsetFromCenter.x;\n    float y = offsetFromCenter.y;\n    float conic = dot(conicOpacity.xyz, vec3(x * x, 2.0 * x * y, y * y));\n    float gaussianExponent = -0.5 * conic;\n\n    // A positive exponent indicates alpha > 1, this should not happen\n    // We also early check the opacity-aware alpha cutoff to avoid unnecessary exp().\n    if (gaussianExponent > 0.0 || gaussianExponent < gaussianLogAlphaCutoff) {\n      discard;\n    }\n\n    discardByTerrainDepth();\n\n    float gaussianFalloff = exp(gaussianExponent);\n\n    // cap at 0.99 to avoid blending issues, such as seams between overlapping Gaussians\n    float alpha = min(.99f, conicOpacity.w * gaussianFalloff);\n\n    vec3 shadedColor = vColor.rgb;\n  ${D(i,N)}\n    fragColor = vec4(shadedColor * alpha, alpha);\n\n    // We simulate first hit based depth using 0.25 as the opacity threshold.\n    // This works because we render in front-to-back order,\n    // i.e. the first hit that counts completelly saturates the alpha channel\n    // and further splats do not contribute.\n    float countHit = step(0.25, alpha);\n    float normalizedDepth = gl_FragCoord.z;\n    fragDepthColor = vec4(encodeNormalizedDepthToRGB(normalizedDepth) * countHit, countHit);\n  `),F}function L(e){const{clippingEnabled:a,fragmentShadows:n,hasSlicePlane:i}=e;return n||i||a}const A=a(),I=i-1,$=Math.log2(i),G=t-1,k=Math.log2(t),B=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatPassParameters:F,build:T},Symbol.toStringTag,{value:"Module"}));export{F as G,B as a,T as b};
+  `;return j.vertex.main.add(`\n    uint instanceID = uint(gl_InstanceID);\n\n    // Transform the instanceID into 2D coordinates\n    uint orderTextureWidth = uint(textureSize(splatOrderTexture, 0).x);\n    uint x = instanceID % orderTextureWidth;\n    uint y = instanceID / orderTextureWidth;\n\n    // Fetch the index of the remaining frontmost Gaussian\n    uint gaussianIndex = texelFetch(splatOrderTexture, ivec2(x, y), 0).r;\n\n    // Fetch the packed Gaussian according to the index\n    uint gaussianIndexX = gaussianIndex & ${A}u;\n    uint gaussianIndexY = gaussianIndex >> ${I}u;\n    uvec4 packedGaussian = texelFetch(splatAtlasTexture, ivec2(gaussianIndexX, gaussianIndexY), 0);\n\n    uint pageNum = gaussianIndex >> ${G}u;\n\n    // Unpack the Gaussian\n    vColor = unpackColor(packedGaussian);\n\n    // Handle fading\n    ${S(a.fadingEnabled,"\n      uint fadingTextureWidth = uint(textureSize(splatFadingTexture, 0).x);\n      uint fadeX = pageNum  % fadingTextureWidth;\n      uint fadeY = pageNum  / fadingTextureWidth;\n      uint opacityModifierByte = texelFetch(splatFadingTexture, ivec2(fadeX , fadeY), 0).r;\n      float opacityModifier = float(opacityModifierByte) / 255.0;\n      vColor.a *= opacityModifier;\n      ")}\n\n    // set default position outside clipspace for early returns\n    gl_Position = ${d};\n\n    if(vColor.a < ${F}) {\n      return;\n    }\n\n    // Delay the page header fetch until the splat survives the opacity reject.\n    uint headerIndex = gaussianIndex | ${$}u;\n    uint headerIndexX = headerIndex & ${A}u;\n    uint headerIndexY = headerIndex >> ${I}u;\n    uvec4 packedHeader = texelFetch(splatAtlasTexture, ivec2(headerIndexX, headerIndexY), 0);\n\n    vec3 tileOriginRelativePosition = unpackTileOriginRelativePosition(packedGaussian);\n    vec3 cameraRelativePosition = unpackCameraRelativeGaussianPosition(packedHeader, tileOriginRelativePosition);\n\n    ${S(n,"\n      if (cameraRelativePosition.x < clipMin.x || cameraRelativePosition.y < clipMin.y || cameraRelativePosition.z < clipMin.z ||\n        cameraRelativePosition.x > clipMax.x || cameraRelativePosition.y > clipMax.y || cameraRelativePosition.z > clipMax.z) {\n        return;\n      }\n      ")}\n\n    ${S(t,"if (rejectBySlice(cameraRelativePosition)) {\n        return;\n      }")}\n\n    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1);\n\n    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {\n      return;\n    }\n\n    vec3 scale = unpackScale(packedGaussian);\n    vec4 quaternion = unpackQuaternion(packedGaussian);\n    mat3 rotation = quaternionToRotationMatrix(quaternion);\n\n    vec3 covarianceA;\n    vec3 covarianceB;\n    computeCovariance3D(rotation, scale.xyz, covarianceA, covarianceB);\n\n    float covariance3D[6] = float[6](covarianceA.x, covarianceA.y, covarianceA.z, covarianceB.x, covarianceB.y, covarianceB.z);\n\n    vec3 covariance2D = computeCovariance2D(viewPos.xyz, focalLength, tanFov, covariance3D, view);\n\n    // Invert covariance (EWA algorithm)\n    float determinant = (covariance2D.x * covariance2D.z - covariance2D.y * covariance2D.y);\n    if (determinant <= 0.) {\n      return;\n    }\n\n    // Compute the Gaussians extent in screen space by finding the eigenvalues lambda1 and lambda2\n    // of the 2D covariance matrix\n    float mid = 0.5 * (covariance2D.x + covariance2D.z);\n    float radius = length(vec2((covariance2D.x - covariance2D.z) * 0.5, covariance2D.y));\n    float lambda1 = mid + radius;\n    float lambda2 = mid - radius;\n\n\n    // Fold the per-splat opacity into the log cutoff so the vertex-side ellipse\n    // bound matches the fragment alpha discard after fading.\n    gaussianLogAlphaCutoff = ${k} - log(vColor.a);\n        // Compute the extents along the principal axes\n    float gaussianEllipseThreshold = max(0.0, -2.0 * gaussianLogAlphaCutoff);\n    float l1 = ceil(sqrt(lambda1 * gaussianEllipseThreshold));\n    float l2 = ceil(sqrt(lambda2 * gaussianEllipseThreshold));\n\n    float maxRadius = max(l1, l2);\n\n    // Ignore gaussians with very small contribution, with tolerance based on the quality profile\n    if(minSplatRadius > 0.0) {\n      float effectiveSize = maxRadius * vColor.a;\n      if(effectiveSize < minSplatRadius) {\n        return;\n      }\n    }\n\n    vec4 projPos = proj * viewPos;\n    float invW = 1. / (projPos.w + 1e-7);\n    vec3 ndcPos = projPos.xyz * invW;\n    vec2 clipSpacePixelScale = 2.0 * inverseScreenSize;\n\n    // Screen space frustum culling\n    vec2 radiusNDC = maxRadius * clipSpacePixelScale;\n\n    if (any(greaterThan(abs(ndcPos.xy) - radiusNDC, vec2(1.0)))) {\n        return;\n    }\n\n    // Compute the principal diagonal direction (eigenvector for lambda1)\n    vec2 diagonalVector = normalize(vec2(covariance2D.y, lambda1 - covariance2D.x));\n\n    vec2 majorAxis = l1 * diagonalVector;\n    vec2 minorAxis = l2 * vec2(diagonalVector.y, -diagonalVector.x);\n\n    // This maps vertex IDs 0, 1, 2, 3 to (-1,-1), (1,-1), (-1,1), (1,1)\n    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.0;\n    offsetFromCenter = corner.x * majorAxis + corner.y * minorAxis;\n\n    ${S(L(a),"float viewSpacePixelScale = -viewPos.z / focalLength;\n      vec3 fragmentViewOffset = vec3(offsetFromCenter * viewSpacePixelScale, 0.0);\n      fragmentPositionCameraRelative = cameraRelativePosition + transpose(mat3(view)) * fragmentViewOffset;")}\n\n    float invDeterminant = 1. / determinant;\n\n    // We use a conic function to derive the opacity\n    vec3 conic = vec3(covariance2D.z, -covariance2D.y, covariance2D.x) * invDeterminant;\n    conicOpacity = vec4(conic, vColor.a);\n\n    // Handle environment (scene lighting) per vertex, delay to fragment shader if fragment shadows are enabled\n    // for a crisper shadow border at the cost of more computations in the fragment shader\n    ${S(i,"forwardLinearDepth(-viewPos.z);",O)}\n\n    // Convert from screen-space to clip-space using center + offset\n    vec2 clipPos = ndcPos.xy + offsetFromCenter * clipSpacePixelScale - inverseScreenSize;\n\n    gl_Position = vec4(clipPos, ndcPos.z, 1.0);\n\n  `),j.fragment.include(h),j.fragment.include(o,a),j.fragment.main.add(`\n    ${S(n,"if (fragmentPositionCameraRelative.x < clipMin.x || fragmentPositionCameraRelative.y < clipMin.y || fragmentPositionCameraRelative.z < clipMin.z ||\n        fragmentPositionCameraRelative.x > clipMax.x || fragmentPositionCameraRelative.y > clipMax.y || fragmentPositionCameraRelative.z > clipMax.z) {\n        discard;\n      }")}\n    ${S(t,"if (rejectBySlice(fragmentPositionCameraRelative)) { discard; }")}\n\n    // Evaluate the 2D elliptical Gaussian exponent using the general conic form: Ax^2+2Bxy+Cy^2\n    float x = offsetFromCenter.x;\n    float y = offsetFromCenter.y;\n    float conic = dot(conicOpacity.xyz, vec3(x * x, 2.0 * x * y, y * y));\n    float gaussianExponent = -0.5 * conic;\n\n    // A positive exponent indicates alpha > 1, this should not happen\n    // We also early check the opacity-aware alpha cutoff to avoid unnecessary exp().\n    if (gaussianExponent > 0.0 || gaussianExponent < gaussianLogAlphaCutoff) {\n      discard;\n    }\n\n    float gaussianFalloff = exp(gaussianExponent);\n\n    // cap at 0.99 to avoid blending issues, such as seams between overlapping Gaussians\n    float alpha = min(.99f, conicOpacity.w * gaussianFalloff);\n\n    vec3 shadedColor = vColor.rgb;\n  ${S(i,E)}\n    fragColor = vec4(shadedColor * alpha, alpha);\n\n    // We simulate first hit based depth using 0.25 as the opacity threshold.\n    // This works because we render in front-to-back order,\n    // i.e. the first hit that counts completelly saturates the alpha channel\n    // and further splats do not contribute.\n    float countHit = step(0.25, alpha);\n    float normalizedDepth = gl_FragCoord.z;\n    fragDepthColor = vec4(encodeNormalizedDepthToRGB(normalizedDepth) * countHit, countHit);\n  `),j}function L(e){const{clippingEnabled:a,fragmentShadows:n,hasSlicePlane:i}=e;return n||i||a}const T=a(),A=i-1,I=Math.log2(i),$=t-1,G=Math.log2(t),k=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatPassParameters:j,build:F},Symbol.toStringTag,{value:"Module"}));export{j as G,k as a,F as b};