@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Graphics3DLineSymbolLayer.js

@@ -0,0 +1,226 @@
+import "../../../../geometry.js";
+import V from "../../../../core/Error.js";
+import { px2pt as A, pt2px as E } from "../../../../core/screenUtils.js";
+import { fromValues as S, clone as I } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { create as w, empty as C, expandWithBuffer as L, intersectsClippingArea as k, expandWithAABB as T } from "../../../../geometry/support/aaBoundingBox.js";
+import { getDriverAxisSizeValueAny as $ } from "../../../../renderers/support/renderingInfoUtils.js";
+import { sharedGeometryElevationAligner as F } from "./ElevationAligners.js";
+import { SymbolUpdateType as P, elevationModeChangeUpdateType as H, needsElevationUpdates2D as G } from "./elevationAlignmentUtils.js";
+import { Graphics3DDrapedGraphicLayer as j } from "./Graphics3DDrapedGraphicLayer.js";
+import { Graphics3DObject3DGraphicLayer as B } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DSymbolLayer as N } from "./Graphics3DSymbolLayer.js";
+import { ApplyRendererDiffResult as v } from "./interfaces.js";
+import { parseCapType as W, parseLineMarkerStyle as z } from "./lineUtils.js";
+import { initFastSymbolUpdatesState as X, updateFastSymbolUpdatesState as q, getAttributeValue as R, ConvertOptions as J } from "../support/FastSymbolUpdates.js";
+import { debugFlags as x } from "../../support/debugFlags.js";
+import { createGeometry as K } from "../../support/engineContent/line.js";
+import { geometryToRenderInfo as Q, geometryToRenderInfoDraped as Y } from "../../support/renderInfoUtils/line.js";
+import { Object3D as Z } from "../../webgl-engine/lib/Object3D.js";
+import { RenderGeometry as ee } from "../../webgl-engine/lib/RenderGeometry.js";
+import { LineMarkerMaterial as te } from "../../webgl-engine/materials/LineMarkerMaterial.js";
+import { getStipplePatternForLinePattern as re } from "../../webgl-engine/materials/lineStippleUtils.js";
+import { RibbonLineMaterial as b } from "../../webgl-engine/materials/RibbonLineMaterial.js";
+import ae from "../../../../geometry/Extent.js";
+import ie from "../../../../geometry/Polygon.js";
+const se = ["polyline", "polygon", "extent"], O = new J({ size: !0, color: !0, rotation: !1, opacity: !0 });
+class D extends N {
+  constructor(e, t, r, a) {
+    super(e, t, r, a);
+  }
+  async doLoad() {
+    if (this._fastUpdates = X(this._context.renderer, O), !this._drivenProperties.size && (this.symbolLayer.size != null ? this.symbolLayer.size : A(1)) < 0)
+      throw new V("graphics3dlinesymbollayer:invalid-size", "Symbol sizes may not be negative values");
+  }
+  _getMaterialParameters(e, t = !1) {
+    var i, n;
+    const r = this._getCombinedOpacityAndColor(t && this._markerColor || this._materialColor);
+    this._patternHidesLine && !t && (r[3] = 0);
+    const a = { width: this._computeMaterialWidth((i = this.symbolLayer) == null ? void 0 : i.size), color: r, hasPolygonOffset: !0, join: this.symbolLayer.join || "miter", cap: W(this.symbolLayer.cap || "butt"), hasSlicePlane: this._context.slicePlaneEnabled, isClosed: e, stipplePattern: re(this.symbolLayer.pattern) };
+    return (n = this._fastUpdates) != null && n.visualVariables ? { ...a, ...this._fastUpdates.materialParameters } : a;
+  }
+  get _materialColor() {
+    var e;
+    return (e = this.symbolLayer.material) == null ? void 0 : e.color;
+  }
+  get _markerColor() {
+    var e;
+    return (e = this.symbolLayer.marker) == null ? void 0 : e.color;
+  }
+  get _lineMaterial() {
+    return this._materials[o.Line] == null && (this._materials[o.Line] = new b(this._getMaterialParameters(!1)), this._context.stage.add(this._materials[o.Line])), this._materials[o.Line];
+  }
+  get _ringMaterial() {
+    return this._materials[o.Ring] == null && (this._materials[o.Ring] = new b(this._getMaterialParameters(!0)), this._context.stage.add(this._materials[o.Ring])), this._materials[o.Ring];
+  }
+  get _wireframeLineMaterial() {
+    return this._materials[o.LineWireframe] == null && (this._materials[o.LineWireframe] = new b({ ...this._getMaterialParameters(!1), wireframe: !0 }), this._context.stage.add(this._materials[o.LineWireframe])), this._materials[o.LineWireframe];
+  }
+  get _wireframeRingMaterial() {
+    return this._materials[o.RingWireframe] == null && (this._materials[o.RingWireframe] = new b({ ...this._getMaterialParameters(!0), wireframe: !0 }), this._context.stage.add(this._materials[o.RingWireframe])), this._materials[o.RingWireframe];
+  }
+  get _markerMaterial() {
+    return this._materials[o.Marker] == null && this.symbolLayer.marker != null && (this._materials[o.Marker] = new te({ ...this._getMaterialParameters(!1, !0), placement: this.symbolLayer.marker.placement, markerPrimitive: z(this.symbolLayer.marker.style) }), this._context.stage.add(this._materials[o.Marker])), this._materials[o.Marker];
+  }
+  destroy() {
+    super.destroy(), this._forEachMaterial((e) => this._context.stage.remove(e)), this._materials.length = 0;
+  }
+  _getDrivenSize(e) {
+    return this._drivenProperties.size && e.size ? E($(e.size)) : 1;
+  }
+  _getDrivenColor(e) {
+    const t = S(1, 1, 1, 1);
+    return this._drivenProperties.color && e.color && (t[0] = e.color[0], t[1] = e.color[1], t[2] = e.color[2], e.color.length > 0 && (t[3] = e.color[3])), this._drivenProperties.opacity && e.opacity && (t[3] = e.opacity), t;
+  }
+  createGraphics3DGraphic(e) {
+    const t = e.graphic;
+    if (!this._validateGeometry(t.geometry, se, this.symbolLayer.type))
+      return null;
+    const r = this.setGraphicElevationContext(t);
+    return this.ensureDrapedStatus(r.mode === "on-the-ground"), this.draped ? this._createAsOverlay(e, this._context.layer.uid) : this._createAs3DShape(e, r, t.uid);
+  }
+  applyRendererDiff(e, t) {
+    for (const r in e.diff) {
+      if (r !== "visualVariables")
+        return v.RecreateSymbol;
+      {
+        const a = this._fastUpdates;
+        if (!q(a, t, O))
+          return v.RecreateSymbol;
+        this._forEachMaterial((i) => i == null ? void 0 : i.setParameters(a.materialParameters));
+      }
+    }
+    return v.FastUpdate;
+  }
+  prepareSymbolLayerPatch(e) {
+    var i, n;
+    if (e.diff.type !== "partial")
+      return;
+    const t = e.diff.diff, r = {};
+    ((i = t.size) == null ? void 0 : i.type) === "complete" && (r.width = this._computeMaterialWidth(t.size.newValue), delete t.size), ((n = t.cap) == null ? void 0 : n.type) === "complete" && (r.cap = W(t.cap.newValue ?? "butt"), delete t.cap);
+    const a = this._prepareMarkerPatch(e, t);
+    this._prepareMaterialPatch(e, t, a), e.symbolLayerStatePatches.push(() => this._forEachMaterial((s) => s == null ? void 0 : s.setParameters(r)));
+  }
+  layerOpacityChanged() {
+    this._forEachMaterial((e, t) => this._updateMaterialLayerOpacity(e, t === o.Marker));
+  }
+  _forEachMaterial(e) {
+    this._materials.forEach(e);
+  }
+  _updateMaterialLayerOpacity(e, t = !1) {
+    var s, l;
+    if (e == null)
+      return;
+    const r = e.parameters.color, a = (l = (s = this.symbolLayer) == null ? void 0 : s.material) == null ? void 0 : l.color, i = this._patternHidesLine && !t ? 0 : this._getCombinedOpacity(a), n = S(r[0], r[1], r[2], i);
+    e.setParameters({ color: n });
+  }
+  layerElevationInfoChanged(e, t, r) {
+    const a = this._elevationContext.mode, i = H(D.elevationModeChangeTypes, r, a);
+    if (i !== P.UPDATE)
+      return i;
+    const n = G(a);
+    return this.updateGraphics3DGraphicElevationInfo(e, t, () => n);
+  }
+  slicePlaneEnabledChanged() {
+    const e = { hasSlicePlane: this._context.slicePlaneEnabled };
+    return this._forEachMaterial((t) => t == null ? void 0 : t.setParameters(e)), !0;
+  }
+  physicalBasedRenderingChanged() {
+    return !0;
+  }
+  _getGeometryAsPolygonOrPolyline(e) {
+    switch (e.type) {
+      case "extent":
+        if (e instanceof ae)
+          return ie.fromExtent(e);
+        break;
+      case "polygon":
+      case "polyline":
+        return e;
+    }
+    return null;
+  }
+  _createAs3DShape(e, t, r) {
+    const a = e.graphic, i = this._getGeometryAsPolygonOrPolyline(a.geometry), n = i.type === "polygon" ? i.rings : i.paths, s = new Array(), l = w(), m = Q(i, this._context.elevationProvider, this._context.renderCoordsHelper, t), h = i.type === "polygon" ? "rings" : "paths";
+    this._logGeometryCreationWarnings(m, n, h, "LineSymbol3DLayer");
+    for (let g = 0; g < m.lines.length; g++) {
+      const y = m.lines[g], u = y.position, c = y.mapPositions;
+      if (this._context.clippingExtent != null && (C(l), L(l, c), !k(l, this._context.clippingExtent)))
+        continue;
+      const f = this._createGeometry(i.type === "polygon" ? this._ringMaterial : this._lineMaterial, e, u, c, i.type, M.ELEVATED, r);
+      s.push(f), x.LINE_WIREFRAMES && s.push(f.instantiate({ material: i.type === "polygon" ? this._wireframeRingMaterial : this._wireframeLineMaterial })), this._markerMaterial != null && s.push(f.instantiate({ material: this._markerMaterial }));
+    }
+    if (s.length === 0)
+      return null;
+    const _ = new Z({ geometries: s, castShadow: !1, layerUid: this._context.layer.uid, graphicUid: r }), d = new B(this, _, s, null, null, F, t);
+    return d.alignedSampledElevation = m.sampledElevation, d.needsElevationUpdates = G(t.mode), d;
+  }
+  _createGeometry(e, t, r, a, i, n, s) {
+    var u, c, f;
+    const l = n === M.DRAPED ? { spatialReference: this._context.overlaySR, renderCoordsHelper: this._context.renderCoordsHelper } : null, m = i === "polygon", h = (u = this._fastUpdates) == null ? void 0 : u.visualVariables.color, _ = (c = this._fastUpdates) == null ? void 0 : c.visualVariables.size, d = (f = this._fastUpdates) == null ? void 0 : f.visualVariables.opacity, g = this._context.stage.renderView.getObjectAndLayerIdColor({ graphicUid: s, layerUid: this._context.layer.uid }), y = { position: r, size: _ ? null : this._getDrivenSize(t.renderingInfo), color: h ? null : this._getDrivenColor(t.renderingInfo), sizeFeature: _ ? R(_.field, t.graphic) : null, colorFeature: h ? R(h.field, t.graphic) : null, opacityFeature: d ? R(d.field, t.graphic) : null };
+    return K(e, { overlayInfo: l, removeDuplicateStartEnd: m, mapPositions: a, attributeData: y }, g);
+  }
+  _createAsOverlay(e, t) {
+    const r = e.graphic, a = this._getGeometryAsPolygonOrPolyline(r.geometry), i = a.type === "polygon" ? a.rings : a.paths, n = a.type === "polygon" ? this._ringMaterial : this._lineMaterial;
+    n.renderPriority = this._renderPriority;
+    const s = x.LINE_WIREFRAMES ? a.type === "polygon" ? this._wireframeRingMaterial : this._wireframeLineMaterial : null, l = this._markerMaterial;
+    s != null && (s.renderPriority = this._renderPriority - 1e-3), l != null && (l.renderPriority = this._renderPriority - 2e-3);
+    const m = new Array(), h = w(), _ = C(), d = Y(a, this._context.overlaySR), g = a.type === "polygon" ? "rings" : "paths";
+    this._logGeometryCreationWarnings(d, i, g, "LineSymbol3DLayer");
+    for (const y of d.lines) {
+      if (C(h), L(h, y.position), !k(h, this._context.clippingExtent))
+        continue;
+      T(_, h);
+      const u = (c) => {
+        const f = this._createGeometry(c, e, y.position, void 0, a.type, M.DRAPED, r.uid), U = new ee(f, { layerUid: t, graphicUid: r.uid });
+        m.push(U);
+      };
+      if (l != null) {
+        u(l);
+        const c = this.symbolLayer.marker.placement;
+        c !== "begin" && c !== "begin-end" || L(h, y.position, 0, 1), c !== "end" && c !== "begin-end" || L(h, y.position, y.position.length - 3, 1);
+      }
+      u(n), x.LINE_WIREFRAMES && u(s);
+    }
+    return new j(this, m, _, this._context.drapeSourceRenderer);
+  }
+  get _patternHidesLine() {
+    const e = this.symbolLayer.pattern;
+    return e != null && e.type === "style" && e.style === "none";
+  }
+  _computeMaterialWidth(e) {
+    var t;
+    return e = e ?? A(1), this._drivenProperties.size ? (t = this._fastUpdates) != null && t.visualVariables.size ? E(1) : 1 : E(e);
+  }
+  _prepareMaterialPatch(e, t, r) {
+    var s, l;
+    const a = t.material;
+    if (a == null)
+      return void (r.changed && r.useMaterialColor && this._patchMaterialColor(this._getCombinedOpacityAndColor(this._materialColor), this._materials[o.Marker], e));
+    if (a.type === "collection")
+      return;
+    const i = a.type === "complete" ? (s = a.newValue) == null ? void 0 : s.color : ((l = a.diff.color) == null ? void 0 : l.type) === "complete" ? a.diff.color.newValue : null, n = this._getCombinedOpacityAndColor(i);
+    r.useMaterialColor && this._patchMaterialColor(I(n), this._materials[o.Marker], e), this._patternHidesLine && (n[3] = 0), this._patchMaterialColor(n, this._materials[o.Line], e), delete t.material;
+  }
+  _prepareMarkerPatch(e, t) {
+    var h;
+    const r = t.marker, a = this._markerMaterial;
+    if (r == null || r.type !== "partial" || r.diff == null || r.diff.placement != null || r.diff.style != null && r.diff.style.type !== "complete" || r.diff.color != null && r.diff.color.type !== "complete" || a == null)
+      return { changed: !1, useMaterialColor: this._markerColor == null };
+    const i = r.diff.color, n = i != null, s = n ? i.newValue : null, l = s == null && this._markerColor == null;
+    s && this._patchMaterialColor(this._getCombinedOpacityAndColor(s), a, e);
+    const m = (h = r.diff.style) == null ? void 0 : h.newValue;
+    return m && e.symbolLayerStatePatches.push(() => a.setParameters({ markerPrimitive: z(m) })), delete t.marker, { changed: n, useMaterialColor: l };
+  }
+  _patchMaterialColor(e, t, r) {
+    t != null && r.symbolLayerStatePatches.push(() => t.setParameters({ color: e }));
+  }
+}
+var M, o;
+D.elevationModeChangeTypes = { definedChanged: P.RECREATE, staysOnTheGround: P.NONE, onTheGroundChanged: P.RECREATE }, function(p) {
+  p[p.DRAPED = 0] = "DRAPED", p[p.ELEVATED = 1] = "ELEVATED";
+}(M || (M = {})), function(p) {
+  p[p.Line = 0] = "Line", p[p.Ring = 1] = "Ring", p[p.LineWireframe = 2] = "LineWireframe", p[p.RingWireframe = 3] = "RingWireframe", p[p.Marker = 4] = "Marker";
+}(o || (o = {}));
+export {
+  D as Graphics3DLineSymbolLayer
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Graphics3DLodInstanceGraphicLayer.js

@@ -0,0 +1,96 @@
+import { create as v } from "../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { e as p, s as b } from "../../../../chunks/vec32.js";
+import { create as f } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { empty as x, expandWithVec3 as I, create as _, isPoint as S, center as R, offset as y } from "../../../../geometry/support/aaBoundingBox.js";
+import { evaluateElevationInfoAtPoint as D } from "./elevationAlignmentUtils.js";
+import { setContextFeature as B } from "./featureExpressionInfoUtils.js";
+import { demResolutionForBoundingBox as E } from "./graphicUtils.js";
+import { Object3DState as C } from "../../webgl-engine/lib/basicInterfaces.js";
+import { Object3DStateID as O } from "../../webgl-engine/lib/Object3DStateID.js";
+class M {
+  constructor(e, t, s, h) {
+    this.graphics3DSymbolLayer = e, this.instanceIndex = t, this.elevationAligner = s, this.elevationContext = h, this.type = "lod-instance", this._highlights = /* @__PURE__ */ new Set(), this.alignedSampledElevation = 0, this.isElevationSource = !1, this.needsElevationUpdates = !1;
+  }
+  initialize() {
+  }
+  setVisibility(e) {
+    const t = this._lodRenderer.instanceData;
+    e !== t.getVisible(this.instanceIndex) && t.setVisible(this.instanceIndex, e);
+  }
+  destroy() {
+    this.instanceIndex != null && (this._lodRenderer.instanceData.removeInstance(this.instanceIndex), this.graphics3DSymbolLayer.notifyDestroyGraphicLayer(this));
+  }
+  alignWithElevation(e, t, s) {
+    if (this.elevationAligner) {
+      B(this.elevationContext.featureExpressionInfoContext, s);
+      const h = (n, d) => D(n, e, this.elevationContext, t, d), c = this.elevationAligner(this, this.elevationContext, e.spatialReference, h, t);
+      c != null && (this.alignedSampledElevation = c);
+    }
+  }
+  getCenterObjectSpace(e = f()) {
+    return this._lodRenderer.instanceData.getCombinedLocalTransform(this.instanceIndex, r), p(e, this._lodRenderer.baseBoundingSphere.center, r);
+  }
+  getBoundingBoxObjectSpace(e = _()) {
+    this._lodRenderer.instanceData.getCombinedLocalTransform(this.instanceIndex, r);
+    const t = this._lodRenderer.baseBoundingBox;
+    x(e);
+    for (let s = 0; s < 8; ++s)
+      b(o, 1 & s ? t[3] : t[0], 2 & s ? t[4] : t[1], 4 & s ? t[5] : t[2]), p(o, o, r), I(e, o);
+    return e;
+  }
+  computeAttachmentOrigin(e) {
+    this._lodRenderer.instanceData.getGlobalTransform(this.instanceIndex, r), e.render.origin[0] += r[12], e.render.origin[1] += r[13], e.render.origin[2] += r[14], e.render.num++;
+  }
+  async getProjectedBoundingBox(e, t, s, h, c) {
+    const n = this.getBoundingBoxObjectSpace(c), d = j, g = S(n) ? 1 : d.length;
+    this._lodRenderer.instanceData.getGlobalTransform(this.instanceIndex, r);
+    for (let i = 0; i < g; i++) {
+      const a = d[i];
+      o[0] = n[a[0]], o[1] = n[a[1]], o[2] = n[a[2]], p(o, o, r), l[3 * i] = o[0], l[3 * i + 1] = o[1], l[3 * i + 2] = o[2];
+    }
+    if (!e(l, 0, g))
+      return null;
+    x(n);
+    let m = null;
+    this.calculateRelativeScreenBounds && (m = this.calculateRelativeScreenBounds());
+    for (let i = 0; i < 3 * g; i += 3) {
+      for (let a = 0; a < 3; a++)
+        n[a] = Math.min(n[a], l[i + a]), n[a + 3] = Math.max(n[a + 3], l[i + a]);
+      m && s.push({ location: l.slice(i, i + 3), screenSpaceBoundingRect: m });
+    }
+    if (t && (R(n, u), this.elevationContext.mode !== "absolute-height")) {
+      let i;
+      const a = E(n, t.service.spatialReference, t);
+      try {
+        i = await t.service.queryElevation(u[0], u[1], h, a, "ground");
+      } catch {
+      }
+      i != null && y(n, 0, 0, -this.alignedSampledElevation + i);
+    }
+    return n;
+  }
+  addObjectState(e, t) {
+    if (e === C.Highlight) {
+      const s = new O(e);
+      this._addHighlightId(s), t.addExternal((h) => {
+        this._removeHighlightId(h);
+      }, s);
+    }
+  }
+  removeObjectState(e) {
+    this._highlights.forEach((t) => e.remove(t));
+  }
+  _addHighlightId(e) {
+    this._highlights.add(e), this._lodRenderer.instanceData.setHighlight(this.instanceIndex, !0);
+  }
+  _removeHighlightId(e) {
+    this._highlights.delete(e), this._lodRenderer.instanceData.setHighlight(this.instanceIndex, this._highlights.size > 0);
+  }
+  get _lodRenderer() {
+    return this.graphics3DSymbolLayer.lodRenderer;
+  }
+}
+const l = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], o = f(), u = f(), j = [[0, 1, 2], [3, 1, 2], [0, 4, 2], [3, 4, 2], [0, 1, 5], [3, 1, 5], [0, 4, 5], [3, 4, 5]], r = v();
+export {
+  M as Graphics3DLodInstanceGraphicLayer
+};