@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/chunks/Laserlines.glsl.js

@@ -16,8 +16,8 @@ import { Float4PassUniform as g } from "../views/3d/webgl-engine/core/shaderModu
 import { FloatPassUniform as h } from "../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";
 import { glsl as r } from "../views/3d/webgl-engine/core/shaderModules/interfaces.js";
 import { ShaderBuilder as H } from "../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";
-const j = S(6);
-function N(e) {
+const $ = S(6);
+function j(e) {
   const o = new H();
   o.include(_), o.include(W, e);
   const i = o.fragment;
@@ -79,7 +79,7 @@ vec4 color = vec4(0, 0, 0, 0);`), e.heightManifoldEnabled) {
     }
     `);
   }
-  return e.pointDistanceEnabled && (i.uniforms.add(new m("angleCutoff", (t) => u(t)), new g("pointDistanceSphere", (t, n) => $(t, n))), i.code.add(r`{
+  return e.pointDistanceEnabled && (i.uniforms.add(new m("angleCutoff", (t) => u(t)), new g("pointDistanceSphere", (t, n) => N(t, n))), i.code.add(r`{
 float pointDistanceSphereDistance = sphereDistancePixels(pointDistanceSphere, pos);
 vec4 pointDistanceSphereColor = laserlineProfile(pointDistanceSphereDistance);
 float pointDistanceSphereAlpha = 1.0 - smoothstep(angleCutoff.x, angleCutoff.y, abs(dot(normal, normalize(pos - pointDistanceSphere.xyz))));
@@ -104,7 +104,7 @@ color = max(color, intersectsLineColor * intersectsLineAlpha);
 function u(e) {
   return V(k, Math.cos(e.angleCutoff), Math.cos(Math.max(0, e.angleCutoff - S(2))));
 }
-function $(e, o) {
+function N(e, o) {
   return d(U(D), e.pointDistanceOrigin, o.camera.viewMatrix), D[3] = M(e.pointDistanceOrigin, e.pointDistanceTarget), D;
 }
 function q(e, o) {
@@ -122,9 +122,9 @@ function Z(e, o) {
 function C(e, o, i) {
   return d(v, e, i), w(l, o), l[3] = 0, L(l, l, i), G(v, l, K);
 }
-const k = O(), c = P(), l = I(), J = P(), f = P(), v = P(), K = R(), D = F(), ge = Object.freeze(Object.defineProperty({ __proto__: null, build: N, defaultAngleCutoff: j }, Symbol.toStringTag, { value: "Module" }));
+const k = O(), c = P(), l = I(), J = P(), f = P(), v = P(), K = R(), D = F(), ge = Object.freeze(Object.defineProperty({ __proto__: null, build: j, defaultAngleCutoff: $ }, Symbol.toStringTag, { value: "Module" }));
 export {
   ge as L,
-  N as b,
-  j as d
+  j as b,
+  $ as d
 };

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/chunks/LineCallout.glsl.js

@@ -0,0 +1,138 @@
+import { set as c } from "../core/libs/gl-matrix-2/math/vec2.js";
+import { create as g } from "../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { ZEROS as S } from "../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { SliceDraw as m } from "../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";
+import { AlignPixel as v } from "../views/3d/webgl-engine/core/shaderLibrary/hud/AlignPixel.glsl.js";
+import { HUD as u } from "../views/3d/webgl-engine/core/shaderLibrary/hud/HUD.glsl.js";
+import { HUDVisibility as h } from "../views/3d/webgl-engine/core/shaderLibrary/hud/HUDVisibility.glsl.js";
+import { multipassGeometryTest as b } from "../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassGeometryTest.glsl.js";
+import { addScreenSizePerspectiveAlignment as z } from "../views/3d/webgl-engine/core/shaderLibrary/util/ScreenSizePerspective.glsl.js";
+import { Float2PassUniform as l } from "../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";
+import { Float4PassUniform as d } from "../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";
+import { FloatPassUniform as s } from "../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";
+import { glsl as o } from "../views/3d/webgl-engine/core/shaderModules/interfaces.js";
+import { ShaderBuilder as w } from "../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";
+import { VertexAttribute as x } from "../views/3d/webgl-engine/lib/VertexAttribute.js";
+function A(e) {
+  const t = new w(), { vertex: a, fragment: n } = t;
+  return a.include(v), t.include(u, e), t.include(m, e), t.attributes.add(x.UV0, "vec2"), a.uniforms.add(new d("viewport", (i, r) => r.camera.fullViewport), new s("lineSize", (i, r) => i.size > 0 ? Math.max(1, i.size) * r.camera.pixelRatio : 0), new l("pixelToNDC", (i, r) => c(f, 2 / r.camera.fullViewport[2], 2 / r.camera.fullViewport[3])), new s("borderSize", (i, r) => i.borderColor != null ? r.camera.pixelRatio : 0), new l("screenOffset", (i, r) => c(f, i.horizontalScreenOffset * r.camera.pixelRatio, 0))), t.varyings.add("coverageSampling", "vec4"), t.varyings.add("lineSizes", "vec2"), e.multipassEnabled && t.varyings.add("depth", "float"), e.occlusionTestEnabled && t.include(h), e.hasScreenSizePerspective && z(a), a.code.add(o`
+    void main(void) {
+      ProjectHUDAux projectAux;
+      vec4 endPoint = projectPositionHUD(projectAux);
+
+      vec3 vpos = projectAux.posModel;
+      if (rejectBySlice(vpos)) {
+        gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
+        return;
+      }
+    ${e.occlusionTestEnabled ? o`
+      if (!testHUDVisibility(endPoint)) {
+        gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
+        return;
+      }` : ""}
+
+    ${e.hasScreenSizePerspective ? o`
+      vec3 perspectiveFactor = screenSizePerspectiveScaleFactor(projectAux.absCosAngle, projectAux.distanceToCamera, screenSizePerspectiveAlignment);
+      vec2 screenOffsetScaled = applyScreenSizePerspectiveScaleFactorVec2(screenOffset, perspectiveFactor);
+        ` : o`vec2 screenOffsetScaled = screenOffset;`}
+      // Add view dependent polygon offset to get exact same original starting point. This is mostly used to get the
+      // correct depth value
+      vec3 posView = (view * vec4(position, 1.0)).xyz;
+      ${e.multipassEnabled ? "depth = posView.z;" : ""}
+
+      applyHUDViewDependentPolygonOffset(centerOffsetAndDistance.w, projectAux.absCosAngle, posView);
+      vec4 startPoint = proj * vec4(posView, 1.0);
+      // Apply screen offset to both start and end point
+      vec2 screenOffsetNorm = screenOffsetScaled * 2.0 / viewport.zw;
+      startPoint.xy += screenOffsetNorm * startPoint.w;
+      endPoint.xy += screenOffsetNorm * endPoint.w;
+      // Align start and end to pixel origin
+      vec4 startAligned = alignToPixelOrigin(startPoint, viewport.zw);
+      vec4 endAligned = alignToPixelOrigin(endPoint, viewport.zw);
+    ${e.depthHudEnabled ? e.depthHudAlignStartEnabled ? o`endAligned = vec4(endAligned.xy / endAligned.w * startAligned.w, startAligned.zw);` : o`startAligned = vec4(startAligned.xy / startAligned.w * endAligned.w, endAligned.zw);` : ""}
+      vec4 projectedPosition = mix(startAligned, endAligned, uv0.y);
+      // The direction of the line in screen space
+      vec2 screenSpaceDirection = normalize(endAligned.xy / endAligned.w - startAligned.xy / startAligned.w);
+      vec2 perpendicularScreenSpaceDirection = vec2(screenSpaceDirection.y, -screenSpaceDirection.x);
+    ${e.hasScreenSizePerspective ? o`
+      float lineSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(lineSize, perspectiveFactor);
+      float borderSizeScaled = applyScreenSizePerspectiveScaleFactorFloat(borderSize, perspectiveFactor);
+        ` : o`
+      float lineSizeScaled = lineSize;
+      float borderSizeScaled = borderSize;
+        `}
+      float halfPixelSize = lineSizeScaled * 0.5;
+
+      // Compute full ndc offset, adding 1px padding for doing anti-aliasing and the border size
+      float padding = 1.0 + borderSizeScaled;
+      vec2 ndcOffset = (-halfPixelSize - padding + uv0.x * (lineSizeScaled + padding + padding)) * pixelToNDC;
+
+      // Offset x/y from the center of the line in screen space
+      projectedPosition.xy += perpendicularScreenSpaceDirection * ndcOffset * projectedPosition.w;
+
+      // Compute a coverage varying which we can use in the fragment shader to determine
+      // how much a pixel is actually covered by the line (i.e. to anti alias the line).
+      // This works by computing two coordinates that can be linearly interpolated and then
+      // subtracted to find out how far away from the line edge we are.
+      float edgeDirection = (uv0.x * 2.0 - 1.0);
+
+      float halfBorderSize = 0.5 * borderSizeScaled;
+      float halfPixelSizeAndBorder = halfPixelSize + halfBorderSize;
+      float outerEdgeCoverageSampler = edgeDirection * (halfPixelSizeAndBorder + halfBorderSize + 1.0);
+
+      float isOneSided = float(lineSizeScaled < 2.0 && borderSize < 2.0);
+
+      coverageSampling = vec4(
+        // Edge coordinate
+        outerEdgeCoverageSampler,
+
+        // Border edge coordinate
+        outerEdgeCoverageSampler - halfPixelSizeAndBorder * isOneSided,
+
+        // Line offset
+        halfPixelSize - 0.5,
+
+        // Border offset
+        halfBorderSize - 0.5 + halfPixelSizeAndBorder * (1.0 - isOneSided)
+      );
+
+      lineSizes = vec2(lineSizeScaled, borderSizeScaled);
+
+      gl_Position = projectedPosition;
+    }
+  `), n.uniforms.add(new d("uColor", (i) => p(i.color)), new d("borderColor", (i) => p(i.borderColor))), e.multipassEnabled && (n.include(b, e), n.uniforms.add(new l("inverseViewport", (i, r) => r.inverseViewport))), n.code.add(o`
+    void main() {
+      ${e.multipassEnabled ? "if( geometryDepthTest(gl_FragCoord.xy * inverseViewport, depth) ){ discard; }" : ""}
+
+      // Mix between line and border coverage offsets depending on whether we need
+      // a border (based on the sidedness).
+      vec2 coverage = min(1.0 - clamp(abs(coverageSampling.xy) - coverageSampling.zw, 0.0, 1.0), lineSizes);
+
+      // Mix between border and line color based on the line coverage (conceptually the line blends on top of the
+      // border background).
+      //
+      // Anti-alias by blending final result using the full (including optional border) coverage and the color alpha
+      float borderAlpha = uColor.a * borderColor.a * coverage.y;
+      float colorAlpha = uColor.a * coverage.x;
+
+      float finalAlpha = mix(borderAlpha, 1.0, colorAlpha);
+
+    ${e.depthHudEnabled ? o`
+      if (finalAlpha < 0.01) {
+        discard;
+      }
+      ` : o`
+      vec3 finalRgb = mix(borderColor.rgb * borderAlpha, uColor.rgb, colorAlpha);
+      fragColor = vec4(finalRgb, finalAlpha);
+      `}
+  }
+  `), t;
+}
+function p(e) {
+  return e ?? S;
+}
+const f = g(), R = Object.freeze(Object.defineProperty({ __proto__: null, build: A }, Symbol.toStringTag, { value: "Module" }));
+export {
+  R as L,
+  A as b
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/chunks/LineMarker.glsl.js

@@ -0,0 +1,200 @@
+import { markerTextureSize as v, markerSymbolSize as f, markerTipThicknessFactor as h } from "../views/3d/support/engineContent/marker.js";
+import { addLinearDepth as u, addCalculateLinearDepth as S } from "../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";
+import { ShaderOutput as t } from "../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";
+import { SliceDraw as g } from "../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";
+import { RibbonVertexPosition as y } from "../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";
+import { OutputDepth as P } from "../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";
+import { MarkerSizing as x } from "../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";
+import { multipassTerrainTest as z } from "../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";
+import { symbolAlphaCutoff as w } from "../views/3d/webgl-engine/core/shaderLibrary/util/AlphaCutoff.js";
+import { ColorConversion as C } from "../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";
+import { RgbaFloatEncoding as b } from "../views/3d/webgl-engine/core/shaderLibrary/util/RgbaFloatEncoding.glsl.js";
+import { addProjViewLocalOrigin as L, addViewNormal as $, addPixelRatio as k } from "../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";
+import { Float2PassUniform as D } from "../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";
+import { Float4PassUniform as m } from "../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";
+import { FloatPassUniform as N } from "../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";
+import { glsl as a } from "../views/3d/webgl-engine/core/shaderModules/interfaces.js";
+import { Matrix4PassUniform as T } from "../views/3d/webgl-engine/core/shaderModules/Matrix4PassUniform.js";
+import { ShaderBuilder as A } from "../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";
+import { Texture2DPassUniform as O } from "../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";
+import { TransparencyPassType as j } from "../views/3d/webgl-engine/lib/TransparencyPassType.js";
+import { VertexAttribute as l } from "../views/3d/webgl-engine/lib/VertexAttribute.js";
+import { LineMarkerSpace as d, LineMarkerAnchor as W } from "../views/3d/webgl-engine/shaders/LineMarkerTechniqueConfiguration.js";
+function F(e) {
+  const r = new A(), p = e.multipassEnabled && (e.output === t.Color || e.output === t.Alpha), i = e.space === d.World;
+  r.include(y, e), r.include(x, e), e.output === t.LinearDepth && r.include(P, e);
+  const { vertex: o, fragment: c } = r;
+  return c.include(b), L(o, e), r.attributes.add(l.POSITION, "vec3"), r.attributes.add(l.PREVPOSITION, "vec3"), r.attributes.add(l.UV0, "vec2"), r.varyings.add("vColor", "vec4"), r.varyings.add("vpos", "vec3"), r.varyings.add("vUV", "vec2"), r.varyings.add("vSize", "float"), u(r), p && r.varyings.add("depth", "float"), e.hasTip && r.varyings.add("vLineWidth", "float"), o.uniforms.add(new D("nearFar", (n, s) => s.camera.nearFar), new m("viewport", (n, s) => s.camera.fullViewport)), o.code.add(a`vec4 projectAndScale(vec4 pos) {
+vec4 posNdc = proj * pos;
+posNdc.xy *= viewport.zw / posNdc.w;
+return posNdc;
+}`), o.code.add(a`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);
+}
+}`), i ? (r.attributes.add(l.NORMAL, "vec3"), $(o), o.constants.add("tiltThreshold", "float", 0.7), o.code.add(a`vec3 perpendicular(vec3 v) {
+vec3 n = (viewNormal * vec4(normal.xyz, 1.0)).xyz;
+vec3 n2 = cross(v, n);
+vec3 forward = vec3(0.0, 0.0, 1.0);
+float tiltDot = dot(forward, n);
+return abs(tiltDot) < tiltThreshold ? n : n2;
+}`)) : o.code.add(a`vec2 perpendicular(vec2 v) {
+return vec2(v.y, -v.x);
+}`), o.code.add(a`
+      #define vecN ${i ? "vec3" : "vec2"}
+
+      vecN normalizedSegment(vecN pos, vecN prev) {
+        vecN segment = pos - prev;
+        float segmentLen = length(segment);
+
+        // normalize or zero if too short
+        return (segmentLen > 0.001) ? segment / segmentLen : ${i ? "vec3(0.0, 0.0, 0.0)" : "vec2(0.0, 0.0)"};
+      }
+
+      vecN displace(vecN pos, vecN prev, float displacementLen) {
+        vecN segment = normalizedSegment(pos, prev);
+
+        vecN displacementDirU = perpendicular(segment);
+        vecN displacementDirV = segment;
+
+        ${e.anchor === W.Tip ? "pos -= 0.5 * displacementLen * displacementDirV;" : ""}
+
+        return pos + displacementLen * (uv0.x * displacementDirU + uv0.y * displacementDirV);
+      }
+    `), e.space === d.Screen && (o.uniforms.add(new T("inverseProjectionMatrix", (n, s) => s.camera.inverseProjectionMatrix)), o.code.add(a`vec3 inverseProject(vec4 posScreen) {
+posScreen.xy = (posScreen.xy / viewport.zw) * posScreen.w;
+return (inverseProjectionMatrix * posScreen).xyz;
+}`), o.code.add(a`bool rayIntersectPlane(vec3 rayDir, vec3 planeOrigin, vec3 planeNormal, out vec3 intersection) {
+float cos = dot(rayDir, planeNormal);
+float t = dot(planeOrigin, planeNormal) / cos;
+intersection = t * rayDir;
+return abs(cos) > 0.001 && t > 0.0;
+}`), o.uniforms.add(new N("perScreenPixelRatio", (n, s) => s.camera.perScreenPixelRatio)), o.code.add(a`
+      vec4 toFront(vec4 displacedPosScreen, vec3 posLeft, vec3 posRight, vec3 prev, float lineWidth) {
+        // Project displaced position back to camera space
+        vec3 displacedPos = inverseProject(displacedPosScreen);
+
+        // Calculate the plane that we want the marker to lie in. Note that this will always be an approximation since ribbon lines are generally
+        // not planar and we do not know the actual position of the displaced prev vertices (they are offset in screen space, too).
+        vec3 planeNormal = normalize(cross(posLeft - posRight, posLeft - prev));
+        vec3 planeOrigin = posLeft;
+
+        ${e.hasCap ? `
+                if(prev.z > posLeft.z) {
+                  vec2 diff = posLeft.xy - posRight.xy;
+                  planeOrigin.xy += perpendicular(diff) / 2.0;
+                }
+              ` : ""};
+
+        // 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.
+        float offset = lineWidth * perScreenPixelRatio;
+        planeOrigin *= (1.0 - offset);
+
+        // Intersect camera ray with the plane and make sure it is within clip space
+        vec3 rayDir = normalize(displacedPos);
+        vec3 intersection;
+        if (rayIntersectPlane(rayDir, planeOrigin, planeNormal, intersection) && intersection.z < -nearFar[0] && intersection.z > -nearFar[1]) {
+          return vec4(intersection.xyz, 1.0);
+        }
+
+        // Fallback: use depth of pos or prev, whichever is closer to the camera
+        float minDepth = planeOrigin.z > prev.z ? length(planeOrigin) : length(prev);
+        displacedPos *= minDepth / length(displacedPos);
+        return vec4(displacedPos.xyz, 1.0);
+      }
+  `)), k(o), S(r), o.code.add(a`void main(void) {
+if (uv0.y == 0.0) {
+gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+}
+else {
+float lineWidth = getLineWidth();
+float screenMarkerSize = getScreenMarkerSize();
+vec4 pos  = view * vec4(position, 1.0);
+vec4 prev = view * vec4(prevPosition, 1.0);
+clip(pos, prev);`), i ? (e.hideOnShortSegments && o.code.add(a`if (areWorldMarkersHidden(pos, prev)) {
+gl_Position = vec4(1e038, 1e038, 1e038, 1.0);
+return;
+}`), o.code.add(a`pos.xyz = displace(pos.xyz, prev.xyz, getWorldMarkerSize(pos));
+vec4 displacedPosScreen = projectAndScale(pos);`)) : (o.code.add(a`vec4 posScreen = projectAndScale(pos);
+vec4 prevScreen = projectAndScale(prev);
+vec4 displacedPosScreen = posScreen;
+displacedPosScreen.xy = displace(posScreen.xy, prevScreen.xy, screenMarkerSize);`), e.space === d.Screen && o.code.add(a`vec2 displacementDirU = perpendicular(normalizedSegment(posScreen.xy, prevScreen.xy));
+vec3 lineRight = inverseProject(posScreen + lineWidth * vec4(displacementDirU.xy, 0.0, 0.0));
+vec3 lineLeft = pos.xyz + (pos.xyz - lineRight);
+pos = toFront(displacedPosScreen, lineLeft, lineRight, prev.xyz, lineWidth);
+displacedPosScreen = projectAndScale(pos);`)), o.code.add(a`
+        ${p ? "depth = pos.z;" : ""}
+        linearDepth = calculateLinearDepth(nearFar,pos.z);
+
+        // Convert back into NDC
+        displacedPosScreen.xy = (displacedPosScreen.xy / viewport.zw) * displacedPosScreen.w;
+
+        // Convert texture coordinate into [0,1]
+        vUV = (uv0 + 1.0) / 2.0;
+
+        ${i ? "" : "vUV *= displacedPosScreen.w;"}
+
+        ${e.hasTip ? "vLineWidth = lineWidth;" : ""}
+
+        vSize = screenMarkerSize;
+        vColor = getColor();
+
+        // Use camera space for slicing
+        vpos = pos.xyz;
+
+        gl_Position = displacedPosScreen;
+      }
+    }
+  `), p && r.include(z, e), r.include(g, e), c.uniforms.add(new m("intrinsicColor", (n) => n.color), new O("tex", (n) => n.markerTexture)), c.include(C), r.constants.add("texelSize", "float", 1 / v), c.code.add(a`float markerAlpha(vec2 samplePos) {
+samplePos += vec2(0.5, -0.5) * texelSize;
+float sdf = rgba2float(texture(tex, samplePos)) - 0.5;
+float distance = sdf * vSize;
+distance -= 0.5;
+return clamp(0.5 - distance, 0.0, 1.0);
+}`), e.hasTip && (r.constants.add("relativeMarkerSize", "float", f / v), r.constants.add("relativeTipLineWidth", "float", h), c.code.add(a`
+    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);
+      samplePos *= vSize;
+
+      float halfMarkerSize = 0.5 * relativeMarkerSize * vSize;
+      float halfTipLineWidth = 0.5 * max(1.0, relativeTipLineWidth * vLineWidth);
+
+      ${i ? "halfTipLineWidth *= fwidth(samplePos.y);" : ""}
+
+      float distance = max(abs(samplePos.x) - halfMarkerSize, abs(samplePos.y) - halfTipLineWidth);
+      return clamp(0.5 - distance, 0.0, 1.0);
+    }
+  `)), r.constants.add("symbolAlphaCutoff", "float", w), c.code.add(a`
+  void main() {
+    discardBySlice(vpos);
+    ${p ? "terrainDepthTest(depth);" : ""}
+
+    vec4 finalColor = intrinsicColor * vColor;
+
+    ${i ? "vec2 samplePos = vUV;" : "vec2 samplePos = vUV * gl_FragCoord.w;"}
+
+    ${e.hasTip ? "finalColor.a *= max(markerAlpha(samplePos), tipAlpha(samplePos));" : "finalColor.a *= markerAlpha(samplePos);"}
+
+    ${e.output === t.ObjectAndLayerIdColor ? a`finalColor.a = 1.0;` : ""}
+
+    if (finalColor.a < symbolAlphaCutoff) {
+      discard;
+    }
+
+    ${e.output === t.Alpha ? a`fragColor = vec4(finalColor.a);` : ""}
+    ${e.output === t.Color ? a`fragColor = highlightSlice(finalColor, vpos);` : ""}
+    ${e.output === t.Color && e.transparencyPassType === j.Color ? "fragColor = premultiplyAlpha(fragColor);" : ""}
+    ${e.output === t.Highlight ? a`fragColor = vec4(1.0);` : ""}
+    ${e.output === t.LinearDepth ? a`outputDepth(linearDepth);` : ""}
+  }
+  `), r;
+}
+const ie = Object.freeze(Object.defineProperty({ __proto__: null, build: F }, Symbol.toStringTag, { value: "Module" }));
+export {
+  ie as L,
+  F as b
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/chunks/NativeLine.glsl.js

@@ -0,0 +1,40 @@
+import { ShaderOutput as i } from "../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";
+import { SliceDraw as m } from "../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";
+import { Transform as d } from "../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";
+import { VertexColor as n } from "../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";
+import { OutputHighlight as p } from "../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";
+import { symbolAlphaCutoff as c } from "../views/3d/webgl-engine/core/shaderLibrary/util/AlphaCutoff.js";
+import { addProjViewLocalOrigin as f } from "../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";
+import { Float4PassUniform as u } from "../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";
+import { FloatPassUniform as g } from "../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";
+import { glsl as t } from "../views/3d/webgl-engine/core/shaderModules/interfaces.js";
+import { ShaderBuilder as h } from "../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";
+import { VertexAttribute as v } from "../views/3d/webgl-engine/lib/VertexAttribute.js";
+function C(o) {
+  const r = new h(), { vertex: l, fragment: a } = r;
+  return r.include(d, o), r.include(n, o), f(l, o), r.attributes.add(v.POSITION, "vec3"), r.varyings.add("vpos", "vec3"), l.code.add(t`void main(void) {
+vpos = position;
+forwardNormalizedVertexColor();
+gl_Position = transformPosition(proj, view, vpos);
+}`), o.output === i.Highlight && r.include(p, o), r.include(m, o), a.uniforms.add(new g("alphaCoverage", (e, s) => Math.min(1, e.width * s.camera.pixelRatio))), o.hasVertexColors || a.uniforms.add(new u("constantColor", (e) => e.color)), a.code.add(t`
+  void main() {
+    discardBySlice(vpos);
+
+    vec4 color = ${o.hasVertexColors ? "vColor" : "constantColor"};
+
+    ${o.output === i.ObjectAndLayerIdColor ? t`color.a = 1.0;` : ""}
+
+    if (color.a < ${t.float(c)}) {
+      discard;
+    }
+
+    ${o.output === i.Color ? t`fragColor = highlightSlice(color, vpos);` : ""}
+    ${o.output === i.Highlight ? t`outputHighlight();` : ""}
+  }
+  `), r;
+}
+const A = Object.freeze(Object.defineProperty({ __proto__: null, build: C }, Symbol.toStringTag, { value: "Module" }));
+export {
+  A as N,
+  C as b
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/chunks/Path.glsl.js

@@ -0,0 +1,111 @@
+import { ForwardLinearDepth as v, addNearFar as u } from "../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";
+import { ShaderOutput as e } from "../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";
+import { SliceDraw as d } from "../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";
+import { Transform as n } from "../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";
+import { PathVertexPosition as h } from "../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";
+import { OutputDepth as f } from "../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";
+import { OutputHighlight as g } from "../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";
+import { EvaluateAmbientOcclusion as b } from "../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";
+import { EvaluateSceneLighting as y, addAmbientBoostFactor as w, addLightingGlobalFactor as P } from "../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";
+import { addMainLightIntensity as S } from "../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";
+import { multipassTerrainTest as $ } from "../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";
+import { Normals as C } from "../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";
+import { NormalUtils as c } from "../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";
+import { ReadShadowMapDraw as m } from "../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";
+import { ColorConversion as D } from "../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";
+import { addProjViewLocalOrigin as F, addViewNormal as L, addCameraPosition as A } from "../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";
+import { Float3PassUniform as s } from "../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";
+import { FloatPassUniform as p } from "../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";
+import { glsl as t } from "../views/3d/webgl-engine/core/shaderModules/interfaces.js";
+import { ShaderBuilder as N } from "../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";
+import { TransparencyPassType as T } from "../views/3d/webgl-engine/lib/TransparencyPassType.js";
+function _(a) {
+  const o = new N(), { vertex: l, fragment: i } = o;
+  switch (F(l, a), o.varyings.add("vpos", "vec3"), o.include(h, a), a.output !== e.Color && a.output !== e.Alpha || (o.include(n, a), o.include(m, a), o.include(v, a), o.varyings.add("vnormal", "vec3"), o.varyings.add("vcolor", "vec4"), a.multipassEnabled && o.varyings.add("depth", "float"), l.code.add(t`
+      void main() {
+        vpos = calculateVPos();
+        vnormal = normalize(localNormal());
+
+        ${a.multipassEnabled ? "depth = (view * vec4(vpos, 1.0)).z;" : ""}
+        gl_Position = transformPosition(proj, view, vpos);
+
+        ${a.output === e.Color ? "forwardLinearDepth();" : ""}
+
+        vcolor = getColor();
+      }
+    `)), o.include($, a), a.output) {
+    case e.Alpha:
+      o.include(d, a), i.uniforms.add(new p("opacity", (r) => r.opacity)), i.code.add(t`
+      void main() {
+        discardBySlice(vpos);
+        ${a.multipassEnabled ? "terrainDepthTest(depth);" : ""}
+        float combinedOpacity = vcolor.a * opacity;
+        fragColor = vec4(combinedOpacity);
+      }
+    `);
+      break;
+    case e.Color:
+      o.include(d, a), o.include(y, a), o.include(b, a), o.include(m, a), o.include(C, a), A(i, a), w(i), P(i), i.uniforms.add(l.uniforms.get("localOrigin"), new s("ambient", (r) => r.ambient), new s("diffuse", (r) => r.diffuse), new s("specular", (r) => r.specular), new p("opacity", (r) => r.opacity)), i.include(D), S(i), i.code.add(t`
+        void main() {
+          discardBySlice(vpos);
+          ${a.multipassEnabled ? "terrainDepthTest(depth);" : ""}
+
+          shadingParams.viewDirection = normalize(vpos - cameraPosition);
+          shadingParams.normalView = vnormal;
+          vec3 normal = shadingNormal(shadingParams);
+          float ssao = evaluateAmbientOcclusionInverse();
+
+          float additionalAmbientScale = additionalDirectedAmbientLight(vpos + localOrigin);
+          vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
+          ${a.receiveShadows ? "float shadow = readShadowMap(vpos, linearDepth);" : a.spherical ? "float shadow = lightingGlobalFactor * (1.0 - additionalAmbientScale);" : "float shadow = 0.0;"}
+          vec3 albedo = vcolor.rgb * max(ambient, diffuse); // combine the old material parameters into a single one
+          float combinedOpacity = vcolor.a * opacity;
+          albedo += 0.25 * specular; // don't completely ignore specular for now
+
+          vec3 shadedColor = evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);
+          fragColor = vec4(shadedColor, combinedOpacity);
+          fragColor = highlightSlice(fragColor, vpos);
+          ${a.transparencyPassType === T.Color ? "fragColor = premultiplyAlpha(fragColor);" : ""}
+        }
+      `);
+      break;
+    case e.LinearDepth:
+    case e.Shadow:
+    case e.ShadowHighlight:
+    case e.ShadowExcludeHighlight:
+      o.include(n, a), u(o), o.varyings.add("depth", "float"), l.code.add(t`void main() {
+vpos = calculateVPos();
+gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);
+}`), o.include(d, a), o.include(f, a), i.code.add(t`void main() {
+discardBySlice(vpos);
+outputDepth(depth);
+}`);
+      break;
+    case e.Normal:
+      o.include(n, a), o.include(c, a), L(l), o.varyings.add("vnormal", "vec3"), l.code.add(t`void main(void) {
+vpos = calculateVPos();
+vnormal = normalize((viewNormal * vec4(localNormal(), 1.0)).xyz);
+gl_Position = transformPosition(proj, view, vpos);
+}`), o.include(d, a), i.code.add(t`void main() {
+discardBySlice(vpos);
+vec3 normal = normalize(vnormal);
+if (gl_FrontFacing == false) normal = -normal;
+fragColor = vec4(vec3(0.5) + 0.5 * normal, 1.0);
+}`);
+      break;
+    case e.Highlight:
+      o.include(n, a), o.include(c, a), o.varyings.add("vnormal", "vec3"), l.code.add(t`void main(void) {
+vpos = calculateVPos();
+gl_Position = transformPosition(proj, view, vpos);
+}`), o.include(d, a), o.include(g, a), i.code.add(t`void main() {
+discardBySlice(vpos);
+outputHighlight();
+}`);
+  }
+  return o;
+}
+const O = Object.freeze(Object.defineProperty({ __proto__: null, build: _ }, Symbol.toStringTag, { value: "Module" }));
+export {
+  O as P,
+  _ as b
+};