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

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};

package/chunks/ImageMaterial.glsl.js

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

package/chunks/LineCallout.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{ZEROS as r}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{RejectBySliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{AlignPixel as t}from"../views/3d/webgl-engine/core/shaderLibrary/hud/AlignPixel.glsl.js";import{HUD as a}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js";import{multipassGeometryTest as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassGeometryTest.glsl.js";import{addScreenSizePerspectiveAlignment as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ScreenSizePerspective.glsl.js";import{Float2BindUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float4BindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as g}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as f,If as v}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOLID as S}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";function h(i){const h=new m,{vertex:b,fragment:z}=h,{terrainDepthTest:x}=i;return b.include(t),h.include(a,i),h.vertex.include(o,i),i.hudDepth||h.include(S,i),h.attributes.add("uv0","vec2"),b.uniforms.add(new c("viewport",e=>e.camera.fullViewport),new g("lineSize",(e,i)=>e.size>0?Math.max(1,e.size)*i.camera.pixelRatio:0),new d("pixelToNDC",i=>e(u,2/i.camera.fullViewport[2],2/i.camera.fullViewport[3])),new g("borderSize",(e,i)=>e.borderColor?i.camera.pixelRatio:0),new s("screenOffset",(i,r)=>e(u,i.horizontalScreenOffset*r.camera.pixelRatio,0))),h.varyings.add("coverageSampling","vec4"),h.varyings.add("lineSizes","vec2"),x&&h.varyings.add("depth","float"),i.hasScreenSizePerspective&&l(b),b.main.add(f`
+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{ZEROS as r}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{RejectBySliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{AlignPixel as t}from"../views/3d/webgl-engine/core/shaderLibrary/hud/AlignPixel.glsl.js";import{HUD as a}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js";import{addScreenSizePerspectiveAlignment as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/ScreenSizePerspective.glsl.js";import{Float2BindUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float4BindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as g,If as f}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOLID as S}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as v}from"../views/webgl/ShaderBuilder.js";function m(i){const m=new v,{vertex:u,fragment:b}=m;return u.include(t),m.include(a,i),m.vertex.include(o,i),i.hudDepth||m.include(S,i),m.attributes.add("uv0","vec2"),u.uniforms.add(new c("viewport",e=>e.camera.fullViewport),new p("lineSize",(e,i)=>e.size>0?Math.max(1,e.size)*i.camera.pixelRatio:0),new l("pixelToNDC",i=>e(w,2/i.camera.fullViewport[2],2/i.camera.fullViewport[3])),new p("borderSize",(e,i)=>e.borderColor?i.camera.pixelRatio:0),new d("screenOffset",(i,r)=>e(w,i.horizontalScreenOffset*r.camera.pixelRatio,0))),m.varyings.add("coverageSampling","vec4"),m.varyings.add("lineSizes","vec2"),i.hasScreenSizePerspective&&n(u),u.main.add(g`
     ProjectHUDAux projectAux;
     vec4 endPoint = projectPositionHUD(projectAux);
 
@@ -9,12 +9,11 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
       return;
     }
 
-    ${i.hasScreenSizePerspective?f`vec3 perspectiveFactor = screenSizePerspectiveScaleFactor(projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspectiveAlignment);
+    ${i.hasScreenSizePerspective?g`vec3 perspectiveFactor = screenSizePerspectiveScaleFactor(projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspectiveAlignment);
                vec2 screenOffsetScaled = applyScreenSizePerspectiveScaleFactorVec2(screenOffset, perspectiveFactor);`:"vec2 screenOffsetScaled = screenOffset;"}
     // Add view dependent polygon offset to get exact same original starting point. This is mostly used to get the
     // correct depth value
     vec3 posView = (view * vec4(position, 1.0)).xyz;
-    ${v(x,"depth = posView.z;")}
 
     applyHUDViewDependentPolygonOffset(groundDistance, projectAux.absCosAngle, posView);
     vec4 startPoint = proj * vec4(posView, 1.0);
@@ -27,14 +26,14 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
     // Align start and end to pixel origin
     vec4 startAligned = alignToPixelOrigin(startPoint, viewport.zw);
     vec4 endAligned = alignToPixelOrigin(endPoint, viewport.zw);
-    ${v(i.hudDepth,i.hudDepthAlignStart?"endAligned = vec4(endAligned.xy / endAligned.w * startAligned.w, startAligned.zw);":"startAligned = vec4(startAligned.xy / startAligned.w * endAligned.w, endAligned.zw);")}
+    ${f(i.hudDepth,i.hudDepthAlignStart?"endAligned = vec4(endAligned.xy / endAligned.w * startAligned.w, startAligned.zw);":"startAligned = vec4(startAligned.xy / startAligned.w * endAligned.w, endAligned.zw);")}
     vec4 projectedPosition = mix(startAligned, endAligned, uv0.y);
 
     // The direction of the line in screen space
     vec2 screenSpaceDirection = normalize(endAligned.xy / endAligned.w - startAligned.xy / startAligned.w);
     vec2 perpendicularScreenSpaceDirection = vec2(screenSpaceDirection.y, -screenSpaceDirection.x);
-    ${i.hasScreenSizePerspective?f`float lineSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(lineSize, perspectiveFactor);
-               float borderSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(borderSize, perspectiveFactor);`:f`float lineSizeScaled = lineSize;
+    ${i.hasScreenSizePerspective?g`float lineSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(lineSize, perspectiveFactor);
+               float borderSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(borderSize, perspectiveFactor);`:g`float lineSizeScaled = lineSize;
                float borderSizeScaled = borderSize;`}
     float halfPixelSize = lineSizeScaled * 0.5;
 
@@ -72,16 +71,14 @@ import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as i}f
     );
 
     lineSizes = vec2(lineSizeScaled, borderSizeScaled);
-    gl_Position = projectedPosition;`),z.uniforms.add(new p("uColor",e=>e.color??r),new p("borderColor",e=>e.borderColor??r)),x&&(z.include(n,i),z.uniforms.add(new d("inverseViewport",e=>e.inverseViewport))),z.main.add(f`
-    ${v(x,"if( geometryDepthTest(gl_FragCoord.xy * inverseViewport, depth) ){ discard; }")}
-
+    gl_Position = projectedPosition;`),b.uniforms.add(new s("uColor",e=>e.color??r),new s("borderColor",e=>e.borderColor??r)),b.main.add(g`
     vec2 coverage = min(1.0 - clamp(abs(coverageSampling.xy) - coverageSampling.zw, 0.0, 1.0), lineSizes);
 
     float borderAlpha = uColor.a * borderColor.a * coverage.y;
     float colorAlpha = uColor.a * coverage.x;
 
     float finalAlpha = mix(borderAlpha, 1.0, colorAlpha);
-    ${v(i.hudDepth,f`
-    if (max(coverage.x, coverage.y) < ${f.float(w)}) discard;`,f`
+    ${f(i.hudDepth,g`
+    if (max(coverage.x, coverage.y) < ${g.float(h)}) discard;`,g`
     vec3 finalRgb = mix(borderColor.rgb * borderAlpha, uColor.rgb, colorAlpha);
-    outputColorHighlightOLID(vec4(finalRgb, finalAlpha), finalRgb);`)}`),h}const w=.5,u=i(),b=Object.freeze(Object.defineProperty({__proto__:null,build:h},Symbol.toStringTag,{value:"Module"}));export{b as L,h as b};
+    outputColorHighlightOLID(vec4(finalRgb, finalAlpha), finalRgb);`)}`),m}const h=.5,w=i(),u=Object.freeze(Object.defineProperty({__proto__:null,build:m},Symbol.toStringTag,{value:"Module"}));export{u as L,m as b};

package/chunks/LineMarker.glsl.js

@@ -1,29 +1,29 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{markerTextureSize as e,markerSymbolSize as r,markerTipThicknessFactor as i}from"../views/3d/support/engineContent/marker.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{OutputHighlight as a}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{MarkerSizing as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{positionOutsideClipSpace as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{terrainDepthTest as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as p,NoPerspectiveRead as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as v,addViewNormal as m,addPixelRatio as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2BindUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as y,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DPassUniform as b}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{outputColorHighlightOLID as P}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as z}from"../views/webgl/ShaderBuilder.js";function j(j){const L=new z,{space:D,anchor:k,hasTip:M,hasScreenSizePerspective:C}=j,$=2===D,W=1===D;L.include(t,j),L.include(n,j),L.include(l,j);const{vertex:O,fragment:U,varyings:T}=L;v(O,j),L.attributes.add("position","vec3"),L.attributes.add("previousDelta","vec4"),L.attributes.add("uv0","vec2"),T.add("vColor","vec4"),T.add("vpos","vec3",{invariant:!0}),T.add("vUV","vec2"),T.add("vSize","float"),M&&T.add("vLineWidth","float"),O.uniforms.add(new f("nearFar",({camera:e})=>e.nearFar),new g("viewport",({camera:e})=>e.fullViewport)).code.add(y`vec4 projectAndScale(vec4 pos) {
+import{markerTextureSize as e,markerSymbolSize as r,markerTipThicknessFactor as i}from"../views/3d/support/engineContent/marker.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{OutputHighlight as a}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{MarkerSizing as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{positionOutsideClipSpace as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{ColorConversion as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as c,NoPerspectiveRead as p}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as d,addViewNormal as v,addPixelRatio as m}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2BindUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as u}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as w,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as y}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DPassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{outputColorHighlightOLID as P}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as b}from"../views/webgl/ShaderBuilder.js";function z(z){const j=new b,{space:L,anchor:k,hasTip:D,hasScreenSizePerspective:M}=z,C=2===L,$=1===L;j.attributes.add("position","vec3"),j.vertex.inputs.add("position",()=>"position"),j.include(t,z),j.include(n,z);const{vertex:W,fragment:O,varyings:U}=j;d(W,z),j.attributes.add("previousDelta","vec4"),j.attributes.add("uv0","vec2"),U.add("vColor","vec4"),U.add("vpos","vec3",{invariant:!0}),U.add("vUV","vec2"),U.add("vSize","float"),D&&U.add("vLineWidth","float"),W.uniforms.add(new h("nearFar",({camera:e})=>e.nearFar),new f("viewport",({camera:e})=>e.fullViewport)).code.add(w`vec4 projectAndScale(vec4 pos) {
 vec4 posNdc = proj * pos;
 posNdc.xy *= viewport.zw / posNdc.w;
 return posNdc;
-}`),O.code.add(y`void clip(vec4 pos, inout vec4 prev) {
+}`),W.code.add(w`void clip(vec4 pos, inout vec4 prev) {
 float vnp = nearFar[0] * 0.99;
 if (prev.z > -nearFar[0]) {
 float interpolation = (-vnp - pos.z) / (prev.z - pos.z);
 prev = mix(pos, prev, interpolation);
 }
-}`),$?(L.attributes.add("normal","vec3"),m(O),O.constants.add("tiltThreshold","float",.7),O.code.add(y`vec3 perpendicular(vec3 v) {
+}`),C?(j.attributes.add("normal","vec3"),v(W),W.constants.add("tiltThreshold","float",.7),W.code.add(w`vec3 perpendicular(vec3 v) {
 vec3 n = (viewNormal * vec4(normal.xyz, 1.0)).xyz;
 vec3 n2 = cross(v, n);
 vec3 forward = vec3(0.0, 0.0, 1.0);
 float tiltDot = dot(forward, n);
 return abs(tiltDot) < tiltThreshold ? n : n2;
-}`)):O.code.add(y`vec2 perpendicular(vec2 v) {
+}`)):W.code.add(w`vec2 perpendicular(vec2 v) {
 return vec2(v.y, -v.x);
-}`);const N=$?"vec3":"vec2";return O.code.add(y`
+}`);const N=C?"vec3":"vec2";return W.code.add(w`
       ${N} normalizedSegment(${N} pos, ${N} prev) {
         ${N} segment = pos - prev;
         float segmentLen = length(segment);
 
         // normalize or zero if too short
-        return (segmentLen > 0.001) ? segment / segmentLen : ${$?"vec3(0.0, 0.0, 0.0)":"vec2(0.0, 0.0)"};
+        return (segmentLen > 0.001) ? segment / segmentLen : ${C?"vec3(0.0, 0.0, 0.0)":"vec2(0.0, 0.0)"};
       }
 
       ${N} displace(${N} pos, ${N} prev, float displacementLen) {
@@ -36,15 +36,15 @@ return vec2(v.y, -v.x);
 
         return pos + displacementLen * (uv0.x * displacementDirU + uv0.y * displacementDirV);
       }
-    `),W&&(O.uniforms.add(new x("inverseProjectionMatrix",({camera:e})=>e.inverseProjectionMatrix)),O.code.add(y`vec3 inverseProject(vec4 posScreen) {
+    `),$&&(W.uniforms.add(new y("inverseProjectionMatrix",({camera:e})=>e.inverseProjectionMatrix)),W.code.add(w`vec3 inverseProject(vec4 posScreen) {
 posScreen.xy = (posScreen.xy / viewport.zw) * posScreen.w;
 return (inverseProjectionMatrix * posScreen).xyz;
-}`),O.code.add(y`bool rayIntersectPlane(vec3 rayDir, vec3 planeOrigin, vec3 planeNormal, out vec3 intersection) {
+}`),W.code.add(w`bool rayIntersectPlane(vec3 rayDir, vec3 planeOrigin, vec3 planeNormal, out vec3 intersection) {
 float cos = dot(rayDir, planeNormal);
 float t = dot(planeOrigin, planeNormal) / cos;
 intersection = t * rayDir;
 return abs(cos) > 0.001 && t > 0.0;
-}`),O.uniforms.add(new w("perScreenPixelRatio",({camera:e})=>e.perScreenPixelRatio)),O.code.add(y`
+}`),W.uniforms.add(new u("perScreenPixelRatio",({camera:e})=>e.perScreenPixelRatio)),W.code.add(w`
       vec4 toFront(vec4 displacedPosScreen, vec3 posLeft, vec3 posRight, vec3 prev, float lineWidth) {
         // Project displaced position back to camera space
         vec3 displacedPos = inverseProject(displacedPosScreen);
@@ -54,7 +54,7 @@ return abs(cos) > 0.001 && t > 0.0;
         vec3 planeNormal = normalize(cross(posLeft - posRight, posLeft - prev));
         vec3 planeOrigin = posLeft;
 
-        ${S(j.hasCap,"if(prev.z > posLeft.z) {\n                vec2 diff = posLeft.xy - posRight.xy;\n                planeOrigin.xy += perpendicular(diff) / 2.0;\n             }")};
+        ${S(z.hasCap,"if(prev.z > posLeft.z) {\n                vec2 diff = posLeft.xy - posRight.xy;\n                planeOrigin.xy += perpendicular(diff) / 2.0;\n             }")};
 
         // Move the plane towards the camera by a margin dependent on the line width (approximated in world space). This tolerance corrects for the
         // non-planarity in most cases, but sharp joins can place the prev vertices at arbitrary positions so markers can still clip.
@@ -73,7 +73,7 @@ return abs(cos) > 0.001 && t > 0.0;
         displacedPos *= minDepth / length(displacedPos);
         return vec4(displacedPos.xyz, 1.0);
       }
-  `)),h(O),L.include(p),O.main.add(y`
+  `)),m(W),j.include(c),W.main.add(w`
     // Check for special value of uv0.y which is used by the Renderer when graphics
     // are removed before the VBO is recompacted. If this is the case, then we just
     // project outside of clip space.
@@ -85,24 +85,24 @@ return abs(cos) > 0.001 && t > 0.0;
       vec4 pos  = view * vec4(position, 1.0);
       vec4 prev = view * vec4(position + previousDelta.xyz * previousDelta.w, 1.0);
 
-      float lineWidth = getLineWidth(${S(C,"pos.xyz")});
+      float lineWidth = getLineWidth(${S(M,"pos.xyz")});
       float screenMarkerSize = getScreenMarkerSize(lineWidth);
 
       clip(pos, prev);
 
-      ${$?y`${S(j.hideOnShortSegments,y`
+      ${C?w`${S(z.hideOnShortSegments,w`
                 if (areWorldMarkersHidden(pos.xyz, prev.xyz)) {
                   gl_Position = ${s};
                   return;
                 }`)}
             pos.xyz = displace(pos.xyz, prev.xyz, getWorldMarkerSize(pos.xyz));
-            vec4 displacedPosScreen = projectAndScale(pos);`:y`
+            vec4 displacedPosScreen = projectAndScale(pos);`:w`
             vec4 posScreen = projectAndScale(pos);
             vec4 prevScreen = projectAndScale(prev);
             vec4 displacedPosScreen = posScreen;
 
             displacedPosScreen.xy = displace(posScreen.xy, prevScreen.xy, screenMarkerSize);
-            ${S(W,y`
+            ${S($,w`
                 vec2 displacementDirU = perpendicular(normalizedSegment(posScreen.xy, prevScreen.xy));
 
                 // We need three points of the ribbon line in camera space to calculate the plane it lies in
@@ -112,14 +112,13 @@ return abs(cos) > 0.001 && t > 0.0;
 
                 pos = toFront(displacedPosScreen, lineLeft, lineRight, prev.xyz, lineWidth);
                 displacedPosScreen = projectAndScale(pos);`)}`}
-      forwardViewPosDepth(pos.xyz);
       // Convert back into NDC
       displacedPosScreen.xy = (displacedPosScreen.xy / viewport.zw) * displacedPosScreen.w;
 
       // Convert texture coordinate into [0,1]
       vUV = (uv0 + 1.0) / 2.0;
-      ${S(!$,"vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);")}
-      ${S(M,"vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);")}
+      ${S(!C,"vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);")}
+      ${S(D,"vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);")}
 
       vSize = screenMarkerSize;
       vColor = getColor();
@@ -128,13 +127,13 @@ return abs(cos) > 0.001 && t > 0.0;
       vpos = pos.xyz;
 
       gl_Position = displacedPosScreen;
-    }`),U.include(o,j),L.include(P,j),U.include(c),U.uniforms.add(new u("intrinsicColor",({color:e})=>e),new b("tex",({markerTexture:e})=>e)).constants.add("texelSize","float",1/e).code.add(y`float markerAlpha(vec2 samplePos) {
+    }`),O.include(o,z),j.include(P,z),O.include(l),O.uniforms.add(new g("intrinsicColor",({color:e})=>e),new x("tex",({markerTexture:e})=>e)).constants.add("texelSize","float",1/e).code.add(w`float markerAlpha(vec2 samplePos) {
 samplePos += vec2(0.5, -0.5) * texelSize;
 float sdf = texture(tex, samplePos).r;
 float pixelDistance = sdf * vSize;
 pixelDistance -= 0.5;
 return clamp(0.5 - pixelDistance, 0.0, 1.0);
-}`),M&&(L.include(d),U.constants.add("relativeMarkerSize","float",r/e).constants.add("relativeTipLineWidth","float",i).code.add(y`
+}`),D&&(j.include(p),O.constants.add("relativeMarkerSize","float",r/e).constants.add("relativeTipLineWidth","float",i).code.add(w`
     float tipAlpha(vec2 samplePos) {
       // Convert coordinates s.t. they are in pixels and relative to the tip of an arrow marker
       samplePos -= vec2(0.5, 0.5 + 0.5 * relativeMarkerSize);
@@ -143,18 +142,17 @@ return clamp(0.5 - pixelDistance, 0.0, 1.0);
       float halfMarkerSize = 0.5 * relativeMarkerSize * vSize;
       float halfTipLineWidth = 0.5 * max(1.0, relativeTipLineWidth * noPerspectiveRead(vLineWidth));
 
-      ${S($,"halfTipLineWidth *= fwidth(samplePos.y);")}
+      ${S(C,"halfTipLineWidth *= fwidth(samplePos.y);")}
 
       float distance = max(abs(samplePos.x) - halfMarkerSize, abs(samplePos.y) - halfTipLineWidth);
       return clamp(0.5 - distance, 0.0, 1.0);
     }
-  `)),L.include(a,j),L.include(d),U.main.add(y`
+  `)),j.include(a,z),j.include(p),O.main.add(w`
     discardBySlice(vpos);
-    discardByTerrainDepth();
 
     vec4 finalColor = intrinsicColor * vColor;
 
     // Cancel out perspective correct interpolation if in screen space or draped
-    vec2 samplePos = ${S(!$,"noPerspectiveRead(vUV)","vUV")};
-    finalColor.a *= ${M?"max(markerAlpha(samplePos), tipAlpha(samplePos))":"markerAlpha(samplePos)"};
-    outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),L}const L=Object.freeze(Object.defineProperty({__proto__:null,build:j},Symbol.toStringTag,{value:"Module"}));export{L,j as b};
+    vec2 samplePos = ${S(!C,"noPerspectiveRead(vUV)","vUV")};
+    finalColor.a *= ${D?"max(markerAlpha(samplePos), tipAlpha(samplePos))":"markerAlpha(samplePos)"};
+    outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),j}const j=Object.freeze(Object.defineProperty({__proto__:null,build:z},Symbol.toStringTag,{value:"Module"}));export{j as L,z as b};

package/chunks/Path.glsl.js

@@ -1,13 +1,11 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{addNearFar as e}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as i}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 a}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{PathVertexPosition as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";import{OutputDepth as l}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{EvaluateAmbientOcclusion as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as c,addLightingGlobalFactor as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDrawFragment as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as f,addViewNormal as y,addCameraPosition as L}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as j}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 S,If as O}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as C}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as A}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as D}from"../views/webgl/ShaderBuilder.js";function B(B){const I=new D,{vertex:M,fragment:_,varyings:F}=I;f(M,B),F.add("vpos","vec3",{invariant:!0}),I.include(n,B);const{output:V,spherical:x,pbrMode:z,snowCover:T}=B;switch((i(V)||11===V)&&(I.include(a),I.include(u,B),I.include(r,B),I.include(b,B),F.add("vnormal","vec3"),F.add("vcolor","vec4"),M.main.add(S`vpos = calculateVPos();
+import{addNearFar as e}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as i}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 a}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{PathVertexPosition as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";import{OutputDepth as l}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{EvaluateAmbientOcclusion as d}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as t,addAmbientBoostFactor as c,addLightingGlobalFactor as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDrawFragment as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{ColorConversion as b}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as h,addViewNormal as f,addCameraPosition as y}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as L}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as j}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as P,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as O}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as C}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as A}from"../views/webgl/ShaderBuilder.js";function I(I){const B=new A,{vertex:D,fragment:M,varyings:_}=B;h(D,I),_.add("vpos","vec3",{invariant:!0}),B.include(n,I);const{output:F,spherical:V,pbrMode:x,snowCover:z}=I;switch((i(F)||11===F)&&(B.include(a),B.include(w,I),B.include(r,I),_.add("vnormal","vec3"),_.add("vcolor","vec4"),D.main.add(P`vpos = calculateVPos();
 vnormal = normalize(localNormal());
-forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
 gl_Position = transformPosition(proj, view, vpos);
 forwardObjectAndLayerIdColor();
 vcolor = getColor();
-forwardLinearDepthToReadShadowMap();`)),V){case 0:case 1:case 2:I.include(w,B),_.include(t,B),_.include(d,B),I.include(v,B),_.include(o,B),I.include(A,B),L(_,B),c(_),m(_),_.uniforms.add(M.uniforms.get("localOrigin"),new j("ambient",e=>e.ambient),new j("diffuse",e=>e.diffuse),new P("opacity",e=>e.opacity)),_.include(h),_.include(C,B),g(_),_.main.add(S`
+forwardLinearDepthToReadShadowMap();`)),F){case 0:case 1:case 2:B.include(u,I),M.include(t,I),M.include(d,I),B.include(v,I),M.include(o,I),B.include(C,I),y(M,I),c(M),m(M),M.uniforms.add(D.uniforms.get("localOrigin"),new L("ambient",e=>e.ambient),new L("diffuse",e=>e.diffuse),new j("opacity",e=>e.opacity)),M.include(b),M.include(O,I),g(M),M.main.add(P`
         discardBySlice(vpos);
-        discardByTerrainDepth();
 
         shadingParams.viewDirection = normalize(vpos - cameraPosition);
         shadingParams.normalView = vnormal;
@@ -15,12 +13,12 @@ forwardLinearDepthToReadShadowMap();`)),V){case 0:case 1:case 2:I.include(w,B),_
         float ssao = evaluateAmbientOcclusionInverse();
 
         vec3 posWorld = vpos + localOrigin;
-        vec3 normalGround = ${x?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
+        vec3 normalGround = ${V?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
 
         vec3 albedo = vcolor.rgb * max(ambient, diffuse); // combine the old material parameters into a single one
         float combinedOpacity = vcolor.a * opacity;
 
-        ${O(T,S`float snow = getSnow(normal, normalGround);
+        ${S(z,P`float snow = getSnow(normal, normalGround);
                  albedo = mix(albedo, vec3(1), snow);
                  ssao = mix(ssao, 1.0, snow);`)}
 
@@ -28,19 +26,19 @@ forwardLinearDepthToReadShadowMap();`)),V){case 0:case 1:case 2:I.include(w,B),_
         vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
         float shadow = readShadow(additionalAmbientScale, vpos);
 
-        ${O(2===z,`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];\n           ${O(T,"mrr = applySnowToMRR(mrr, snow);")}`)}
+        ${S(2===x,`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];\n           ${S(z,"mrr = applySnowToMRR(mrr, snow);")}`)}
 
-        vec3 shadedColor = ${2===z?"evaluateSceneLightingPBR(normal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);":"evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);"}
+        vec3 shadedColor = ${2===x?"evaluateSceneLightingPBR(normal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);":"evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);"}
         vec4 finalColor = vec4(shadedColor, combinedOpacity);
-        outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${O(T,", snow")});`);break;case 3:I.include(a),M.main.add(S`vpos = calculateVPos();
-gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(o,B),_.main.add(S`discardBySlice(vpos);`);break;case 5:case 6:case 7:case 8:I.include(a),e(I),F.add("depth","float"),M.main.add(S`vpos = calculateVPos();
-gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),I.fragment.include(o,B),I.include(l,B),_.main.add(S`discardBySlice(vpos);
-outputDepth(depth);`);break;case 11:I.fragment.include(o,B),_.main.add(S`discardBySlice(vpos);
-outputObjectAndLayerIdColor();`);break;case 4:I.include(a),I.include(p,B),y(M),F.add("vnormal","vec3"),M.main.add(S`vpos = calculateVPos();
+        outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${S(z,", snow")});`);break;case 3:B.include(a),D.main.add(P`vpos = calculateVPos();
+gl_Position = transformPosition(proj, view, vpos);`),B.fragment.include(o,I),M.main.add(P`discardBySlice(vpos);`);break;case 5:case 6:case 7:case 8:B.include(a),e(B),_.add("depth","float"),D.main.add(P`vpos = calculateVPos();
+gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),B.fragment.include(o,I),B.include(l,I),M.main.add(P`discardBySlice(vpos);
+outputDepth(depth);`);break;case 11:B.fragment.include(o,I),M.main.add(P`discardBySlice(vpos);
+outputObjectAndLayerIdColor();`);break;case 4:B.include(a),B.include(p,I),f(D),_.add("vnormal","vec3"),D.main.add(P`vpos = calculateVPos();
 vnormal = normalize((viewNormal * vec4(localNormal(), 1.0)).xyz);
-gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(o,B),_.main.add(S`discardBySlice(vpos);
+gl_Position = transformPosition(proj, view, vpos);`),B.fragment.include(o,I),M.main.add(P`discardBySlice(vpos);
 vec3 normal = normalize(vnormal);
 if (gl_FrontFacing == false) normal = -normal;
-fragColor = vec4(vec3(0.5) + 0.5 * normal, 1.0);`);break;case 10:I.include(a),I.include(p,B),F.add("vnormal","vec3"),M.main.add(S`vpos = calculateVPos();
-gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(o,B),I.include(s,B),_.main.add(S`discardBySlice(vpos);
-calculateOcclusionAndOutputHighlight();`)}return I}const I=Object.freeze(Object.defineProperty({__proto__:null,build:B},Symbol.toStringTag,{value:"Module"}));export{I as P,B as b};
+fragColor = vec4(vec3(0.5) + 0.5 * normal, 1.0);`);break;case 10:B.include(a),B.include(p,I),_.add("vnormal","vec3"),D.main.add(P`vpos = calculateVPos();
+gl_Position = transformPosition(proj, view, vpos);`),B.fragment.include(o,I),B.include(s,I),M.main.add(P`discardBySlice(vpos);
+calculateOcclusionAndOutputHighlight();`)}return B}const B=Object.freeze(Object.defineProperty({__proto__:null,build:I},Symbol.toStringTag,{value:"Module"}));export{B as P,I as b};