@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/Graphics3DGraphic.js

@@ -0,0 +1,164 @@
+import { emptyArray as d } from "../../../../core/arrayUtils.js";
+import { forEach as b } from "../../../../core/asyncUtils.js";
+import { estimateAttributesObjectSize as L } from "../../../../core/byteSizeEstimations.js";
+import _ from "../../../../core/ObjectPool.js";
+import { scale as f } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as g } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { h as E } from "../../../../chunks/vec32.js";
+import { create as G } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import A from "../../../../geometry/Polygon.js";
+import { projectBoundingRect as x } from "../../../../geometry/projection/projectBoundingRect.js";
+import { set as v, zero as S, empty as y, expandWithAABB as B, allFinite as F, toRect as V } from "../../../../geometry/support/aaBoundingBox.js";
+import { create as u, allFinite as j } from "../../../../geometry/support/aaBoundingRect.js";
+import { equals as O } from "../../../../geometry/support/spatialReferenceUtils.js";
+import { computeAABR as z } from "../../../../layers/graphics/dehydratedFeatures.js";
+import { convertFromGeometry as R } from "../../../../layers/graphics/featureConversionUtils.js";
+import { VisibilityFlag as n, VisibilityGroup as o } from "./enums.js";
+import { createFeature as D } from "./featureExpressionInfoUtils.js";
+const m = new _(Array, (p) => v(p, S), null, 10, 5), P = u();
+class $ {
+  get labelLayers() {
+    return this._labelLayers || d;
+  }
+  get extent() {
+    return this._extent;
+  }
+  get isElevationSource() {
+    return this.layers.some((e) => e == null ? void 0 : e.isElevationSource);
+  }
+  constructor(e, i, t, r, s) {
+    this.graphic = e, this.graphics3DSymbol = i, this.layers = t, this._visibleFlags = n.ALL_LABEL, this.deconflictionPriority = 0, ++i.referenced, this._featureExpressionFeature = s ? D(s, e, r) : null;
+  }
+  initialize(e) {
+    this._layer = e, this._forEachSymbolLayerGraphic((i) => {
+      i.initialize(e), i.setVisibility(this.isVisible());
+    });
+  }
+  destroy() {
+    this._forEachSymbolLayerGraphic((e) => e.destroy()), this._calloutLayer = null, --this.graphics3DSymbol.referenced, this.graphics3DSymbol = null;
+  }
+  get destroyed() {
+    return this.layers == null;
+  }
+  clearLabelGraphics() {
+    this._forEachLabelGraphic((e) => e.destroy()), this._labelLayers = null;
+  }
+  addLabelGraphic(e, i) {
+    this._labelLayers || (this._labelLayers = new Array()), this._labelLayers.push(e), e.initialize(i), e.setVisibility(this.isVisible(o.LABEL));
+  }
+  setCalloutGraphic(e) {
+    this._calloutLayer = e, this._layer && (e.initialize(this._layer), e.setVisibility(this.isVisible()));
+  }
+  get calloutLayer() {
+    return this._calloutLayer;
+  }
+  get isDraped() {
+    let e = !1;
+    return this._forEachSymbolLayerGraphic((i) => {
+      i.type === "draped" && (e = !0);
+    }), e;
+  }
+  isVisible(e = o.GRAPHIC, i) {
+    const t = i ? this._visibleFlags | i | o.LABEL * i : this._visibleFlags;
+    return e === o.GRAPHIC ? (t & n.ALL_GRAPHIC) === n.ALL_GRAPHIC : (t & n.ALL_LABEL) === n.ALL_LABEL;
+  }
+  setVisibilityFlag(e, i, t) {
+    const r = this.isVisible(e);
+    t ? this._visibleFlags |= e * i : this._visibleFlags &= ~(e * i);
+    const s = this.isVisible(e);
+    if (r === s)
+      return !1;
+    if (e === o.LABEL)
+      this._forEachLabelGraphic((a) => a.setVisibility(s));
+    else {
+      this._forEachSymbolLayerGraphic((l) => l.setVisibility(s));
+      const a = this.isVisible(o.LABEL);
+      this._forEachLabelGraphic((l) => l.setVisibility(a));
+    }
+    return !0;
+  }
+  getVisibilityFlag(e, i) {
+    return (this._visibleFlags & e * i) != 0;
+  }
+  computeExtent(e) {
+    if (!this._extent) {
+      const i = this.graphic.geometry;
+      if (i == null)
+        return !1;
+      this._extent = u(), z(i, this._extent);
+      const t = i.spatialReference;
+      if (!O(t, e) && !x(this._extent, t, this._extent, e))
+        return this._extent = null, !1;
+    }
+    return !0;
+  }
+  getAsOptimizedGeometry(e, i) {
+    return this._optimizedGeometry || (this._optimizedGeometry = this._convertGraphicToOptimizedGeometry(this.graphic, e, i)), this._optimizedGeometry;
+  }
+  _convertGraphicToOptimizedGeometry(e, i, t) {
+    let r = e.geometry;
+    return r.type !== "mesh" && r.type !== "extent" || (r = A.fromExtent(r.type === "mesh" ? r.extent : r)), R(r, i, t);
+  }
+  get usedMemory() {
+    let e = L(this.graphic.attributes);
+    return this._forEachSymbolLayerGraphic((i) => e += i.graphics3DSymbolLayer.usedMemory), e;
+  }
+  computeAttachmentOrigin() {
+    const e = { render: { origin: G(), num: 0 }, draped: { origin: g(), num: 0 } };
+    for (const i of this.layers)
+      i != null && i.computeAttachmentOrigin(e);
+    return e.render.num > 1 && E(e.render.origin, e.render.origin, 1 / e.render.num), e.draped.num > 1 && f(e.draped.origin, e.draped.origin, 1 / e.draped.num), e;
+  }
+  async getProjectedBoundingBox(e, i, t, r, s) {
+    return s || (s = { boundingBox: null, requiresDrapedElevation: !1, screenSpaceObjects: [] }), s.boundingBox ? y(s.boundingBox) : s.boundingBox = y(), s.requiresDrapedElevation = !1, await b(this.layers, async (a) => {
+      if (a == null)
+        return;
+      const l = a.type === "draped" ? i : e, h = m.acquire(), c = await a.getProjectedBoundingBox(l, t, s.screenSpaceObjects, r, h);
+      isFinite(c[2]) && isFinite(c[5]) || (s.requiresDrapedElevation = !0), c && B(s.boundingBox, h), m.release(h);
+    }), F(s.boundingBox) || j(V(s.boundingBox, P)) ? s : null;
+  }
+  needsElevationUpdates() {
+    var e;
+    for (const i of this.layers)
+      if (i != null && (i.type === "object3d" || i.type === "lod-instance") && i.needsElevationUpdates)
+        return !0;
+    return ((e = this._labelLayers) == null ? void 0 : e.some((i) => (i == null ? void 0 : i.needsElevationUpdates) ?? !1)) ?? !1;
+  }
+  alignWithElevation(e, i, t) {
+    this._forEachRenderedGraphic((r) => {
+      r.type !== "object3d" && r.type !== "lod-instance" || r.alignWithElevation(e, i, this._featureExpressionFeature, t);
+    });
+  }
+  alignWithAbsoluteElevation(e, i, t) {
+    this._forEachRenderedGraphic((r) => {
+      r.type === "object3d" && r.alignWithAbsoluteElevation(e, i, t);
+    });
+  }
+  addObjectStateSet(e, i) {
+    this._forEachSymbolLayerGraphic((t) => t.addObjectState(e, i));
+  }
+  removeObjectState(e) {
+    this._forEachSymbolLayerGraphic((i) => i.removeObjectState(e));
+  }
+  _forEachGraphicList(e, i) {
+    e == null || e.forEach((t) => t && i(t));
+  }
+  _forEachSymbolLayerGraphic(e) {
+    this._forEachGraphicList(this.layers, e), this._calloutLayer && e(this._calloutLayer);
+  }
+  _forEachLabelGraphic(e) {
+    this._forEachGraphicList(this._labelLayers, e);
+  }
+  _forEachRenderedGraphic(e) {
+    this._forEachSymbolLayerGraphic(e), this._forEachLabelGraphic(e);
+  }
+  get test() {
+    const e = this;
+    return { addLabelLayer: (i) => {
+      e._labelLayers || (e._labelLayers = new Array()), e._labelLayers.push(i);
+    } };
+  }
+}
+export {
+  $ as Graphics3DGraphic
+};

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

@@ -0,0 +1,8 @@
+class a {
+  constructor(r, t, i) {
+    this.graphic = r, this.renderingInfo = t, this.layer = i;
+  }
+}
+export {
+  a as Graphics3DGraphicCreationContext
+};

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

@@ -0,0 +1,367 @@
+import k from "../../../../Color.js";
+import { result as I, createTask as j } from "../../../../core/asyncUtils.js";
+import P from "../../../../core/Error.js";
+import { clone as B } from "../../../../core/lang.js";
+import { abortMaybe as O, releaseMaybe as w } from "../../../../core/maybe.js";
+import { throwIfAbortError as E, throwIfAborted as g } from "../../../../core/promiseUtils.js";
+import { pt2px as x, px2pt as N } from "../../../../core/screenUtils.js";
+import { numericHash as q } from "../../../../core/string.js";
+import { dataComponents as W } from "../../../../core/urlUtils.js";
+import { fromValues as D, create as $ } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { create as H, fromValues as T } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { fromValues as J } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { projectPointToVector as Z } from "../../../../geometry/projection/projectPointToVector.js";
+import { containsPoint as K } from "../../../../geometry/support/aaBoundingBox.js";
+import { createRendererExpression as Q } from "../../../../support/arcadeOnDemand.js";
+import { CIMSymbolHelper as z } from "../../../../symbols/cim/CIMSymbolHelper.js";
+import { OverrideHelper as S } from "../../../../symbols/cim/OverrideHelper.js";
+import { evaluateValueOrFunction as X } from "../../../../symbols/cim/utils.js";
+import { scaleCIMSymbol as Y } from "../../../../symbols/support/cimSymbolUtils.js";
+import { defaultPrimitive as ee } from "../../../../symbols/support/IconSymbol3DLayerResource.js";
+import { Symbol3DAnchorPosition2D as te } from "../../../../symbols/support/Symbol3DAnchorPosition2D.js";
+import { getIconHref as re } from "../../../../symbols/support/utils.js";
+import ie from "../../../2d/arcade/callExpressionWithFeature.js";
+import { transparentUnit as se } from "./constants.js";
+import { perObjectElevationAligner as ae } from "./ElevationAligners.js";
+import { SymbolUpdateType as b, elevationModeChangeUpdateType as oe, needsElevationUpdates2D as A } from "./elevationAlignmentUtils.js";
+import { Graphics3DDrapedGraphicLayer as ne } from "./Graphics3DDrapedGraphicLayer.js";
+import { Graphics3DObject3DGraphicLayer as le } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DSymbolLayer as ce } from "./Graphics3DSymbolLayer.js";
+import { validateSymbolLayerSize as he } from "./graphicUtils.js";
+import { ApplyRendererDiffResult as R } from "./interfaces.js";
+import { namedAnchorToHUDMaterialAnchorPos as M } from "./placementUtils.js";
+import { placePointOnGeometry as ue, createStageObject as me, extendPointGraphicElevationContext as de } from "./pointUtils.js";
+import { initFastSymbolUpdatesState as pe, updateFastSymbolUpdatesState as _e, evaluateModelTransformScale as fe, ConvertOptions as ye } from "../support/FastSymbolUpdates.js";
+import { defaultTexSize as F, createTexture as ge, requiresHalfTexelOffset as xe, defaultSymbolSizeRatio as Se } from "../../support/engineContent/sdfPrimitives.js";
+import { drapedZ as be } from "../../terrain/OverlayRenderer.js";
+import { createPointGeometry as U } from "../../webgl-engine/lib/GeometryUtil.js";
+import { RenderGeometry as ve } from "../../webgl-engine/lib/RenderGeometry.js";
+import { Texture as L } from "../../webgl-engine/lib/Texture.js";
+import { HUDMaterial as G } from "../../webgl-engine/materials/HUDMaterial.js";
+const V = T(0, 0, 1), Pe = 16, ze = 1.5, _ = Se, Re = [_ / 2, _ / 2, 1 - _ / 2, 1 - _ / 2], Me = [F * _, F * _];
+class v extends ce {
+  getCachedSize() {
+    return { size: this._getIconSize() };
+  }
+  constructor(e, t, r, i) {
+    super(e, t, r, i), this._cimSymbolMaterials = /* @__PURE__ */ new Map(), this._cimSymbolTextures = /* @__PURE__ */ new Map(), this._cimMaterialParametersInfo = null, this._size = null, this._symbolTextureRatio = 1, this._outlineSize = 0, this._patchTask = null, this._elevationOptions = { supportsOffsetAdjustment: !0, supportsOnTheGround: !0 };
+  }
+  async doLoad(e) {
+    this._validateOrThrow();
+    const t = this._prepareMaterialParameters(), r = this._getPrimitive();
+    if (r != null)
+      this._prepareResourcesPrimitive(t, r);
+    else {
+      const i = re(this.symbolLayer), s = this._getCIMResource(i);
+      s != null ? await this._prepareResourcesCIM(t, JSON.parse(s), e) : await this._prepareResourcesHref(t, i, e);
+    }
+  }
+  _getCIMResource(e) {
+    const t = W(e);
+    return (t == null ? void 0 : t.mediaType) === "application/json" ? t.data : void 0;
+  }
+  _validateOrThrow() {
+    if (this._drivenProperties.size)
+      return;
+    const e = he(this._getIconSize());
+    if (e)
+      throw new P("graphics3diconsymbollayer:invalid-size", e);
+  }
+  _getIconSize() {
+    const e = this.symbolLayer, t = Math.round(e.size != null ? x(e.size) : Pe);
+    return this._drivenProperties.size ? Math.max(t, 64) : t;
+  }
+  _generateTextureCIM(e) {
+    let t = this._cimData;
+    if (t && t.symbol || this.logger.error("Can't create texture, CIM data is undefined"), t.primitiveOverrides) {
+      t = B(t);
+      const u = t.primitiveOverrides;
+      S.evaluateOverrides(u, e, this._arcadeInfo.geometryType, null, null), S.applyOverrides(t.symbol, u);
+    }
+    const r = q(JSON.stringify(t));
+    let i = this._cimSymbolTextures.get(r);
+    if (i)
+      return i;
+    const s = this._context.sharedResources.cimSymbolRasterizer, a = this._context.renderer && this._context.renderer.type === "dictionary" ? this._context.renderer.fieldMap : null;
+    a && S.applyDictionaryTextOverrides(t.symbol, e, a, null);
+    const n = this._cimScaleFactorOrFunction != null ? X(this._cimScaleFactorOrFunction, e) : 1;
+    n !== 1 && t.symbol && Y(t.symbol, n, !0);
+    const o = z.getEnvelope(t, null, s.resourceManager);
+    if (o && o.width && o.height) {
+      const u = o.x + o.width / 2, m = o.y + o.height / 2, l = s.rasterize({ type: "cim", data: t }, o.width, o.height, u, m, 1, "esriGeometryPoint"), c = new te({ x: -o.x / o.width - 0.5, y: (o.height + o.y) / o.height - 0.5 });
+      this._cimMaterialParametersInfo.anchorPosition = this._getAnchorPos("relative", c), i = new L(l, { width: (l == null ? void 0 : l.width) ?? 1, height: (l == null ? void 0 : l.height) ?? 1 });
+    } else
+      i = new L(new ImageData(1, 1), { width: 1, height: 1 });
+    return this._cimSymbolTextures.set(r, i), this._context.stage.add(i), i;
+  }
+  _prepareMaterialParameters() {
+    const e = { anchorPosition: this._getAnchorPos(this.symbolLayer.anchor, this.symbolLayer.anchorPosition) }, t = this.symbol;
+    if (Ce(t)) {
+      const { screenLength: r, minWorldLength: i, maxWorldLength: s } = t.verticalOffset;
+      e.verticalOffset = { screenLength: x(r), minWorldLength: i || 0, maxWorldLength: s ?? 1 / 0 };
+    }
+    return this._context.screenSizePerspectiveEnabled && (e.screenSizePerspective = this._context.sharedResources.screenSizePerspectiveSettings), e.occlusionTest = !0, e.hasSlicePlane = this._context.slicePlaneEnabled, e;
+  }
+  _prepareResourcesPrimitive(e, t) {
+    const r = this._getOutlineSize();
+    if (C(t) && r === 0)
+      throw new Error("Nothing to render");
+    if (this._outlineSize = r, e.color = this._getFillColor(), e.outlineColor = this._getOutlineColor(), e.outlineSize = this._outlineSize, this._context.sharedResources.textures != null) {
+      const s = this._context.sharedResources.textures.fromData(`${t}-icon`, () => ge(t));
+      this._textureHandle = s, e.textureId = s.texture.id;
+    }
+    e.textureIsSignedDistanceField = !0, e.sampleSignedDistanceFieldTexelCenter = xe(t), e.distanceFieldBoundingBox = Re;
+    const i = this._getIconSize();
+    this._size = [i, i], this._symbolTextureRatio = 1 / _, this._createMaterialAndAddToStage(e, this._context.stage);
+  }
+  async _prepareResourcesHref(e, t, r) {
+    this._outlineSize = this._getOutlineSize(), e.color = this._getFillColor(), e.outlineColor = this._getOutlineColor(), e.outlineSize = this._outlineSize, e.textureIsSignedDistanceField = !1;
+    const i = this._getIconSize(), s = i * this._context.graphicsCoreOwner.view.state.rasterPixelRatio;
+    if (this._context.sharedResources.textures != null) {
+      const a = await I(this._context.sharedResources.textures.fromUrl(t, s, { signal: r }));
+      if (a.ok === !1)
+        throw E(a.error), new P("graphics3diconsymbollayer:request-failed", `Failed to load (Request for icon resource failed: ${t})`);
+      this._textureHandle = a.value;
+      const n = a.value.texture;
+      this._size = this._computeSizeFromTexture(n, i), e.textureId = n.id;
+    }
+    this._createMaterialAndAddToStage(e, this._context.stage);
+  }
+  async _prepareResourcesCIM(e, t, r) {
+    if (this._cimData = t, !this._context.sharedResources.cimSymbolRasterizer) {
+      const m = (await import("../../../../symbols/cim/CIMSymbolRasterizer.js")).CIMSymbolRasterizer;
+      g(r), this._context.sharedResources.cimSymbolRasterizer || (this._context.sharedResources.cimSymbolRasterizer = new m(this._context.renderCoordsHelper.spatialReference));
+    }
+    const i = this._context.sharedResources.cimSymbolRasterizer, s = [], a = t, n = a == null ? void 0 : a.symbol;
+    z.fetchResources(n, i.resourceManager, s, r), z.fetchFonts(n, i.resourceManager, s);
+    const o = this._context.layer.fields ? this._context.layer.fields.map((m) => m.toJSON()) : [], u = this._context.renderCoordsHelper.spatialReference;
+    if (this._arcadeInfo = { spatialReference: u, fields: o, geometryType: "esriGeometryPoint" }, a != null && a.primitiveOverrides && s.push(S.createRenderExpressions(a.primitiveOverrides, this._arcadeInfo)), s.length > 0 && (await Promise.all(s), g(r)), this._context.renderer && this._context.renderer.type === "dictionary" && this._context.renderer.scaleExpression) {
+      const m = this._context.renderer;
+      if (m.scaleExpression) {
+        const l = m.scaleExpression, c = await Q(l, this._context.layer.spatialReference, o);
+        this._cimScaleFactorOrFunction = (h, d, f) => {
+          const y = ie(c, h, { $view: f }, "esriGeometryPoint", d);
+          return y !== null ? y : 1;
+        };
+      }
+    }
+    g(r), this._cimMaterialParametersInfo = e, this._cimMaterialParametersInfo.color = this._getFillColor(), this._cimMaterialParametersInfo.outlineColor = [0, 0, 0, 0], this._cimMaterialParametersInfo.outlineSize = 0, this._cimMaterialParametersInfo.textureIsSignedDistanceField = !1;
+  }
+  _getPrimitive() {
+    return this.symbolLayer.resource && this.symbolLayer.resource.href ? null : this.symbolLayer.resource && this.symbolLayer.resource.primitive || ee;
+  }
+  _getOutlineSize() {
+    var r;
+    let e = 0;
+    const t = this.symbolLayer;
+    return ((r = t.outline) == null ? void 0 : r.size) != null ? Math.max(x(t.outline.size), 0) : (e = C(this._getPrimitive()) ? ze : 0, Math.max(e, 0));
+  }
+  _getOutlineColor() {
+    var i;
+    const e = this._getLayerOpacity(), t = this.symbolLayer, r = (i = t == null ? void 0 : t.outline) == null ? void 0 : i.color;
+    if (r != null) {
+      const s = k.toUnitRGB(r), a = r.a * e;
+      return [s[0], s[1], s[2], a];
+    }
+    return [0, 0, 0, 0];
+  }
+  _getFillColor() {
+    var r, i;
+    if (C(this._getPrimitive()))
+      return se;
+    const e = this._getPrimitive() == null, t = (i = (r = this.symbolLayer) == null ? void 0 : r.material) == null ? void 0 : i.color;
+    return this._getCombinedOpacityAndColor(t, { hasIntrinsicColor: e });
+  }
+  _getAnchorPos(e, t) {
+    return e === "relative" ? D((t.x || 0) + 0.5, 0.5 - (t.y || 0)) : e in M ? M[e] : M.center;
+  }
+  _createMaterialAndAddToStage(e, t) {
+    if (this._cimData) {
+      this._fastUpdates = null;
+      let r = e.textureId ? this._cimSymbolMaterials.get(e.textureId) : null;
+      return r || (r = new G(e), this._cimSymbolMaterials.set(e.textureId ?? 0, r), t.add(r)), r;
+    }
+    return this._fastUpdates = pe(this._context.renderer, this._fastVisualVariableConvertOptions()), this._fastUpdates && (e = { ...e, ...this._fastUpdates.materialParameters }), this._materials[0] = new G(e), t.add(this._materials[0]), this._materials[0];
+  }
+  _setDrapingDependentMaterialParameters() {
+    this.draped && (this._forEachMaterial((e) => {
+      e.setParameters({ verticalOffset: null, screenSizePerspective: null, occlusionTest: !1, hasSlicePlane: !1, shaderPolygonOffset: 0, draped: this.draped });
+    }), this.layerOpacityChanged());
+  }
+  destroy() {
+    super.destroy(), this._patchTask = O(this._patchTask), this._forEachMaterial((e) => this._context.stage.remove(e)), this._materials.length = 0, this._cimSymbolMaterials.clear(), this._cimSymbolTextures.forEach((e) => this._context.stage.remove(e)), this._cimSymbolTextures.clear(), this._textureHandle = w(this._textureHandle);
+  }
+  _getScaleFactor(e, t) {
+    if (this._drivenProperties.size && e.size) {
+      for (let r = 0; r < 3; r++) {
+        const i = e.size[r];
+        i && i !== "symbol-value" && i !== "proportional" && (e.size[r] = x(i));
+      }
+      if (e.size[0] === "symbol-value")
+        return 1;
+      if (isFinite(+e.size[0]))
+        return +e.size[0] / t;
+      if (isFinite(+e.size[2]))
+        return +e.size[2] / t;
+    }
+    return 1;
+  }
+  createGraphics3DGraphic(e) {
+    var l;
+    const t = e.graphic;
+    if (!this._validateGeometry(t.geometry))
+      return null;
+    let r, i = [0, 0];
+    if (this._cimData) {
+      if (!this._cimData.symbol)
+        return null;
+      const c = this._generateTextureCIM(t), h = { textureId: c.id, ...this._cimMaterialParametersInfo };
+      r = this._createMaterialAndAddToStage(h, this._context.stage);
+      const d = window.devicePixelRatio || 1;
+      i = [c.parameters.width / d, c.parameters.height / d];
+    } else
+      i = this._size, r = this._materials[0];
+    const s = ue(t.geometry);
+    if (s == null)
+      return this.logger.warn(`unsupported geometry type for icon symbol: ${t.geometry.type}`), null;
+    const a = e.renderingInfo, n = this._getVertexOpacityAndColor(a);
+    let o = 1;
+    if (!((l = this._fastUpdates) != null && l.visualVariables.size)) {
+      const c = i[0] > i[1] ? i[0] : i[1];
+      o = this._getScaleFactor(a, c);
+    }
+    o *= this._symbolTextureRatio;
+    const u = D(i[0] * o, i[1] * o), m = this.setGraphicElevationContext(t);
+    return this.ensureDrapedStatus(m.mode === "on-the-ground") && this._setDrapingDependentMaterialParameters(), this.draped ? this._createAsOverlay(t, s, r, n, u, e.layer.uid) : this._createAs3DShape(t, s, r, n, u, m, t.uid);
+  }
+  layerOpacityChanged() {
+    const e = this._getFillColor(), t = this._getOutlineColor();
+    this._forEachMaterial((r) => {
+      r.setParameters({ color: e }), r.setParameters({ outlineColor: t });
+    });
+  }
+  layerElevationInfoChanged(e, t, r) {
+    const i = this._elevationContext.mode, s = oe(v.elevationModeChangeTypes, r, i);
+    if (s !== b.UPDATE)
+      return s;
+    const a = A(i) || i === "absolute-height";
+    return this.updateGraphics3DGraphicElevationInfo(e, t, () => a);
+  }
+  slicePlaneEnabledChanged() {
+    return this.draped || this._forEachMaterial((e) => {
+      e.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled });
+    }), !0;
+  }
+  physicalBasedRenderingChanged() {
+    return !0;
+  }
+  get pixelRatioChanged() {
+    return this._getPrimitive() != null;
+  }
+  applyRendererDiff(e, t) {
+    var r;
+    for (const i in e.diff) {
+      if (i !== "visualVariables")
+        return R.RecreateSymbol;
+      if (!_e(this._fastUpdates, t, this._fastVisualVariableConvertOptions()))
+        return R.RecreateSymbol;
+      (r = this._materials[0]) == null || r.setParameters(this._fastUpdates.materialParameters);
+    }
+    return R.FastUpdate;
+  }
+  prepareSymbolLayerPatch(e) {
+    var r;
+    if ((r = this._patchTask) == null || r.abort(), e.diff.type !== "partial")
+      return;
+    const t = e.diff.diff;
+    this._preparePatchResource(e, t);
+  }
+  _preparePatchResource(e, t) {
+    var o;
+    if (!t.resource || t.resource.type !== "partial")
+      return;
+    const r = t.resource.diff;
+    if (((o = r == null ? void 0 : r.href) == null ? void 0 : o.type) !== "complete")
+      return;
+    const i = r.href.newValue, { textures: s } = this._context.sharedResources;
+    if (i == null || s == null || this._getCIMResource(i) != null)
+      return;
+    const a = this._getIconSize(), n = a * this._context.graphicsCoreOwner.view.state.pixelRatio;
+    e.symbolLayerStatePatches.push(() => {
+      this._patchTask = O(this._patchTask), this._patchTask = j((u) => this._context.schedule(async (m, l) => {
+        const c = await I(s.fromUrl(i, n, { signal: l }));
+        g(l);
+        const h = !c.ok;
+        if (h && E(c.error), this._textureHandle = w(this._textureHandle), this._patchTask = null, h) {
+          this._forEachMaterial((y) => {
+            y.visible = !1, y.setParameters({ textureId: null });
+          });
+          const f = `Failed to load (Request for icon resource failed: ${i})`;
+          return void this.logger.error(new P("graphics3diconsymbollayer:request-failed", f));
+        }
+        this._textureHandle = c.value;
+        const d = c.value.texture;
+        this._size = this._computeSizeFromTexture(d, a), this._forEachMaterial((f) => {
+          f.setParameters({ textureId: d.id }), f.visible = !0;
+        });
+      }, u));
+    }), delete r.href;
+  }
+  _defaultElevationInfoNoZ() {
+    return Te;
+  }
+  _createAs3DShape(e, t, r, i, s, a, n) {
+    const o = this.getFastUpdateAttrValues(e), u = this._context.layer.uid, m = this._context.stage.renderView.getObjectAndLayerIdColor({ graphicUid: n, layerUid: u }), l = U(r, V, null, i, s, Ie, null, o, m), c = me(this._context, t, l, a, n);
+    if (c == null)
+      return null;
+    const h = new le(this, c.object, [l], null, null, ae, a);
+    return h.alignedSampledElevation = c.sampledElevation, h.needsElevationUpdates = A(a.mode) || a.mode === "absolute-height", h.getScreenSize = this._createScreenSizeGetter(s, o), h.calculateRelativeScreenBounds = (d) => r.calculateRelativeScreenBounds(h.getScreenSize(), 1, d), de(h, t, this._context.elevationProvider), h;
+  }
+  _createAsOverlay(e, t, r, i, s, a) {
+    r.renderPriority = this._renderPriority;
+    const n = H();
+    Z(t, n, this._context.overlaySR), n[2] = be;
+    const o = this._context.clippingExtent;
+    if (o != null && !K(o, n))
+      return null;
+    const u = this.getFastUpdateAttrValues(e), m = this._context.stage.renderView.getObjectAndLayerIdColor({ graphicUid: e.uid, layerUid: this._context.layer.uid }), l = U(r, V, n, i, s, null, null, u, m), c = new ve(l, { layerUid: a, graphicUid: e.uid }), h = new ne(this, [c], null, this._context.drapeSourceRenderer);
+    return h.getScreenSize = this._createScreenSizeGetter(s, u), h.calculateRelativeScreenBounds = (d) => r.calculateRelativeScreenBounds(h.getScreenSize(), 1, d), h;
+  }
+  _createScreenSizeGetter(e, t) {
+    const r = this._outlineSize + 2;
+    if (this._fastUpdates && t) {
+      const a = e[0] / this._symbolTextureRatio, n = e[1] / this._symbolTextureRatio;
+      return (o = $()) => {
+        const [u, m] = fe(Oe, this._fastUpdates.materialParameters, t);
+        return o[0] = u * a + r, o[1] = m * n + r, o;
+      };
+    }
+    const i = e[0] / this._symbolTextureRatio + r, s = e[1] / this._symbolTextureRatio + r;
+    return (a = $()) => (a[0] = i, a[1] = s, a);
+  }
+  _fastVisualVariableConvertOptions() {
+    const e = Math.max(this._size[0], this._size[1]), t = T(e, e, e), r = N(1), i = e * r, s = T(i, i, i);
+    return new ye({ size: !0, color: !0, rotation: !0, opacity: !1 }, t, s, r);
+  }
+  _forEachMaterial(e) {
+    this._materials.forEach(e), this._cimSymbolMaterials.forEach(e);
+  }
+  _computeSizeFromTexture({ parameters: e }, t) {
+    const r = (e.width ?? 1) / (e.height ?? 1);
+    return r > 1 ? [t, Math.round(t / r)] : [Math.round(t * r), t];
+  }
+  test() {
+    return { ...super.test(), material: this._materials[0] };
+  }
+}
+function Ce(p) {
+  return p && p.type === "point-3d" && p.hasVisibleVerticalOffset();
+}
+function C(p) {
+  return p != null && (p === "cross" || p === "x");
+}
+v.PRIMITIVE_SIZE = Me, v.elevationModeChangeTypes = { definedChanged: b.UPDATE, staysOnTheGround: b.NONE, onTheGroundChanged: b.RECREATE };
+const Te = { mode: "relative-to-ground", offset: 0 }, Ie = J(0, 0, 0, 1), Oe = H();
+export {
+  v as Graphics3DIconSymbolLayer
+};

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

@@ -0,0 +1,115 @@
+import y from "../../../../Color.js";
+import { pt2px as v } from "../../../../core/screenUtils.js";
+import { create as C } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { create as x } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { textSymbolLayerSupportsVerticalOffset as O } from "../../../../symbols/callouts/calloutUtils.js";
+import { perObjectElevationAligner as b } from "./ElevationAligners.js";
+import { SymbolUpdateType as d, elevationModeChangeUpdateType as _, needsElevationUpdates2D as g } from "./elevationAlignmentUtils.js";
+import { ElevationContext as E } from "./ElevationContext.js";
+import { Graphics3DObject3DGraphicLayer as P } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DObjectMetadata as S } from "./Graphics3DObjectMetadata.js";
+import { Graphics3DSymbolLayer as U } from "./Graphics3DSymbolLayer.js";
+import { computeCentroid as L } from "./graphicUtils.js";
+import { createStageObject as G, extendPointGraphicElevationContext as D } from "./pointUtils.js";
+import { SymbolComplexity as A } from "./SymbolComplexity.js";
+import { Attribute as p } from "../../webgl-engine/lib/Attribute.js";
+import { ContentObjectType as T } from "../../webgl-engine/lib/ContentObjectType.js";
+import { Geometry as w } from "../../webgl-engine/lib/Geometry.js";
+import { VertexAttribute as h } from "../../webgl-engine/lib/VertexAttribute.js";
+import { LineCalloutMaterial as m, Parameters as $ } from "../../webgl-engine/materials/LineCalloutMaterial.js";
+class f extends U {
+  constructor(e, t) {
+    super(e, null, t, M), this._elevationOptions = { supportsOffsetAdjustment: !0, supportsOnTheGround: !1 }, this.ensureDrapedStatus(!1);
+  }
+  async doLoad() {
+    this._materials[0] = new m(this._materialParameters), this._context.stage.add(this._materials[0]);
+  }
+  destroy() {
+    super.destroy(), this._context.stage.remove(this._materials[0]), this._materials.length = 0;
+  }
+  _perInstanceMaterialParameters(e) {
+    const t = this._materialParameters;
+    return t.horizontalScreenOffset = e.horizontalScreenOffset ?? 0, t.centerOffsetUnits = e.centerOffsetUnits || "world", t;
+  }
+  get _materialParameters() {
+    var s;
+    const e = new $(), t = this.symbol, r = t.callout;
+    if (e.color = r.color != null ? y.toUnitRGBA(r.color) : [0, 0, 0, 0], e.color[3] *= this._getLayerOpacity(), e.size = v(r.size || 0), t.verticalOffset) {
+      const { screenLength: i, minWorldLength: o, maxWorldLength: l } = t.verticalOffset;
+      e.verticalOffset = { screenLength: v(i), minWorldLength: o || 0, maxWorldLength: l ?? 1 / 0 };
+    }
+    e.borderColor = ((s = r.border) == null ? void 0 : s.color) != null ? y.toUnitRGBA(r.border.color) : null;
+    const n = t.symbolLayers.at(0).type === "object", a = t.type === "label-3d";
+    return e.occlusionTest = !n, e.shaderPolygonOffset = n ? 0 : void 0, e.depthHUDAlignStart = a, e.hasSlicePlane = this._context.slicePlaneEnabled, e.screenSizePerspective = this._context.screenSizePerspectiveEnabled ? this._context.sharedResources.screenSizePerspectiveSettings : null, e;
+  }
+  _defaultElevationInfoNoZ() {
+    return I;
+  }
+  createGraphics3DGraphic(e) {
+    const t = e.renderingInfo, r = e.graphic, n = this.setGraphicElevationContext(r, new E(), t.elevationOffset || 0), a = t.symbol, s = this._elevationContext.mode === "on-the-ground" && (a.type === "cim" || !a.symbolLayers.some((o) => o.type === "object" || o.type === "text"));
+    if (a.type !== "label-3d" && s || a.type === "point-3d" && a.symbolLayers.every((o) => o.type === "text" && !O(o)))
+      return null;
+    const i = L(r.geometry);
+    return i == null ? null : this._createAs3DShape(i, n, t, r.uid);
+  }
+  layerOpacityChanged() {
+    var e;
+    (e = this._materials[0]) == null || e.setParameters(this._materialParameters);
+  }
+  layerElevationInfoChanged(e, t, r) {
+    const n = this._elevationContext.mode, a = _(f.elevationModeChangeTypes, r, n);
+    return a !== d.UPDATE || e.forEach((s) => {
+      const i = t(s);
+      i != null && this.updateGraphicElevationContext(s.graphic, i);
+    }), a;
+  }
+  slicePlaneEnabledChanged() {
+    var e;
+    return (e = this._materials[0]) == null || e.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled }), !0;
+  }
+  physicalBasedRenderingChanged() {
+    return !0;
+  }
+  setGraphicElevationContext(e, t, r = 0) {
+    return super.setGraphicElevationContext(e, t), t.addOffsetRenderUnits(r), t;
+  }
+  updateGraphicElevationContext(e, t) {
+    this.setGraphicElevationContext(e, t.elevationContext, t.metadata != null ? t.metadata.elevationOffset : 0), t.needsElevationUpdates = g(t.elevationContext.mode);
+  }
+  computeComplexity() {
+    return new A({ verticesPerFeature: 6 });
+  }
+  _createVertexData(e) {
+    const { translation: t, centerOffset: r } = e, n = new p(t ? [t[0], t[1], t[2]] : [0, 0, 0], u, 3, !0), a = new p(r ? [r[0], r[1], r[2], r[3]] : [0, 0, 0, 1], u, 4, !0);
+    return [[h.POSITION, n], [h.NORMAL, new p([0, 0, 1], u, 3, !0)], [h.CENTEROFFSETANDDISTANCE, a]];
+  }
+  _getOrCreateMaterial(e) {
+    var n;
+    const t = this._perInstanceMaterialParameters(e), r = m.uniqueMaterialIdentifier(t);
+    if (r === ((n = this._materials[0]) == null ? void 0 : n.uniqueMaterialIdentifier))
+      return { material: this._materials[0], isUnique: !1 };
+    if (e.materialCollection != null) {
+      let a = e.materialCollection.get(r);
+      return a == null && (a = new m(t), e.materialCollection.add(r, a)), { material: a, isUnique: !1 };
+    }
+    return { material: new m(t), isUnique: !0 };
+  }
+  _createAs3DShape(e, t, r, n) {
+    const a = this._context.layer.uid, s = this._context.stage.renderView.getObjectAndLayerIdColor({ graphicUid: n, layerUid: a }), i = this._getOrCreateMaterial(r), o = new w(i.material, this._createVertexData(r), null, T.Point, s), l = G(this._context, e, o, t, n);
+    if (l == null)
+      return null;
+    const c = new P(this, l.object, [o], i.isUnique ? [i.material] : null, null, b, t);
+    return c.metadata = new S(r.elevationOffset), c.alignedSampledElevation = l.sampledElevation, c.needsElevationUpdates = g(t.mode), D(c, e, this._context.elevationProvider), c;
+  }
+}
+f.elevationModeChangeTypes = { definedChanged: d.UPDATE, staysOnTheGround: d.UPDATE, onTheGroundChanged: d.RECREATE };
+const u = [0], I = { mode: "relative-to-ground", offset: 0 }, M = { ignoreDrivers: !0, renderPriority: 0, renderPriorityStep: 1 };
+class ae {
+  constructor(e, t, r = C(), n = x(), a = 0, s = "world", i = 0, o = null) {
+    this.renderer = e, this.symbol = t, this.translation = r, this.centerOffset = n, this.horizontalScreenOffset = a, this.centerOffsetUnits = s, this.elevationOffset = i, this.materialCollection = o;
+  }
+}
+export {
+  f as Graphics3DLineCalloutSymbolLayer,
+  ae as LineCalloutSymbolLayerRenderingInfo
+};