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

package/chunks/GaussianSplatShadow.glsl.js

@@ -1,5 +1,11 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{create as e}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{nearFar as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{glsl as n,If as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4PassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Matrix4PassUniform.js";import{shadowDepthBias as a,gaussianSplatFirstHitAlpha as o}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{gaussianSplatRayDepth as s,GaussianSplatPass as c,gaussianSplatUnpackScaleAndRotation as l,gaussianSplatComputeQuad as u,gaussianSplatCullAndTransformVertex as d,gaussianSplatComputeEllipse as f}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{GaussianSplatRenderParameters as p}from"../views/3d/webgl-engine/shaders/GaussianSplatPassParameters.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";class h extends p{constructor(){super(...arguments),this.inverseProjectionMatrix=e()}}function g(e){let p=new m,{vertex:h,fragment:g}=p,_=e.output===8;return e.preciseDepth&&(_?p.include(s):(p.varyings.add(`shadowRayDepth`,`vec2`),h.code.add(n`vec2 gaussianSplatPrepareParallelRayDepth(
+import{create as e}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{positionOutsideClipSpace as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{nearFar as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{glsl as r,If as i}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4PassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Matrix4PassUniform.js";import{shadowDepthBias as o,gaussianSplatFirstHitAlpha as s}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{gaussianSplatCommon as c,gaussianSplatRayDepth as l}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{GaussianSplatRenderParameters as u}from"../views/3d/webgl-engine/shaders/GaussianSplatPassParameters.js";import{ShaderBuilder as d}from"../views/webgl/ShaderBuilder.js";class f extends u{constructor(){super(...arguments),this.inverseProjectionMatrix=e()}}function p(e){let u=new d,{vertex:f,fragment:p,varyings:m}=u,h=e.output===8,g=e.clippingEnabled||e.hasSlicePlane;return u.include(c,e),m.add(`gaussianCoordinates`,`vec2`),m.add(`gaussianLogFalloffCutoff`,`float`),(e.preciseDepth||g)&&f.uniforms.add(new a(`inverseProjectionMatrix`,e=>e.inverseProjectionMatrix)),g&&(m.add(`homogeneousPositionCameraRelative`,`vec4`),f.code.add(r`vec4 reconstructHomogeneousViewPosition(vec2 clipPosition, float viewZ, mat4 inverseProjection) {
+vec4 origin = inverseProjection * vec4(clipPosition, 0.0, 1.0);
+vec4 depthAxis = inverseProjection[2];
+float denominator = depthAxis.z - viewZ * depthAxis.w;
+float numerator = viewZ * origin.w - origin.z;
+return origin * denominator + depthAxis * numerator;
+}`)),e.preciseDepth&&(h?(u.include(l),m.add(`rayGaussianFactor`,`vec4`)):(u.varyings.add(`shadowRayDepth`,`vec2`),f.code.add(r`vec2 gaussianSplatPrepareParallelRayDepth(
 vec2 clipPosition,
 vec3 viewPosition,
 vec3 gaussianScale,
@@ -14,18 +20,35 @@ vec3 homogeneousCenterOffset = vec3(viewPosition.xy * homogeneousOrigin.w - homo
 vec3 factorSpaceOffset = (viewToGaussian * homogeneousCenterOffset) / gaussianScale;
 float homogeneousPeakOffset = dot(factorSpaceDirection, factorSpaceOffset) / dot(factorSpaceDirection, factorSpaceDirection);
 return vec2(-viewPosition.z * homogeneousOrigin.w + homogeneousPeakOffset, homogeneousOrigin.w);
-}`)),h.uniforms.add(new i(`inverseProjectionMatrix`,e=>e.inverseProjectionMatrix)),g.uniforms.add(t),g.constants.add(`depthBias`,`float`,a),g.main.add(n`
-      float rayDepth = ${_?`gaussianSplatRayDepth()`:`shadowRayDepth.x / (shadowRayDepth.y == 0.0 ? 1.0 : shadowRayDepth.y)`};
+}`)),p.uniforms.add(n),p.constants.add(`depthBias`,`float`,o),p.main.add(r`
+      float rayDepth = ${h?`computeGaussianRayDepth(rayGaussianFactor)`:`shadowRayDepth.x / (shadowRayDepth.y == 0.0 ? 1.0 : shadowRayDepth.y)`};
       float linearDepth = (rayDepth - nearFar.x) / (nearFar.y - nearFar.x);
       float slopeBias = 2.0 * max(abs(dFdx(linearDepth)), abs(dFdy(linearDepth)));
-      ${r(!_,n`if (shadowRayDepth.y == 0.0) { discard; }`)}
+      ${i(!h,r`if (shadowRayDepth.y == 0.0) { discard; }`)}
       if (rayDepth < nearFar.x || rayDepth > nearFar.y) {
         discard;
       }
       gl_FragDepth = min(linearDepth + depthBias + slopeBias, 1.0);
-    `)),p.include(c,e),h.constants.add(`alphaCutoff`,`float`,o),h.constants.add(`depthBias`,`float`,a),h.code.add(n`float safeClipW(float clipW) {
+    `)),g&&p.main.add(r`if (homogeneousPositionCameraRelative.w == 0.0) {
+discard;
+}
+vec3 positionCameraRelative = homogeneousPositionCameraRelative.xyz / homogeneousPositionCameraRelative.w;
+if (rejectGaussianPosition(positionCameraRelative)) {
+discard;
+}`),p.main.add(r`
+    ${e.normalizedCutoff?r`
+            if (dot(gaussianCoordinates, gaussianCoordinates) > 1.0) {
+              discard;
+            }
+          `:r`
+            float gaussianExponent = evaluateGaussianExponent(gaussianCoordinates);
+            if (gaussianExponent > 0.0 || gaussianExponent < gaussianLogFalloffCutoff) {
+              discard;
+            }
+          `}
+  `),f.constants.add(`alphaCutoff`,`float`,s),f.constants.add(`depthBias`,`float`,o),f.code.add(r`float safeClipW(float clipW) {
 return abs(clipW) < 1e-7 ? (clipW < 0.0 ? -1e-7 : 1e-7) : clipW;
-}`),h.code.add(n`vec3 computeProjectivePixelGradient(
+}`),f.code.add(r`vec3 computeProjectivePixelGradient(
 vec3 clipGradient,
 vec3 clipWGradient,
 float clipValue,
@@ -34,17 +57,31 @@ float invWSquared,
 float halfScreenSize
 ) {
 return (clipGradient * safeW - clipValue * clipWGradient) * invWSquared * halfScreenSize;
-}`),h.code.add(n`float biasDepth(float linearDepth) {
+}`),f.code.add(r`float biasDepth(float linearDepth) {
 return min(linearDepth + depthBias, 1.0);
-}`),h.main.add(`
+}`),f.main.add(r`
+    gl_Position = ${t};
     uint gaussianIndex = fetchOrderedGaussianIndex(uint(gl_InstanceID));
     uvec4 packedGaussian = fetchPackedGaussian(gaussianIndex);
 
     float opacity = unpackOpacity(packedGaussian);
 
-    ${d(e,`alphaCutoff`)}
+    if (opacity < alphaCutoff) {
+      return;
+    }
+
+    vec3 cameraRelativePosition = fetchGaussianCameraRelativePosition(gaussianIndex, packedGaussian);
+    if (rejectGaussianPosition(cameraRelativePosition)) {
+      return;
+    }
+
+    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1.0);
+    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {
+      return;
+    }
 
-    ${l}
+    vec3 gaussianScale = unpackScale(packedGaussian);
+    mat3 gaussianRotation = quaternionToRotationMatrix(unpackQuaternion(packedGaussian));
 
     vec4 projPos = proj * viewPos;
     float safeW = safeClipW(projPos.w);
@@ -78,7 +115,19 @@ return min(linearDepth + depthBias, 1.0);
       return;
     }
 
-    ${f(`log(alphaCutoff) - log(opacity)`,`minimumRadiusOpacity`)}
+    float determinant = computeGaussianCovarianceDeterminant(covariance2D);
+    if (determinant <= 0.0) {
+      return;
+    }
+
+    vec2 eigenvalues = computeGaussianCovarianceEigenvalues(covariance2D);
+    gaussianLogFalloffCutoff = log(alphaCutoff) - log(opacity);
+    float gaussianEllipseThreshold = computeGaussianEllipseThreshold(gaussianLogFalloffCutoff);
+    vec2 screenRadii = computeGaussianScreenRadii(covariance2D, gaussianEllipseThreshold);
+    float maxRadius = ceil(sqrt(eigenvalues.x * gaussianEllipseThreshold));
+    if (rejectGaussianByMinimumRadius(maxRadius, minimumRadiusOpacity, minSplatRadius)) {
+      return;
+    }
 
     // Avoid invalid/extremely large footprints.
     if (maxRadius < 0.0 || maxRadius > maxShadowSplatRadius) {
@@ -86,16 +135,31 @@ return min(linearDepth + depthBias, 1.0);
     }
 
     vec3 ndcPos = projPos.xyz / safeW;
-    ${u}
+    vec2 clipSpacePixelScale = 2.0 * inverseScreenSize;
+    if (rejectGaussianByScreenBounds(ndcPos.xy, screenRadii, clipSpacePixelScale)) {
+      return;
+    }
+    gaussianCoordinates = computeGaussianUnitQuadCorner(gl_VertexID) * sqrt(gaussianEllipseThreshold);
+    vec2 offsetFromCenter = computeGaussianQuadOffset(covariance2D, determinant, gaussianCoordinates);
     float linearDepth = (-viewPos.z - nearFar.x) / (nearFar.y - nearFar.x);
     float biasedDepth = biasDepth(linearDepth);
 
     vec2 clipPos = ndcPos.xy + offsetFromCenter * clipSpacePixelScale - inverseScreenSize;
-    ${r(e.preciseDepth,_?n`vec3 rayView = reconstructViewRay(clipPos, inverseProjectionMatrix);
-rayGaussianFactor = computeGaussianRayFactor(
-rayView, cameraRelativePosition, gaussianScale, gaussianRotation, mat3(view)
-);`:n`shadowRayDepth = gaussianSplatPrepareParallelRayDepth(
-clipPos, viewPos.xyz, gaussianScale, gaussianRotation, inverseProjectionMatrix, mat3(view)
-);`)}
+    ${i(g,r`
+        vec4 homogeneousViewPosition = reconstructHomogeneousViewPosition(clipPos, viewPos.z, inverseProjectionMatrix);
+        homogeneousPositionCameraRelative = vec4(transpose(mat3(view)) * homogeneousViewPosition.xyz, homogeneousViewPosition.w);
+      `)}
+    ${i(e.preciseDepth,h?r`
+            vec3 rayView = reconstructViewRay(clipPos, inverseProjectionMatrix);
+            rayGaussianFactor = computeGaussianRayFactor(
+              rayView, cameraRelativePosition, gaussianScale, gaussianRotation, mat3(view)
+            );
+          `:r`
+            shadowRayDepth = gaussianSplatPrepareParallelRayDepth(
+              clipPos, viewPos.xyz, gaussianScale, gaussianRotation, inverseProjectionMatrix, mat3(view)
+            );
+          `)}
     gl_Position = vec4(clipPos, biasedDepth * 2.0 - 1.0, 1.0);
-  `),p}const _=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatShadowPassParameters:h,build:g},Symbol.toStringTag,{value:`Module`}));export{h as G,_ as a,g as b};
+
+    ${i(e.normalizedCutoff,r`gaussianCoordinates = computeGaussianUnitQuadCorner(gl_VertexID);`)}
+  `),u}const m=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatShadowPassParameters:f,build:p},Symbol.toStringTag,{value:`Module`}));export{f as G,m as a,p as b};

package/chunks/GlobalIllumination.glsl.js

@@ -29,15 +29,6 @@ float idleOcclusionBlendProgress = clamp(accumulatedFrames / highQualityIdleOccl
 return mix(highQualityIdleOcclusionBlendStart, highQualityIdleOcclusionBlendEnd,
 pow(idleOcclusionBlendProgress, highQualityIdleOcclusionBlendExponent));
 }
-bool isEdgeDepth(float centerDepth, vec2 sampleUv) {
-vec2 texelSize = 1.0 / vec2(textureSize(depthMap, 0));
-float depthLeft = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(-texelSize.x, 0.0)));
-float depthRight = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(texelSize.x, 0.0)));
-float depthUp = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, texelSize.y)));
-float depthDown = linearizeDepth(depthFromTexture(depthMap, sampleUv + vec2(0.0, -texelSize.y)));
-float maxDifference = max(max(abs(centerDepth - depthLeft), abs(centerDepth - depthRight)), max(abs(centerDepth - depthUp), abs(centerDepth - depthDown)));
-return abs(maxDifference / centerDepth) > 0.01;
-}
 vec3 sampleCosineHemisphere(vec2 u) {
 float phi = 6.28318530718 * u.x;
 float radius = sqrt(u.y);
@@ -117,17 +108,11 @@ return value * 2.0 - 1.0;
     float reprojectionDepthMismatch = abs((lastFrameDepthViewPos + reprojectedViewPos.z) / max(lastFrameDepthViewPos, reprojectedViewPos.z));
     bool hasReprojectionMismatch = reprojectionDepthMismatch > reprojectionMismatchThreshold;
     bool isScaledGlobalIllumination = resolutionScale < 1.0;
-    bool isLowQualityEdgePixel = isScaledGlobalIllumination && isEdgeDepth(currentPixelDepth, uv);
 
     // Heuristic to determine blending weights and number of steps for occlusion and color
     if (hasReprojectionMismatch) {
-      if (isLowQualityEdgePixel) {
-        steps = 1;
-        occlusionBlendWeight = lowQualityOcclusionBlendWeight;
-      } else {
-        steps = 6;
-        occlusionBlendWeight = 1.0;
-      }
+      steps = 6;
+      occlusionBlendWeight = 1.0;
     } else {
       steps = 1;
       if (historyOcclusionBlendWeight > weakHistoryOcclusionThreshold) {

package/chunks/LineMarker.glsl.js

@@ -1,50 +1,50 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{markerTextureSize as e,markerSymbolSize as t,markerTipThicknessFactor as n}from"../views/3d/support/engineContent/marker.js";import{sliceDraw as r}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as i}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{evaluateSceneLightingFragment as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/evaluateSceneLightingFragment.glsl.js";import{MarkerSizing as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{NormalUtils as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{positionOutsideClipSpace as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{nearFar as u,viewport as d,viewNormal as f,inverseProjectionMatrix as p,screenPixelSizePerDistance as m,pixelRatio as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{ColorConversion as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as _,NoPerspectiveRead as v}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as y}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as b}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{glsl as x,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as C}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{alphaCutoff as w}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as T}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as E}from"../views/webgl/ShaderBuilder.js";function D(D){let O=new E,{draped:k,worldSpace:A,anchor:j,hasTip:M,shadingEnabled:N}=D,P=!k&&!A;O.attributes.add(`position`,`vec3`),O.attributes.add(D.hasVVSize?`sizeFeatureAttribute`:`size`,`float`),D.hasVVOpacity&&O.attributes.add(`opacityFeatureAttribute`,`float`),O.attributes.add(D.hasVVColor?`colorFeatureAttribute`:`color`,D.hasVVColor?`float`:`vec4`),O.vertex.inputs.add(`position`,()=>`position`),D.hasVVSize?O.vertex.inputs.add(`sizeFeatureAttribute`,()=>`sizeFeatureAttribute`):O.vertex.inputs.add(`size`,()=>`size`),D.hasVVOpacity&&O.vertex.inputs.add(`opacityFeatureAttribute`,()=>`opacityFeatureAttribute`),D.hasVVColor?O.vertex.inputs.add(`colorFeatureAttribute`,()=>`colorFeatureAttribute`):O.vertex.inputs.add(`color`,()=>`color`),O.include(i,D),O.include(s,D);let{vertex:F,fragment:I,varyings:L}=O;y(F,D),O.attributes.add(`previousDelta`,`vec4`),O.attributes.add(`uv0`,`vec2`),L.add(`vColor`,`vec4`),L.add(`vpos`,`vec3`,{invariant:!0}),L.add(`vUV`,`vec2`),L.add(`vSize`,`float`),M&&L.add(`vLineWidth`,`float`),F.uniforms.add(u,d).code.add(x`vec4 projectAndScale(vec4 pos) {
+import{markerTextureSize as e,markerSymbolSize as t,markerTipThicknessFactor as n}from"../views/3d/support/engineContent/marker.js";import{sliceDraw as r}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as i}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{evaluateSceneLightingFragment as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/evaluateSceneLightingFragment.glsl.js";import{forwardLocalUp as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/forwardLocalUp.glsl.js";import{MarkerSizing as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{positionOutsideClipSpace as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{nearFar as u,viewport as d,viewNormal as f,inverseProjectionMatrix as p,screenPixelSizePerDistance as m,pixelRatio as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/cameraUniforms.js";import{ColorConversion as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as _,NoPerspectiveRead as v}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as y,addCameraPosition as b}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{glsl as S,If as C}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{alphaCutoff as T}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as E}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as D}from"../views/webgl/ShaderBuilder.js";function O(O){let k=new D,{draped:A,worldSpace:j,anchor:M,hasTip:N,shadingEnabled:P}=O,F=!A&&!j;k.attributes.add(`position`,`vec3`),k.attributes.add(O.hasVVSize?`sizeFeatureAttribute`:`size`,`float`),O.hasVVOpacity&&k.attributes.add(`opacityFeatureAttribute`,`float`),k.attributes.add(O.hasVVColor?`colorFeatureAttribute`:`color`,O.hasVVColor?`float`:`vec4`),k.vertex.inputs.add(`position`,()=>`position`),O.hasVVSize?k.vertex.inputs.add(`sizeFeatureAttribute`,()=>`sizeFeatureAttribute`):k.vertex.inputs.add(`size`,()=>`size`),O.hasVVOpacity&&k.vertex.inputs.add(`opacityFeatureAttribute`,()=>`opacityFeatureAttribute`),O.hasVVColor?k.vertex.inputs.add(`colorFeatureAttribute`,()=>`colorFeatureAttribute`):k.vertex.inputs.add(`color`,()=>`color`),k.include(i,O),k.include(c,O);let{vertex:I,fragment:L,varyings:R}=k;y(I,O),k.attributes.add(`previousDelta`,`vec4`),k.attributes.add(`uv0`,`vec2`),R.add(`vColor`,`vec4`),R.add(`vpos`,`vec3`,{invariant:!0}),R.add(`vUV`,`vec2`),R.add(`vSize`,`float`),N&&R.add(`vLineWidth`,`float`),I.uniforms.add(u,d).code.add(S`vec4 projectAndScale(vec4 pos) {
 vec4 posNdc = proj * pos;
 posNdc.xy *= viewport.zw / posNdc.w;
 return posNdc;
-}`),F.code.add(x`void clip(vec4 pos, inout vec4 prev) {
+}`),I.code.add(S`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);
 }
-}`),A?(O.attributes.add(`normal`,`vec3`),F.constants.add(`tiltThreshold`,`float`,.7).uniforms.add(f).code.add(x`vec3 perpendicular(vec3 v) {
+}`),j?(k.attributes.add(`normal`,`vec3`),I.constants.add(`tiltThreshold`,`float`,.7).uniforms.add(f).code.add(S`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;
-}`)):F.code.add(x`vec2 perpendicular(vec2 v) {
+}`)):I.code.add(S`vec2 perpendicular(vec2 v) {
 return vec2(v.y, -v.x);
-}`);let R=A?`vec3`:`vec2`;return F.code.add(x`
-    ${R} normalizedSegment(${R} pos, ${R} prev) {
-      ${R} segment = pos - prev;
+}`);let z=j?`vec3`:`vec2`;return I.code.add(S`
+    ${z} normalizedSegment(${z} pos, ${z} prev) {
+      ${z} segment = pos - prev;
       float segmentLen = length(segment);
 
       // normalize or zero if too short
-      return (segmentLen > 0.001) ? segment / segmentLen : ${A?`vec3(0.0, 0.0, 0.0)`:`vec2(0.0, 0.0)`};
+      return (segmentLen > 0.001) ? segment / segmentLen : ${j?`vec3(0.0, 0.0, 0.0)`:`vec2(0.0, 0.0)`};
     }
 
-    ${R} displace(${R} pos, ${R} prev, float displacementLen) {
-      ${R} segment = normalizedSegment(pos, prev);
+    ${z} displace(${z} pos, ${z} prev, float displacementLen) {
+      ${z} segment = normalizedSegment(pos, prev);
 
-      ${R} displacementDirU = perpendicular(segment);
-      ${R} displacementDirV = segment;
+      ${z} displacementDirU = perpendicular(segment);
+      ${z} displacementDirV = segment;
 
-      ${j===1?`pos -= 0.5 * displacementLen * displacementDirV;`:``}
+      ${M===1?`pos -= 0.5 * displacementLen * displacementDirV;`:``}
 
       return pos + displacementLen * (uv0.x * displacementDirU + uv0.y * displacementDirV);
     }
-  `),P&&(F.uniforms.add(p),F.code.add(x`vec3 inverseProject(vec4 posScreen) {
+  `),F&&(I.uniforms.add(p),I.code.add(S`vec3 inverseProject(vec4 posScreen) {
 posScreen.xy = (posScreen.xy / viewport.zw) * posScreen.w;
 return (inverseProjectionMatrix * posScreen).xyz;
-}`),F.code.add(x`bool rayIntersectPlane(vec3 rayDir, vec3 planeOrigin, vec3 planeNormal, out vec3 intersection) {
+}`),I.code.add(S`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;
-}`),F.uniforms.add(m),F.code.add(x`
+}`),I.uniforms.add(m),I.code.add(S`
       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(D.hasCap,`if(prev.z > posLeft.z) {
+        ${C(O.hasCap,`if(prev.z > posLeft.z) {
                 vec2 diff = posLeft.xy - posRight.xy;
                 planeOrigin.xy += perpendicular(diff) / 2.0;
              }`)};
@@ -76,7 +76,7 @@ return abs(cos) > 0.001 && t > 0.0;
         displacedPos *= minDepth / length(displacedPos);
         return vec4(displacedPos.xyz, 1.0);
       }
-  `)),O.include(_),F.uniforms.add(h).main.add(x`
+  `)),k.include(_),I.uniforms.add(h).main.add(S`
     // 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.
     if (uv0.y == 0.0) {
@@ -88,24 +88,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(D.lineWidthRequiresPosition,`pos.xyz`)});
+    float lineWidth = getLineWidth(${C(O.lineWidthRequiresPosition,`pos.xyz`)});
     float screenMarkerSize = getScreenMarkerSize(lineWidth);
 
     clip(pos, prev);
 
-    ${A?x`${S(D.hideOnShortSegments,x`
+    ${j?S`${C(O.hideOnShortSegments,S`
               if (areWorldMarkersHidden(pos.xyz, prev.xyz)) {
                 gl_Position = ${l};
                 return;
               }`)}
           pos.xyz = displace(pos.xyz, prev.xyz, getWorldMarkerSize(pos.xyz));
-          vec4 displacedPosScreen = projectAndScale(pos);`:x`
+          vec4 displacedPosScreen = projectAndScale(pos);`:S`
           vec4 posScreen = projectAndScale(pos);
           vec4 prevScreen = projectAndScale(prev);
           vec4 displacedPosScreen = posScreen;
 
           displacedPosScreen.xy = displace(posScreen.xy, prevScreen.xy, screenMarkerSize);
-          ${S(P,x`
+          ${C(F,S`
               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
@@ -121,8 +121,8 @@ return abs(cos) > 0.001 && t > 0.0;
 
     // Convert texture coordinate into [0,1]
     vUV = (uv0 + 1.0) / 2.0;
-    ${S(!A,`vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);`)}
-    ${S(M,`vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);`)}
+    ${C(!j,`vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);`)}
+    ${C(N,`vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);`)}
 
     vSize = screenMarkerSize;
     vColor = getColor();
@@ -131,13 +131,13 @@ return abs(cos) > 0.001 && t > 0.0;
     vpos = pos.xyz;
 
     gl_Position = displacedPosScreen;
-  `),I.include(r,D),O.include(T,D),I.include(g),I.include(w),I.uniforms.add(new b(`intrinsicColor`,({color:e})=>e),new C(`tex`,({markerTexture:e})=>e)).constants.add(`texelSize`,`float`,1/e).code.add(x`float markerAlpha(vec2 samplePos) {
+  `),L.include(r,O),k.include(E,O),L.include(g),L.include(T),L.uniforms.add(new x(`intrinsicColor`,({color:e})=>e),new w(`tex`,({markerTexture:e})=>e)).constants.add(`texelSize`,`float`,1/e).code.add(S`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&&(O.include(v),I.constants.add(`relativeMarkerSize`,`float`,t/e).constants.add(`relativeTipLineWidth`,`float`,n).code.add(x`
+}`),N&&(k.include(v),L.constants.add(`relativeMarkerSize`,`float`,t/e).constants.add(`relativeTipLineWidth`,`float`,n).code.add(S`
         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);
@@ -146,18 +146,19 @@ 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(A,`halfTipLineWidth *= fwidth(samplePos.y);`)}
+          ${C(j,`halfTipLineWidth *= fwidth(samplePos.y);`)}
 
           float distance = max(abs(samplePos.x) - halfMarkerSize, abs(samplePos.y) - halfTipLineWidth);
           return clamp(0.5 - distance, 0.0, 1.0);
         }
-      `)),O.include(a,D),O.include(v),I.main.add(x`
+      `)),k.include(a,O),k.include(v),L.main.add(S`
     discardBySlice(vpos);
 
     vec4 albedo = intrinsicColor * vColor;
 
     // Cancel out perspective correct interpolation if in screen space or draped
-    vec2 samplePos = ${S(A,`vUV`,`noPerspectiveRead(vUV)`)};
-    albedo.a *= ${M?`max(markerAlpha(samplePos), tipAlpha(samplePos))`:`markerAlpha(samplePos)`};
+    vec2 samplePos = ${C(j,`vUV`,`noPerspectiveRead(vUV)`)};
+    albedo.a *= ${N?`max(markerAlpha(samplePos), tipAlpha(samplePos))`:`markerAlpha(samplePos)`};
     if(albedo.a < alphaCutoff) discard; // We also want to discard in the opaque color pass
-  `),N?(L.add(`vnormal`,`vec3`),F.include(c,D),F.main.add(`vnormal = getLocalUp(vpos, localOrigin);`),O.include(o,D),I.main.add(`vec4 finalColor = evaluateSceneLightingFragment(vpos, vnormal, albedo);`)):I.main.add(`vec4 finalColor = albedo;`),I.main.add(`outputColorHighlightOLID(applySlice(finalColor, vpos), albedo.rgb);`),O}const O=Object.freeze(Object.defineProperty({__proto__:null,build:D},Symbol.toStringTag,{value:`Module`}));export{O as L,D as b};
+  `),P?(R.add(`vposWorld`,`vec3`),b(I,O),k.include(s,O),I.main.add(S`vposWorld = transpose(mat3(view)) * vpos + cameraPosition;
+forwardLocalUp(vposWorld, localOrigin);`),k.include(o,O),L.main.add(`vec4 finalColor = evaluateSceneLightingFragment(vposWorld, upNormal, albedo);`)):L.main.add(`vec4 finalColor = albedo;`),L.main.add(`outputColorHighlightOLID(applySlice(finalColor, vpos), albedo.rgb);`),k}const k=Object.freeze(Object.defineProperty({__proto__:null,build:O},Symbol.toStringTag,{value:`Module`}));export{k as L,O as b};

package/chunks/OITAddEmission.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ColorConversion as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{emissionFilter as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/emissionFilter.glsl.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{OITBlendFragmentPassParameters as a,oitBlendFragment as o}from"../views/3d/webgl-engine/effects/transparency/oitBlendFragment.glsl.js";import{floatBlendScale as s}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ToneMapping as c}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as l}from"../views/webgl/ShaderBuilder.js";class u extends a{}function d(a){let u=new l;u.include(e);let{fragment:d,outputs:f}=u;return f.add(`fragEmission`,`vec4`,1),d.include(s,a),d.include(o,a),d.include(n,a),d.include(c),d.include(t),d.uniforms.add(new i(`emissionTexture`,e=>e.emissionTexture),new i(`frontFaceEmissionTexture`,e=>e.frontFaceEmissionTexture)),d.main.add(r`vec4 emission = oitBlendFragment(emissionTexture, frontFaceEmissionTexture, floatBlendInputScale);
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ColorConversion as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{emissionFilter as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/emissionFilter.glsl.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{OITBlendFragmentPassParameters as a,oitBlendFragment as o}from"../views/3d/webgl-engine/effects/transparency/oitBlendFragment.glsl.js";import{floatBlendScale as s}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ToneMapping as c}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as l}from"../views/webgl/ShaderBuilder.js";class u extends a{}function d(a){let u=new l;u.include(e);let{fragment:d,outputs:f}=u;return f.add(`fragEmission`,`vec4`,1),d.include(s,a),d.include(o,a),d.include(n,a),d.include(c),d.include(t),d.uniforms.add(new i(`emissionTexture`,e=>e.emissionTexture),new i(`frontFaceEmissionTexture`,e=>e.frontFaceEmissionTexture)).main.add(r`vec4 emission = oitBlendFragment(emissionTexture, frontFaceEmissionTexture, floatBlendInputScale);
 vec4 transparentColor = oitBlendFragment();
 vec3 dim = emissionFilter(transparentColor.rgb, transparentColor.a);
 fragEmission.rgb = emission.rgb * dim * pow(emission.a, 0.5) * floatBlendOutputScale;

package/chunks/RasterColorizer.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
-import{ZEROS as e}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{Colormap as t}from"../views/3d/webgl-engine/core/shaderLibrary/raster/Colormap.glsl.js";import{CommonPassParameters as n,Common as r}from"../views/3d/webgl-engine/core/shaderLibrary/raster/Common.glsl.js";import{TileBackground as i}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileBackground.glsl.js";import{TileComposite as a}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileComposite.glsl.js";import{ColorConversion as o}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{BooleanPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/BooleanPassUniform.js";import{Float2PassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3PassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as f}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{IntegerPassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/IntegerPassUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as h}from"../views/webgl/ShaderBuilder.js";class g extends n{constructor(t,n,r,i,a,o){super(t,i,a),this.colormap=n,this.symbolizer=r,this.u_colormap=o,this.backgroundColor=e,this.fboTexture=null,this.baseOpacity=1}}class _ extends g{}class v extends g{}function y(e){let n=new h;return n.include(a),n.include(r,e),n.include(t,e),n.include(i,e),n.fragment.code.add(f`vec4 applyBackgroundBlend(vec4 layerColor) {
+import{ZEROS as e}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{Colormap as t}from"../views/3d/webgl-engine/core/shaderLibrary/raster/Colormap.glsl.js";import{CommonPassParameters as n,Common as r}from"../views/3d/webgl-engine/core/shaderLibrary/raster/Common.glsl.js";import{blendLayers as i}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/blendLayers.glsl.js";import{TileComposite as a}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/TileComposite.glsl.js";import{ColorConversion as o}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{BooleanPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/BooleanPassUniform.js";import{Float2PassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3PassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as f}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{IntegerPassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/IntegerPassUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as h}from"../views/webgl/ShaderBuilder.js";class g extends n{constructor(t,n,r,i,a,o){super(t,i,a),this.colormap=n,this.symbolizer=r,this.u_colormap=o,this.backgroundColor=e,this.fboTexture=null,this.baseOpacity=1}}class _ extends g{}class v extends g{}function y(e){let n=new h;return n.include(a),n.include(r,e),n.include(t,e),n.include(i,e),n.fragment.code.add(f`vec4 applyBackgroundBlend(vec4 layerColor) {
 return blendLayers(vuv, layerColor, u_opacity);
 }`),e.colorizerType===0?x(n,e):e.colorizerType===1?b(n):e.colorizerType===2&&S(n,e),n}function b(e){e.fragment.main.add(f`vec2 pixelLocation = getPixelLocation(uv);
 if (isOutside(pixelLocation)) {