@arcgis/core 5.0.0-next.68 → 5.0.0-next.69

package/chunks/GaussianSplat.glsl.js

@@ -2,6 +2,6 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{EvaluateSceneLighting as a,addAmbientBoostFactor as i,addLightingGlobalFactor as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{terrainDepthTest as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ComputeCovariance as s}from"../views/3d/webgl-engine/core/shaderLibrary/util/ComputeCovariance.glsl.js";import{GaussianSplatUnpackingPassParameters as c,GaussianSplatUnpacking as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/GaussianSplatUnpacking.glsl.js";import{QuaternionToRotationMatrix as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/QuaternionToRotationMatrix.glsl.js";import{Float2BindUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{FloatPassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as m,If as h}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{IntegerPassUniform as f}from"../views/3d/webgl-engine/core/shaderModules/IntegerPassUniform.js";import{Matrix4BindUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DUintPassUniform as y}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUintPassUniform.js";import{getGaussianSplatAlphaCutoffValue as w}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as b}from"../views/webgl/ShaderBuilder.js";class P extends c{constructor(){super(...arguments),this.totalGaussians=-1,this.focalLength=-1,this.minSplatRadius=-1,this.tanFov=n()}}function C(n){const c=new b;c.varyings.add("vColor","vec4"),c.varyings.add("conicOpacity","vec4"),c.varyings.add("depth","float"),c.varyings.add("gaussianCenterScreenPos","vec2"),c.varyings.add("fragScreenPos","vec2"),c.varyings.add("offsetFromCenter","vec2"),c.vertex.uniforms.add(new y("splatOrderTexture",e=>e.splatOrder),new y("splatFadingTexture",e=>e.splatFading),new y("splatAtlasTexture",e=>e.splatAtlas),new f("numSplats",e=>e.totalGaussians),new p("focalLength",e=>e.focalLength),new p("minSplatRadius",e=>e.minSplatRadius),new v("tanFov",e=>e.tanFov),new u("screenSize",({camera:n})=>e(D,n.fullWidth,n.fullHeight)),new x("proj",e=>e.camera.projectionMatrix),new x("view",e=>e.camera.viewMatrix),new u("nearFar",e=>e.camera.nearFar),new g("cameraPosition",e=>e.camera.eye)),c.vertex.include(l),c.vertex.include(d),c.vertex.include(s),c.vertex.include(a,n),c.include(o,n),i(c.vertex),t(c.vertex),c.include(r,n);const P=n.dephtOnlyPass,C=n.dephtOnlyPass;P||C?c.outputs.add("fragColor","vec4"):(c.outputs.add("fragColor","vec4",0),c.outputs.add("fragDepthColor","vec4",1));const S=w(n.alphaCutoff),F=Math.log(S),T=-2*F;return c.vertex.code.add(m`vec2 ndcToPixel(vec2 ndcCoord, vec2 screenSize) {
+import{set as e}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{EvaluateSceneLighting as a,addAmbientBoostFactor as i,addLightingGlobalFactor as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{positionOutsideClipSpace as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{terrainDepthTest as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ComputeCovariance as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/ComputeCovariance.glsl.js";import{GaussianSplatUnpackingPassParameters as l,GaussianSplatUnpacking as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/GaussianSplatUnpacking.glsl.js";import{QuaternionToRotationMatrix as u}from"../views/3d/webgl-engine/core/shaderLibrary/util/QuaternionToRotationMatrix.glsl.js";import{Float2BindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float2PassUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as p}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{FloatPassUniform as h}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as f,If as m}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DUintPassUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUintPassUniform.js";import{getGaussianSplatAlphaCutoffValue as y}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as b}from"../views/webgl/ShaderBuilder.js";class D extends l{constructor(){super(...arguments),this.focalLength=-1,this.minSplatRadius=-1,this.tanFov=n()}}function P(n){const l=new b;l.varyings.add("vColor","vec4"),l.varyings.add("conicOpacity","vec4"),l.varyings.add("depth","float"),l.varyings.add("gaussianCenterScreenPos","vec2"),l.varyings.add("fragScreenPos","vec2"),l.varyings.add("offsetFromCenter","vec2"),l.vertex.uniforms.add(new w("splatOrderTexture",e=>e.splatOrder),new w("splatFadingTexture",e=>e.splatFading),new w("splatAtlasTexture",e=>e.splatAtlas),new h("focalLength",e=>e.focalLength),new h("minSplatRadius",e=>e.minSplatRadius),new g("tanFov",e=>e.tanFov),new v("screenSize",({camera:n})=>e(C,n.fullWidth,n.fullHeight)),new x("proj",e=>e.camera.projectionMatrix),new x("view",e=>e.camera.viewMatrix),new v("nearFar",e=>e.camera.nearFar),new p("cameraPosition",e=>e.camera.eye)),l.vertex.include(d),l.vertex.include(u),l.vertex.include(c),l.vertex.include(a,n),l.include(o,n),i(l.vertex),t(l.vertex),l.include(s,n),l.outputs.add("fragColor","vec4",0),l.outputs.add("fragDepthColor","vec4",1);const D=y(n.alphaCutoff),P=Math.log(D),S=-2*P;return l.vertex.code.add(f`vec2 ndcToPixel(vec2 ndcCoord, vec2 screenSize) {
 return ((ndcCoord + 1.0) * screenSize - 1.0) * 0.5;
-}`),c.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    uint splatAtlasWidth = uint(textureSize(splatAtlasTexture, 0).x);\n\n    // Fetch the packed Gaussian according to the index\n    uint gaussianIndexX = gaussianIndex % splatAtlasWidth;\n    uint gaussianIndexY = gaussianIndex / splatAtlasWidth;\n    uvec4 packedGaussian = texelFetch(splatAtlasTexture, ivec2(gaussianIndexX, gaussianIndexY), 0);\n\n    // Fetch the header associated with the packed Gaussian (contains tile origin and number of fractional bits)\n    uint pageNum = gaussianIndex / 1024u;\n    uint headerIndex = (pageNum + 1u) * 1024u - 1u;\n    uint headerIndexX = headerIndex % splatAtlasWidth;\n    uint headerIndexY = headerIndex / splatAtlasWidth;\n    uvec4 packedHeader = texelFetch(splatAtlasTexture, ivec2(headerIndexX, headerIndexY), 0);\n\n    // Unpack the Gaussian\n    vColor = unpackColor(packedGaussian);\n\n    // Handle fading\n    ${h(n.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    if(vColor.a < ${S}) {\n      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);\n      return;\n    }\n\n    vec3 scale = unpackScale(packedGaussian);\n    vec4 quaternion = unpackQuaternion(packedGaussian);\n    mat3 rotation = quaternionToRotationMatrix(quaternion);\n    vec3 tileOriginRelativePosition = unpackTileOriginRelativePosition(packedGaussian);\n\n    vec3 cameraRelativePosition = unpackCameraRelativeGaussianPosition(packedHeader, tileOriginRelativePosition);\n\n    vec4 viewPos = vec4(mat3(view) * cameraRelativePosition, 1);\n\n    // Handle environment (scene lighting)\n    ${h(!P,`vec3 groundNormal = ${n.spherical?m`normalize(cameraRelativePosition + cameraPosition)`:m`vec3(0.0, 0.0, 1.0)`};\n      float groundLightAlignment = dot(groundNormal, mainLightDirection);\n      float additionalAmbientScale = additionalDirectedAmbientLight(groundLightAlignment);\n      vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;\n      vColor.rgb = evaluateSceneLighting(groundNormal, vColor.rgb, 0.0, 0.0, mainLightIntensity);`)};\n\n    if (viewPos.z > -nearFar.x || viewPos.z < -nearFar.y) {\n      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);\n      return;\n    }\n\n    forwardViewPosDepth(viewPos.xyz);\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      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);\n      return;\n    }\n    float invDeterminant = 1. / determinant;\n\n    vec4 projPos = proj * viewPos;\n    float invW = 1. / (projPos.w + 1e-7);\n    vec3 ndcPos = projPos.xyz * invW;\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    // Compute the extents along the principal axes\n    float l1 = ceil(sqrt(lambda1 * ${T}));\n    float l2 = ceil(sqrt(lambda2 * ${T}));\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        gl_Position = vec4(1e038, 1e038, 1e038, 1.0);\n        return;\n      }\n    }\n\n    // Screen space frustum culling\n    vec2 radiusNDC = maxRadius * 2.0 / screenSize;\n\n    if (any(greaterThan(abs(ndcPos.xy) - radiusNDC, vec2(1.0)))) {\n        gl_Position = vec4(1e038, 1e038, 1e038, 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    gaussianCenterScreenPos = ndcToPixel(ndcPos.xy, screenSize);\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    fragScreenPos = gaussianCenterScreenPos + corner.x * majorAxis + corner.y * minorAxis;\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    depth = ndcPos.z;\n\n    // Convert from screen-space to clip-space\n    vec2 clipPos = fragScreenPos / screenSize * 2. - 1.;\n\n    offsetFromCenter = gaussianCenterScreenPos - fragScreenPos;\n\n    gl_Position = vec4(clipPos, depth, 1.0);\n\n  `),c.fragment.main.add(`\n    discardByTerrainDepth();\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 alphaCutoff (i.e., ln(alphaCutoff)), to avoid unnecessary exp()\n    if (gaussianExponent > 0.0 || gaussianExponent < ${F}) {\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    ${h(!P,"fragColor = vec4(vColor.rgb * alpha, alpha);","fragColor = vec4(depth, 0, 0, alpha)")};\n\n    ${h(!C,"// Regular depth writing based on first hit is not precise enough due to the inherently\n      // transparent nature of Gaussian Splats (especially at the borders of the Splat).\n      // We thus use a blended depth that computes a non-linear average using\n      // the splat order and opacity with geometric decay.\n      // This means the depth is averaged based on the order and opacity of the Gaussians,\n      // with the frontmost Gaussians contributing the most.\n      fragDepthColor = vec4(depth, 0, 0, alpha);")};\n  `),c}const D=n(),S=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatPassParameters:P,build:C},Symbol.toStringTag,{value:"Module"}));export{P as G,S as a,C as b};
+}`),l.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    uint splatAtlasWidth = uint(textureSize(splatAtlasTexture, 0).x);\n\n    // Fetch the packed Gaussian according to the index\n    uint gaussianIndexX = gaussianIndex % splatAtlasWidth;\n    uint gaussianIndexY = gaussianIndex / splatAtlasWidth;\n    uvec4 packedGaussian = texelFetch(splatAtlasTexture, ivec2(gaussianIndexX, gaussianIndexY), 0);\n\n    // Fetch the header associated with the packed Gaussian (contains tile origin and number of fractional bits)\n    uint pageNum = gaussianIndex / 1024u;\n    uint headerIndex = (pageNum + 1u) * 1024u - 1u;\n    uint headerIndexX = headerIndex % splatAtlasWidth;\n    uint headerIndexY = headerIndex / splatAtlasWidth;\n    uvec4 packedHeader = texelFetch(splatAtlasTexture, ivec2(headerIndexX, headerIndexY), 0);\n\n    // Unpack the Gaussian\n    vColor = unpackColor(packedGaussian);\n\n    // Handle fading\n    ${m(n.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 = ${r};\n\n    if(vColor.a < ${D}) {\n      return;\n    }\n\n    vec3 scale = unpackScale(packedGaussian);\n    vec4 quaternion = unpackQuaternion(packedGaussian);\n    mat3 rotation = quaternionToRotationMatrix(quaternion);\n    vec3 tileOriginRelativePosition = unpackTileOriginRelativePosition(packedGaussian);\n\n    vec3 cameraRelativePosition = unpackCameraRelativeGaussianPosition(packedHeader, tileOriginRelativePosition);\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    forwardViewPosDepth(viewPos.xyz);\n\n    // Handle environment (scene lighting)\n    vec3 groundNormal = ${n.spherical?f`normalize(cameraRelativePosition + cameraPosition)`:f`vec3(0.0, 0.0, 1.0)`};\n    float groundLightAlignment = dot(groundNormal, mainLightDirection);\n    float additionalAmbientScale = additionalDirectedAmbientLight(groundLightAlignment);\n    vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;\n    vColor.rgb = evaluateSceneLighting(groundNormal, vColor.rgb, 0.0, 0.0, mainLightIntensity);\n\n\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    // 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    // Compute the extents along the principal axes\n    float l1 = ceil(sqrt(lambda1 * ${S}));\n    float l2 = ceil(sqrt(lambda2 * ${S}));\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\n    // Screen space frustum culling\n    vec2 radiusNDC = maxRadius * 2.0 / screenSize;\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    gaussianCenterScreenPos = ndcToPixel(ndcPos.xy, screenSize);\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    fragScreenPos = gaussianCenterScreenPos + corner.x * majorAxis + corner.y * minorAxis;\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    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    depth = ndcPos.z;\n\n    // Convert from screen-space to clip-space\n    vec2 clipPos = fragScreenPos / screenSize * 2. - 1.;\n\n    offsetFromCenter = gaussianCenterScreenPos - fragScreenPos;\n\n    gl_Position = vec4(clipPos, depth, 1.0);\n\n  `),l.fragment.code.add("\n    // we can use a relatively simple encoding since our values are\n    // guaranteed to be within [-1, 1]\n    vec2 encodeFloat32DepthToVec2F16(float value) {\n      value = value * 1024.0; // shift by 10 bits to the left\n      float high = floor(value);\n      float low = value - high;\n      return vec2(high, low);\n    }\n  "),l.fragment.main.add(`\n    discardByTerrainDepth();\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 alphaCutoff (i.e., ln(alphaCutoff)), to avoid unnecessary exp()\n    if (gaussianExponent > 0.0 || gaussianExponent < ${P}) {\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    fragColor = vec4(vColor.rgb * 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    fragDepthColor = vec4(encodeFloat32DepthToVec2F16(depth) * countHit, 0.0, countHit);\n  `),l}const C=n(),S=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatPassParameters:D,build:P},Symbol.toStringTag,{value:"Module"}));export{D as G,S as a,P as b};

package/chunks/GaussianSplatDepthComposition.glsl.js

@@ -2,10 +2,9 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{glsl as t}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as r}from"../views/webgl/NoParameters.js";import{ShaderBuilder as a}from"../views/webgl/ShaderBuilder.js";class o extends r{}function p(){const r=new a;r.include(e);return r.fragment.uniforms.add(new s("splatOutputDepth",e=>e.splatDepth)),r.fragment.main.add(t`vec4 splatDepth = texture(splatOutputDepth, uv);
-float ndcDepth = splatDepth.x;
-float depthCutOff = 0.75;
-if(splatDepth.a < depthCutOff) {
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{glsl as t}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as o}from"../views/webgl/NoParameters.js";import{ShaderBuilder as r}from"../views/webgl/ShaderBuilder.js";class a extends o{}function n(){const o=new r;o.include(e);return o.fragment.uniforms.add(new s("splatOutputDepth",e=>e.splatDepth)),o.fragment.code.add("\n      // we encode near F32 precision by using two F16s  \n      float decodeVec2F16ToFloat32(vec2 encoded) {\n        return( (encoded.x + encoded.y) / 1024.0);\n      }\n  "),o.fragment.main.add(t`vec4 splatDepth = texture(splatOutputDepth, uv);
+float ndcDepth = decodeVec2F16ToFloat32(splatDepth.xy);
+if(splatDepth.a < 1.0) {
 discard;
 }
-gl_FragDepth = (ndcDepth + 1.0) * 0.5;`),r}const l=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatDepthCompositionPassParameters:o,build:p},Symbol.toStringTag,{value:"Module"}));export{o as G,l as S,p as b};
+gl_FragDepth = (ndcDepth + 1.0) * 0.5;`),o}const d=Object.freeze(Object.defineProperty({__proto__:null,GaussianSplatDepthCompositionPassParameters:a,build:n},Symbol.toStringTag,{value:"Module"}));export{a as G,d as S,n as b};

package/chunks/HUDMaterial.glsl.js

@@ -2,7 +2,7 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{copy as e,set as o}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,fromValues as t}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{earth as l}from"../geometry/support/Ellipsoid.js";import{RejectBySlice as a}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{ObjectAndLayerIdColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{AlignPixel as n}from"../views/3d/webgl-engine/core/shaderLibrary/hud/AlignPixel.glsl.js";import{HUD as c}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js";import{HUDOcclusionPass as d}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUDOcclusionPass.glsl.js";import{HUDVisibility as u}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUDVisibility.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{VisualVariables as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{ColorConversion as m}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{ScreenSizePerspective as v,addScreenSizePerspective as g,addScreenSizePerspectiveAlignment as b}from"../views/3d/webgl-engine/core/shaderLibrary/util/ScreenSizePerspective.glsl.js";import{addPixelRatio as x}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2PassUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float4BindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4DrawUniform as C}from"../views/3d/webgl-engine/core/shaderModules/Float4DrawUniform.js";import{Float4PassUniform as z}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as P}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as S}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as j,If as y}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as A}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as $}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as O}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as D}from"../webscene/support/AlphaCutoff.js";function F(e){const i=new O;if(i.include(c,e),i.vertex.include(a,e),e.occlusionPass)return i.include(d,e),i;const{output:F,oitPass:M,signedDistanceFieldEnabled:U,visibilityPixelEnabled:E,horizonCullingEnabled:H,pixelSnappingEnabled:_,hasEmission:q,hasScreenSizePerspective:R,debugDrawLabelBorder:k,hasVVSize:I,hasVVColor:G,hasRotation:J,occludedFragmentFade:K,sampleSignedDistanceFieldTexelCenter:N}=e;i.include(v),i.include(p,e),i.include(s,e),E&&i.include(u);const{vertex:Q,fragment:W}=i;W.include(m),i.varyings.add("vcolor","vec4"),i.varyings.add("vtc","vec2"),i.varyings.add("vsize","vec2");const X=8===F,Y=X&&E;Y&&i.varyings.add("voccluded","float"),Q.uniforms.add(new w("viewport",e=>e.camera.fullViewport),new h("screenOffset",(e,i)=>o(L,2*e.screenOffset[0]*i.camera.pixelRatio,2*e.screenOffset[1]*i.camera.pixelRatio)),new h("anchorPosition",e=>B(e)),new z("materialColor",e=>e.color),new S("materialRotation",e=>e.rotation),new $("tex",e=>e.texture)),x(Q),U&&(Q.uniforms.add(new z("outlineColor",e=>e.outlineColor)),W.uniforms.add(new z("outlineColor",e=>T(e)?e.outlineColor:r),new S("outlineSize",e=>T(e)?e.outlineSize:0))),H&&Q.uniforms.add(new C("pointDistanceSphere",(e,o)=>{const i=o.camera.eye,r=e.origin;return t(r[0]-i[0],r[1]-i[1],r[2]-i[2],l.radius)})),_&&Q.include(n),R&&(g(Q),b(Q)),k&&i.varyings.add("debugBorderCoords","vec4"),i.attributes.add("uv0","vec2"),i.attributes.add("uvi","vec4"),i.attributes.add("color","vec4"),i.attributes.add("size","vec2"),i.attributes.add("rotation","float"),(I||G)&&i.attributes.add("featureAttribute","vec4"),Q.code.add(H?j`bool behindHorizon(vec3 posModel) {
+import{copy as e,set as o}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,fromValues as t}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{earth as l}from"../geometry/support/Ellipsoid.js";import{RejectBySlice as a}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{ObjectAndLayerIdColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{AlignPixel as n}from"../views/3d/webgl-engine/core/shaderLibrary/hud/AlignPixel.glsl.js";import{HUD as c}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js";import{HUDOcclusionPass as d}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUDOcclusionPass.glsl.js";import{HUDVisibility as u}from"../views/3d/webgl-engine/core/shaderLibrary/hud/HUDVisibility.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{positionOutsideClipSpace as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{VisualVariables as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{ColorConversion as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{ScreenSizePerspective as v,addScreenSizePerspective as b,addScreenSizePerspectiveAlignment as x}from"../views/3d/webgl-engine/core/shaderLibrary/util/ScreenSizePerspective.glsl.js";import{addPixelRatio as h}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2PassUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float4BindUniform as C}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4DrawUniform as z}from"../views/3d/webgl-engine/core/shaderModules/Float4DrawUniform.js";import{Float4PassUniform as P}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as S}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as j}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as y,If as A}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as $}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as O}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{ShaderBuilder as D}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as F}from"../webscene/support/AlphaCutoff.js";function T(e){const i=new D;if(i.include(c,e),i.vertex.include(a,e),e.occlusionPass)return i.include(d,e),i;const{output:T,oitPass:L,signedDistanceFieldEnabled:V,visibilityPixelEnabled:H,horizonCullingEnabled:_,pixelSnappingEnabled:q,hasEmission:R,hasScreenSizePerspective:k,debugDrawLabelBorder:I,hasVVSize:G,hasVVColor:J,hasRotation:K,occludedFragmentFade:N,sampleSignedDistanceFieldTexelCenter:Q}=e;i.include(v),i.include(m,e),i.include(s,e),H&&i.include(u);const{vertex:W,fragment:X}=i;X.include(g),i.varyings.add("vcolor","vec4"),i.varyings.add("vtc","vec2"),i.varyings.add("vsize","vec2");const Y=8===T,Z=Y&&H;Z&&i.varyings.add("voccluded","float"),W.uniforms.add(new C("viewport",e=>e.camera.fullViewport),new w("screenOffset",(e,i)=>o(U,2*e.screenOffset[0]*i.camera.pixelRatio,2*e.screenOffset[1]*i.camera.pixelRatio)),new w("anchorPosition",e=>M(e)),new P("materialColor",e=>e.color),new j("materialRotation",e=>e.rotation),new O("tex",e=>e.texture)),h(W),V&&(W.uniforms.add(new P("outlineColor",e=>e.outlineColor)),X.uniforms.add(new P("outlineColor",e=>B(e)?e.outlineColor:r),new j("outlineSize",e=>B(e)?e.outlineSize:0))),_&&W.uniforms.add(new z("pointDistanceSphere",(e,o)=>{const i=o.camera.eye,r=e.origin;return t(r[0]-i[0],r[1]-i[1],r[2]-i[2],l.radius)})),q&&W.include(n),k&&(b(W),x(W)),I&&i.varyings.add("debugBorderCoords","vec4"),i.attributes.add("uv0","vec2"),i.attributes.add("uvi","vec4"),i.attributes.add("color","vec4"),i.attributes.add("size","vec2"),i.attributes.add("rotation","float"),(G||J)&&i.attributes.add("featureAttribute","vec4"),W.code.add(_?y`bool behindHorizon(vec3 posModel) {
 vec3 camToEarthCenter = pointDistanceSphere.xyz - localOrigin;
 vec3 camToPos = pointDistanceSphere.xyz + posModel;
 float earthRadius = pointDistanceSphere.w;
@@ -10,49 +10,47 @@ float a = dot(camToPos, camToPos);
 float b = dot(camToPos, camToEarthCenter);
 float c = dot(camToEarthCenter, camToEarthCenter) - earthRadius * earthRadius;
 return b > 0.0 && b < a && b * b  > a * c;
-}`:j`bool behindHorizon(vec3 posModel) { return false; }`),Q.main.add(j`
+}`:y`bool behindHorizon(vec3 posModel) { return false; }`),W.main.add(y`
     ProjectHUDAux projectAux;
     vec4 posProj = projectPositionHUD(projectAux);
     forwardObjectAndLayerIdColor();
 
     if (rejectBySlice(projectAux.posModel)) {
-      // Project outside of clip plane
-      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+      gl_Position = ${p};
       return;
     }
 
     if (behindHorizon(projectAux.posModel)) {
-      // Project outside of clip plane
-      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+      gl_Position = ${p};
       return;
     }
 
     vec2 inputSize;
-    ${y(R,j`
+    ${A(k,y`
         inputSize = screenSizePerspectiveScaleVec2(size, projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspective);
-        vec2 screenOffsetScaled = screenSizePerspectiveScaleVec2(screenOffset, projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspectiveAlignment);`,j`
+        vec2 screenOffsetScaled = screenSizePerspectiveScaleVec2(screenOffset, projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspectiveAlignment);`,y`
         inputSize = size;
         vec2 screenOffsetScaled = screenOffset;`)}
-    ${y(I,j`inputSize *= vvScale(featureAttribute).xx;`)}
+    ${A(G,y`inputSize *= vvScale(featureAttribute).xx;`)}
 
     vec2 combinedSize = inputSize * pixelRatio;
     vec4 quadOffset = vec4(0.0);
 
-    ${y(E,j`
+    ${A(H,y`
     bool visible = testHUDVisibility(posProj);
     if (!visible) {
       vtc = vec2(0.0);
-      ${y(k,"debugBorderCoords = vec4(0.5, 0.5, 1.5 / combinedSize);")}
+      ${A(I,"debugBorderCoords = vec4(0.5, 0.5, 1.5 / combinedSize);")}
       return;
     }`)}
-    ${y(Y,j`voccluded = visible ? 0.0 : 1.0;`)}
-  `);const Z=j`
+    ${A(Z,y`voccluded = visible ? 0.0 : 1.0;`)}
+  `);const ee=y`
       vec2 uv = mix(uvi.xy, uvi.zw, bvec2(uv0));
       vec2 texSize = vec2(textureSize(tex, 0));
-      uv = mix(vec2(1.0), uv / texSize, lessThan(uv, vec2(${V})));
+      uv = mix(vec2(1.0), uv / texSize, lessThan(uv, vec2(${E})));
       quadOffset.xy = (uv0 - anchorPosition) * 2.0 * combinedSize;
 
-      ${y(J,j`
+      ${A(K,y`
           float angle = radians(materialRotation + rotation);
           float cosAngle = cos(angle);
           float sinAngle = sin(angle);
@@ -62,36 +60,36 @@ return b > 0.0 && b < a && b * b  > a * c;
         `)}
 
       quadOffset.xy = (quadOffset.xy + screenOffsetScaled) / viewport.zw * posProj.w;
-  `,ee=_?U?j`posProj = alignToPixelOrigin(posProj, viewport.zw) + quadOffset;`:j`posProj += quadOffset;
+  `,oe=q?V?y`posProj = alignToPixelOrigin(posProj, viewport.zw) + quadOffset;`:y`posProj += quadOffset;
 if (inputSize.x == size.x) {
 posProj = alignToPixelOrigin(posProj, viewport.zw);
-}`:j`posProj += quadOffset;`;Q.main.add(j`
-    ${Z}
-    ${G?"vcolor = interpolateVVColor(featureAttribute.y) * materialColor;":"vcolor = color / 255.0 * materialColor;"}
+}`:y`posProj += quadOffset;`;W.main.add(y`
+    ${ee}
+    ${J?"vcolor = interpolateVVColor(featureAttribute.y) * materialColor;":"vcolor = color / 255.0 * materialColor;"}
 
-    ${y(9===F,j`vcolor.a = 1.0;`)}
+    ${A(9===T,y`vcolor.a = 1.0;`)}
 
-    bool alphaDiscard = vcolor.a < ${j.float(D)};
-    ${y(U,`alphaDiscard = alphaDiscard && outlineColor.a < ${j.float(D)};`)}
+    bool alphaDiscard = vcolor.a < ${y.float(F)};
+    ${A(V,`alphaDiscard = alphaDiscard && outlineColor.a < ${y.float(F)};`)}
     if (alphaDiscard) {
       // "early discard" if both symbol color (= fill) and outline color (if applicable) are transparent
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
       return;
     } else {
-      ${ee}
+      ${oe}
       gl_Position = posProj;
     }
 
     vtc = uv;
 
-    ${y(k,j`debugBorderCoords = vec4(uv01, 1.5 / combinedSize);`)}
+    ${A(I,y`debugBorderCoords = vec4(uv01, 1.5 / combinedSize);`)}
     vsize = inputSize;
-  `),W.uniforms.add(new $("tex",e=>e.texture)),K&&!X&&W.uniforms.add(new A("depthMap",e=>e.mainDepth),new P("occludedOpacity",e=>e.hudOccludedFragmentOpacity));const oe=k?j`(isBorder > 0.0 ? 0.0 : ${j.float(D)})`:j.float(D),ie=j`
-    ${y(k,j`float isBorder = float(any(lessThan(debugBorderCoords.xy, debugBorderCoords.zw)) || any(greaterThan(debugBorderCoords.xy, 1.0 - debugBorderCoords.zw)));`)}
+  `),X.uniforms.add(new O("tex",e=>e.texture)),N&&!Y&&X.uniforms.add(new $("depthMap",e=>e.mainDepth),new S("occludedOpacity",e=>e.hudOccludedFragmentOpacity));const ie=I?y`(isBorder > 0.0 ? 0.0 : ${y.float(F)})`:y.float(F),re=y`
+    ${A(I,y`float isBorder = float(any(lessThan(debugBorderCoords.xy, debugBorderCoords.zw)) || any(greaterThan(debugBorderCoords.xy, 1.0 - debugBorderCoords.zw)));`)}
 
     vec2 samplePos = vtc;
 
-    ${y(N,j`
+    ${A(Q,y`
       float txSize = float(textureSize(tex, 0).x);
       float texelSize = 1.0 / txSize;
 
@@ -99,7 +97,7 @@ posProj = alignToPixelOrigin(posProj, viewport.zw);
       vec2 scaleFactor = (vsize - txSize) * texelSize;
       samplePos += (vec2(1.0, -1.0) * texelSize) * scaleFactor;`)}
 
-    ${U?j`
+    ${V?y`
       vec4 fillPixelColor = vcolor;
 
       // Get distance in output units (i.e. pixels)
@@ -120,8 +118,8 @@ posProj = alignToPixelOrigin(posProj, viewport.zw);
         outlinePixelColor.a *= outlineAlphaFactor;
 
         if (
-          outlineAlphaFactor + fillAlphaFactor < ${oe} ||
-          fillPixelColor.a + outlinePixelColor.a < ${j.float(D)}
+          outlineAlphaFactor + fillAlphaFactor < ${ie} ||
+          fillPixelColor.a + outlinePixelColor.a < ${y.float(F)}
         ) {
           discard;
         }
@@ -131,39 +129,39 @@ posProj = alignToPixelOrigin(posProj, viewport.zw);
         vec3 compositeColor = vec3(outlinePixelColor) * outlinePixelColor.a +
           vec3(fillPixelColor) * fillPixelColor.a * (1.0 - outlinePixelColor.a);
 
-        ${y(!X,j`fragColor = vec4(compositeColor, compositeAlpha);`)}
+        ${A(!Y,y`fragColor = vec4(compositeColor, compositeAlpha);`)}
       } else {
-        if (fillAlphaFactor < ${oe}) {
+        if (fillAlphaFactor < ${ie}) {
           discard;
         }
 
-        ${y(!X,j`fragColor = premultiplyAlpha(fillPixelColor);`)}
+        ${A(!Y,y`fragColor = premultiplyAlpha(fillPixelColor);`)}
       }
 
       // visualize SDF:
       // fragColor = vec4(clamp(-pixelDistance/vsize.x*2.0, 0.0, 1.0), clamp(pixelDistance/vsize.x*2.0, 0.0, 1.0), 0.0, 1.0);
-      `:j`
+      `:y`
           vec4 texColor = texture(tex, samplePos, -0.5);
-          if (texColor.a < ${oe}) {
+          if (texColor.a < ${ie}) {
             discard;
           }
-          ${y(!X,j`fragColor = texColor * premultiplyAlpha(vcolor);`)}
+          ${A(!Y,y`fragColor = texColor * premultiplyAlpha(vcolor);`)}
           `}
 
-    ${y(K&&!X,j`
+    ${A(N&&!Y,y`
         float zSample = texelFetch(depthMap, ivec2(gl_FragCoord.xy), 0).x;
         if (zSample < gl_FragCoord.z) {
           fragColor *= occludedOpacity;
         }
         `)}
 
-    ${y(!X&&k,j`fragColor = mix(fragColor, vec4(1.0, 0.0, 1.0, 1.0), isBorder * 0.5);`)}
-  `;switch(F){case 0:i.outputs.add("fragColor","vec4",0),q&&i.outputs.add("fragEmission","vec4",1),1===M&&i.outputs.add("fragAlpha","float",q?2:1),W.main.add(j`
-        ${ie}
-        ${y(2===M,j`fragColor.rgb /= fragColor.a;`)}
-        ${y(q,j`fragEmission = vec4(0.0);`)}
-        ${y(1===M,j`fragAlpha = fragColor.a;`)}`);break;case 9:W.main.add(j`
-        ${ie}
-        outputObjectAndLayerIdColor();`);break;case 8:i.include(f,e),W.main.add(j`
-        ${ie}
-        outputHighlight(${y(Y,j`voccluded == 1.0`,j`false`)});`)}return i}function T(e){return e.outlineColor[3]>0&&e.outlineSize>0}function B(o){return o.textureIsSignedDistanceField?M(o.anchorPosition,o.distanceFieldBoundingBox,L):e(L,o.anchorPosition),L}function M(e,i,r){o(r,e[0]*(i[2]-i[0])+i[0],e[1]*(i[3]-i[1])+i[1])}const L=i(),U=32e3,V=j.float(U),E=Object.freeze(Object.defineProperty({__proto__:null,build:F,calculateAnchorPosition:B,fullUV:U},Symbol.toStringTag,{value:"Module"}));export{E as H,F as b,B as c,U as f};
+    ${A(!Y&&I,y`fragColor = mix(fragColor, vec4(1.0, 0.0, 1.0, 1.0), isBorder * 0.5);`)}
+  `;switch(T){case 0:i.outputs.add("fragColor","vec4",0),R&&i.outputs.add("fragEmission","vec4",1),1===L&&i.outputs.add("fragAlpha","float",R?2:1),X.main.add(y`
+        ${re}
+        ${A(2===L,y`fragColor.rgb /= fragColor.a;`)}
+        ${A(R,y`fragEmission = vec4(0.0);`)}
+        ${A(1===L,y`fragAlpha = fragColor.a;`)}`);break;case 9:X.main.add(y`
+        ${re}
+        outputObjectAndLayerIdColor();`);break;case 8:i.include(f,e),X.main.add(y`
+        ${re}
+        outputHighlight(${A(Z,y`voccluded == 1.0`,y`false`)});`)}return i}function B(e){return e.outlineColor[3]>0&&e.outlineSize>0}function M(o){return o.textureIsSignedDistanceField?L(o.anchorPosition,o.distanceFieldBoundingBox,U):e(U,o.anchorPosition),U}function L(e,i,r){o(r,e[0]*(i[2]-i[0])+i[0],e[1]*(i[3]-i[1])+i[1])}const U=i(),V=32e3,E=y.float(V),H=Object.freeze(Object.defineProperty({__proto__:null,build:T,calculateAnchorPosition:M,fullUV:V},Symbol.toStringTag,{value:"Module"}));export{H,T as b,M as c,V as f};

package/chunks/LineMarker.glsl.js

@@ -2,52 +2,52 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-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{terrainDepthTest as s}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 l,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 y}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as S}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 z}from"../views/webgl/ShaderBuilder.js";function b(b){const j=new z,{space:L,anchor:D,hasTip:k,hasScreenSizePerspective:M}=b,C=2===L,$=1===L;j.include(t,b),j.include(n,b),j.include(s,b);const{vertex:W,fragment:U,varyings:O}=j;d(W,b),j.attributes.add("position","vec3"),j.attributes.add("previousDelta","vec4"),j.attributes.add("uv0","vec2"),O.add("vColor","vec4"),O.add("vpos","vec3",{invariant:!0}),O.add("vUV","vec2"),O.add("vSize","float"),k&&O.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) {
+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) {
 vec4 posNdc = proj * pos;
 posNdc.xy *= viewport.zw / posNdc.w;
 return posNdc;
-}`),W.code.add(w`void clip(vec4 pos, inout vec4 prev) {
+}`),O.code.add(y`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);
 }
-}`),C?(j.attributes.add("normal","vec3"),v(W),W.constants.add("tiltThreshold","float",.7),W.code.add(w`vec3 perpendicular(vec3 v) {
+}`),$?(L.attributes.add("normal","vec3"),m(O),O.constants.add("tiltThreshold","float",.7),O.code.add(y`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;
-}`)):W.code.add(w`vec2 perpendicular(vec2 v) {
+}`)):O.code.add(y`vec2 perpendicular(vec2 v) {
 return vec2(v.y, -v.x);
-}`);const T=C?"vec3":"vec2";return W.code.add(w`
-      ${T} normalizedSegment(${T} pos, ${T} prev) {
-        ${T} segment = pos - prev;
+}`);const N=$?"vec3":"vec2";return O.code.add(y`
+      ${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 : ${C?"vec3(0.0, 0.0, 0.0)":"vec2(0.0, 0.0)"};
+        return (segmentLen > 0.001) ? segment / segmentLen : ${$?"vec3(0.0, 0.0, 0.0)":"vec2(0.0, 0.0)"};
       }
 
-      ${T} displace(${T} pos, ${T} prev, float displacementLen) {
-        ${T} segment = normalizedSegment(pos, prev);
+      ${N} displace(${N} pos, ${N} prev, float displacementLen) {
+        ${N} segment = normalizedSegment(pos, prev);
 
-        ${T} displacementDirU = perpendicular(segment);
-        ${T} displacementDirV = segment;
+        ${N} displacementDirU = perpendicular(segment);
+        ${N} displacementDirV = segment;
 
-        ${1===D?"pos -= 0.5 * displacementLen * displacementDirV;":""}
+        ${1===k?"pos -= 0.5 * displacementLen * displacementDirV;":""}
 
         return pos + displacementLen * (uv0.x * displacementDirU + uv0.y * displacementDirV);
       }
-    `),$&&(W.uniforms.add(new S("inverseProjectionMatrix",({camera:e})=>e.inverseProjectionMatrix)),W.code.add(w`vec3 inverseProject(vec4 posScreen) {
+    `),W&&(O.uniforms.add(new x("inverseProjectionMatrix",({camera:e})=>e.inverseProjectionMatrix)),O.code.add(y`vec3 inverseProject(vec4 posScreen) {
 posScreen.xy = (posScreen.xy / viewport.zw) * posScreen.w;
 return (inverseProjectionMatrix * posScreen).xyz;
-}`),W.code.add(w`bool rayIntersectPlane(vec3 rayDir, vec3 planeOrigin, vec3 planeNormal, out vec3 intersection) {
+}`),O.code.add(y`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;
-}`),W.uniforms.add(new u("perScreenPixelRatio",({camera:e})=>e.perScreenPixelRatio)),W.code.add(w`
+}`),O.uniforms.add(new w("perScreenPixelRatio",({camera:e})=>e.perScreenPixelRatio)),O.code.add(y`
       vec4 toFront(vec4 displacedPosScreen, vec3 posLeft, vec3 posRight, vec3 prev, float lineWidth) {
         // Project displaced position back to camera space
         vec3 displacedPos = inverseProject(displacedPosScreen);
@@ -57,7 +57,7 @@ return abs(cos) > 0.001 && t > 0.0;
         vec3 planeNormal = normalize(cross(posLeft - posRight, posLeft - prev));
         vec3 planeOrigin = posLeft;
 
-        ${y(b.hasCap,"if(prev.z > posLeft.z) {\n                vec2 diff = posLeft.xy - posRight.xy;\n                planeOrigin.xy += perpendicular(diff) / 2.0;\n             }")};
+        ${S(j.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.
@@ -76,37 +76,36 @@ return abs(cos) > 0.001 && t > 0.0;
         displacedPos *= minDepth / length(displacedPos);
         return vec4(displacedPos.xyz, 1.0);
       }
-  `)),m(W),j.include(l),W.main.add(w`
+  `)),h(O),L.include(p),O.main.add(y`
     // 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) {
       // Project out of clip space
-      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+      gl_Position = ${s};
     }
     else {
       vec4 pos  = view * vec4(position, 1.0);
       vec4 prev = view * vec4(position + previousDelta.xyz * previousDelta.w, 1.0);
 
-      float lineWidth = getLineWidth(${y(M,"pos.xyz")});
+      float lineWidth = getLineWidth(${S(C,"pos.xyz")});
       float screenMarkerSize = getScreenMarkerSize(lineWidth);
 
       clip(pos, prev);
 
-      ${C?w`${y(b.hideOnShortSegments,w`
+      ${$?y`${S(j.hideOnShortSegments,y`
                 if (areWorldMarkersHidden(pos.xyz, prev.xyz)) {
-                  // Project out of clip space
-                  gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+                  gl_Position = ${s};
                   return;
                 }`)}
             pos.xyz = displace(pos.xyz, prev.xyz, getWorldMarkerSize(pos.xyz));
-            vec4 displacedPosScreen = projectAndScale(pos);`:w`
+            vec4 displacedPosScreen = projectAndScale(pos);`:y`
             vec4 posScreen = projectAndScale(pos);
             vec4 prevScreen = projectAndScale(prev);
             vec4 displacedPosScreen = posScreen;
 
             displacedPosScreen.xy = displace(posScreen.xy, prevScreen.xy, screenMarkerSize);
-            ${y($,w`
+            ${S(W,y`
                 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
@@ -122,8 +121,8 @@ return abs(cos) > 0.001 && t > 0.0;
 
       // Convert texture coordinate into [0,1]
       vUV = (uv0 + 1.0) / 2.0;
-      ${y(!C,"vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);")}
-      ${y(k,"vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);")}
+      ${S(!$,"vUV = noPerspectiveWrite(vUV, displacedPosScreen.w);")}
+      ${S(M,"vLineWidth = noPerspectiveWrite(lineWidth, displacedPosScreen.w);")}
 
       vSize = screenMarkerSize;
       vColor = getColor();
@@ -132,13 +131,13 @@ return abs(cos) > 0.001 && t > 0.0;
       vpos = pos.xyz;
 
       gl_Position = displacedPosScreen;
-    }`),U.include(o,b),j.include(P,b),U.include(c),U.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) {
+    }`),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) {
 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);
-}`),k&&(j.include(p),U.constants.add("relativeMarkerSize","float",r/e).constants.add("relativeTipLineWidth","float",i).code.add(w`
+}`),M&&(L.include(d),U.constants.add("relativeMarkerSize","float",r/e).constants.add("relativeTipLineWidth","float",i).code.add(y`
     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);
@@ -147,18 +146,18 @@ 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));
 
-      ${y(C,"halfTipLineWidth *= fwidth(samplePos.y);")}
+      ${S($,"halfTipLineWidth *= fwidth(samplePos.y);")}
 
       float distance = max(abs(samplePos.x) - halfMarkerSize, abs(samplePos.y) - halfTipLineWidth);
       return clamp(0.5 - distance, 0.0, 1.0);
     }
-  `)),j.include(a,b),j.include(p),U.main.add(w`
+  `)),L.include(a,j),L.include(d),U.main.add(y`
     discardBySlice(vpos);
     discardByTerrainDepth();
 
     vec4 finalColor = intrinsicColor * vColor;
 
     // Cancel out perspective correct interpolation if in screen space or draped
-    vec2 samplePos = ${y(!C,"noPerspectiveRead(vUV)","vUV")};
-    finalColor.a *= ${k?"max(markerAlpha(samplePos), tipAlpha(samplePos))":"markerAlpha(samplePos)"};
-    outputColorHighlightOLID(finalColor, vpos, finalColor.rgb);`),j}const j=Object.freeze(Object.defineProperty({__proto__:null,build:b},Symbol.toStringTag,{value:"Module"}));export{j as L,b};
+    vec2 samplePos = ${S(!$,"noPerspectiveRead(vUV)","vUV")};
+    finalColor.a *= ${M?"max(markerAlpha(samplePos), tipAlpha(samplePos))":"markerAlpha(samplePos)"};
+    outputColorHighlightOLID(finalColor, vpos, finalColor.rgb);`),L}const L=Object.freeze(Object.defineProperty({__proto__:null,build:j},Symbol.toStringTag,{value:"Module"}));export{L,j as b};

package/chunks/PointRenderer.glsl.js

@@ -2,17 +2,17 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fromTranslation as o}from"../core/libs/gl-matrix-2/math/mat4.js";import{create as r}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as t}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{h as s}from"./vec32.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{create as c,positiveInfinity as l}from"../geometry/support/aaBoundingBox.js";import{isColor as p}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePlaneParameters as m,RejectBySlice as d}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{Float2DrawUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{Float2PassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3DrawUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float3DrawUniform.js";import{glsl as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Matrix4DrawUniform.js";import{NoParameters as w}from"../views/webgl/NoParameters.js";import{ShaderBuilder as z}from"../views/webgl/ShaderBuilder.js";class b extends w{constructor(){super(...arguments),this.clipBox=c(l),this.useFixedSizes=!1,this.useRealWorldSymbolSizes=!1,this.scaleFactor=1,this.minSizePx=0,this.size=0,this.sizePx=0}get fixedSize(){return this.drawScreenSpace?this.sizePx:this.size}get screenMinSize(){return this.useFixedSizes?0:this.minSizePx}get drawScreenSpace(){return this.useFixedSizes&&!this.useRealWorldSymbolSizes}}class M extends m{constructor(e,i,o){super(e),this.origin=e,this.isLeaf=i,this.splatSize=o}}function j(r){const a=new z,n=p(r.output),{vertex:c,fragment:l}=a;return a.vertex.include(d,r),a.attributes.add("position","vec3"),a.attributes.add("color","vec3"),c.uniforms.add(new h("modelView",(e,r)=>i(y,r.camera.viewMatrix,o(y,e.origin))),new v("proj",e=>e.camera.projectionMatrix),new g("screenMinMaxSize",(e,i,o)=>t(B,o.useFixedSizes?0:o.minSizePx*i.camera.pixelRatio,P(e.isLeaf)*i.camera.pixelRatio)),r.useFixedSizes?new u("pointScale",(e,i)=>t(B,e.fixedSize*i.camera.pixelRatio,i.camera.fullHeight)):new g("pointScale",(e,i,o)=>t(B,e.splatSize*o.scaleFactor*i.camera.pixelRatio,i.camera.fullHeight/i.camera.pixelRatio))),r.clippingEnabled?c.uniforms.add(new x("clipMin",(e,i,o)=>s(O,o.clipBox[0]-e.origin[0],o.clipBox[1]-e.origin[1],o.clipBox[2]-e.origin[2])),new x("clipMax",(e,i,o)=>s(O,o.clipBox[3]-e.origin[0],o.clipBox[4]-e.origin[1],o.clipBox[5]-e.origin[2]))):(c.constants.add("clipMin","vec3",[-e,-e,-e]),c.constants.add("clipMax","vec3",[e,e,e])),n&&a.varyings.add("vColor","vec3"),c.main.add(S`
+import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fromTranslation as o}from"../core/libs/gl-matrix-2/math/mat4.js";import{create as r}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as t}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{h as s}from"./vec32.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{create as c,positiveInfinity as l}from"../geometry/support/aaBoundingBox.js";import{isColor as p}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePlaneParameters as m,RejectBySlice as d}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{positionOutsideClipSpace as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{Float2DrawUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{Float2PassUniform as S}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3DrawUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float3DrawUniform.js";import{glsl as h}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Matrix4DrawUniform.js";import{NoParameters as z}from"../views/webgl/NoParameters.js";import{ShaderBuilder as b}from"../views/webgl/ShaderBuilder.js";class M extends z{constructor(){super(...arguments),this.clipBox=c(l),this.useFixedSizes=!1,this.useRealWorldSymbolSizes=!1,this.scaleFactor=1,this.minSizePx=0,this.size=0,this.sizePx=0}get fixedSize(){return this.drawScreenSpace?this.sizePx:this.size}get screenMinSize(){return this.useFixedSizes?0:this.minSizePx}get drawScreenSpace(){return this.useFixedSizes&&!this.useRealWorldSymbolSizes}}class j extends m{constructor(e,i,o){super(e),this.origin=e,this.isLeaf=i,this.splatSize=o}}function P(r){const a=new b,n=p(r.output),{vertex:c,fragment:l}=a;return a.vertex.include(d,r),a.attributes.add("position","vec3"),a.attributes.add("color","vec3"),c.uniforms.add(new v("modelView",(e,r)=>i(O,r.camera.viewMatrix,o(O,e.origin))),new w("proj",e=>e.camera.projectionMatrix),new u("screenMinMaxSize",(e,i,o)=>t(R,o.useFixedSizes?0:o.minSizePx*i.camera.pixelRatio,y(e.isLeaf)*i.camera.pixelRatio)),r.useFixedSizes?new S("pointScale",(e,i)=>t(R,e.fixedSize*i.camera.pixelRatio,i.camera.fullHeight)):new u("pointScale",(e,i,o)=>t(R,e.splatSize*o.scaleFactor*i.camera.pixelRatio,i.camera.fullHeight/i.camera.pixelRatio))),r.clippingEnabled?c.uniforms.add(new x("clipMin",(e,i,o)=>s(B,o.clipBox[0]-e.origin[0],o.clipBox[1]-e.origin[1],o.clipBox[2]-e.origin[2])),new x("clipMax",(e,i,o)=>s(B,o.clipBox[3]-e.origin[0],o.clipBox[4]-e.origin[1],o.clipBox[5]-e.origin[2]))):(c.constants.add("clipMin","vec3",[-e,-e,-e]),c.constants.add("clipMax","vec3",[e,e,e])),n&&a.varyings.add("vColor","vec3"),c.main.add(h`
     // Move clipped points outside of clipspace
     if (position.x < clipMin.x || position.y < clipMin.y || position.z < clipMin.z ||
       position.x > clipMax.x || position.y > clipMax.y || position.z > clipMax.z) {
-      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+      gl_Position = ${g};
       gl_PointSize = 0.0;
       return;
     }
 
     if (rejectBySlice(position)) {
-      gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+      gl_Position = ${g};
       gl_PointSize = 0.0;
       return;
     }
@@ -22,7 +22,7 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
 
     float pointSize = pointScale.x;
     vec4 position = proj * camera;
-    ${r.drawScreenSize?S`float clampedScreenSize = pointSize;`:S`float pointRadius = 0.5 * pointSize;
+    ${r.drawScreenSize?h`float clampedScreenSize = pointSize;`:h`float pointRadius = 0.5 * pointSize;
            vec4 cameraOffset = camera + vec4(0.0, pointRadius, 0.0, 0.0);
            vec4 positionOffset = proj * cameraOffset;
            float radius = abs(positionOffset.y - position.y);
@@ -38,7 +38,7 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
 
     gl_PointSize = clampedScreenSize;
     gl_Position = position;
-    ${n?S`vColor = color;`:""}`),a.include(f,r),l.main.add(S`
+    ${n?h`vColor = color;`:""}`),a.include(f,r),l.main.add(h`
     vec2 vOffset = gl_PointCoord - vec2(0.5, 0.5);
     float r2 = dot(vOffset, vOffset);
 
@@ -46,4 +46,4 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
       discard;
     }
     calculateOcclusionAndOutputHighlight();
-    ${n?S`fragColor = vec4(vColor, 1.0);`:""}`),a}function P(e){return e?256:64}const y=r(),O=n(),B=a(),R=Object.freeze(Object.defineProperty({__proto__:null,PointRendererDrawParameters:M,PointRendererPassParameters:b,build:j,getMaxPointSizeScreenspace:P},Symbol.toStringTag,{value:"Module"}));export{b as P,M as a,R as b,j as c,P as g};
+    ${n?h`fragColor = vec4(vColor, 1.0);`:""}`),a}function y(e){return e?256:64}const O=r(),B=n(),R=a(),_=Object.freeze(Object.defineProperty({__proto__:null,PointRendererDrawParameters:j,PointRendererPassParameters:M,build:P,getMaxPointSizeScreenspace:y},Symbol.toStringTag,{value:"Module"}));export{M as P,j as a,_ as b,P as c,y as g};