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

@@ -0,0 +1,147 @@
+import { c as f, e as j, g as S } from "../../../../chunks/vec32.js";
+import { create as m } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { setMin as y, setMax as E, create as M, isPoint as A, empty as x, center as L, offset as B } from "../../../../geometry/support/aaBoundingBox.js";
+import { g as C } from "../../../../chunks/sphere.js";
+import { evaluateElevationInfoAtPoint as T } from "./elevationAlignmentUtils.js";
+import { setContextFeature as V } from "./featureExpressionInfoUtils.js";
+import { demResolutionForBoundingBox as R } from "./graphicUtils.js";
+import { Object3DState as v } from "../../webgl-engine/lib/basicInterfaces.js";
+import { Transparency as O } from "../../webgl-engine/lib/edgeRendering/interfaces.js";
+class z {
+  constructor(e, t, s) {
+    this.baseMaterial = e, this.edgeMaterials = t, this.properties = s;
+  }
+}
+class F {
+  get isElevationSource() {
+    return !!this.stageObject.lastValidElevationBB;
+  }
+  constructor(e, t, s, o, n, i, g, d = null) {
+    this.graphics3DSymbolLayer = e, this.stageObject = t, this._uniqueGeometries = s, this._uniqueMaterials = o, this._sharedResource = n, this.elevationAligner = i, this.elevationContext = g, this._edgeState = d, this.type = "object3d", this._stageLayer = null, this._visible = !1, this._addedToStage = !1, this.alignedSampledElevation = 0, this.needsElevationUpdates = !1, this.useObjectOriginAsAttachmentOrigin = !1;
+  }
+  initialize(e) {
+    this._stageLayer = e;
+    const t = e.stage;
+    t.addMany(this._uniqueMaterials), t.addMany(this._uniqueGeometries), t.add(this.stageObject);
+  }
+  destroy() {
+    var t, s;
+    if (!this._stageLayer)
+      return;
+    const e = this._stageLayer.stage;
+    e.removeMany(this._uniqueMaterials), e.removeMany(this._uniqueGeometries), e.remove(this.stageObject), this._addedToStage && (this._stageLayer.remove(this.stageObject), this._addedToStage = !1), (t = e.renderer.edgeView) == null || t.removeObject(this.stageObject), this.stageObject.dispose(), (s = this._sharedResource) == null || s.release(), this._visible = !1, this._stageLayer = null;
+  }
+  layerOpacityChanged(e, t) {
+    if (this._edgeState == null)
+      return;
+    const s = _(this._edgeState.baseMaterial);
+    let o = !1;
+    for (const n of this._edgeState.edgeMaterials)
+      n.objectTransparency !== s && (n.objectTransparency = s, o = !0);
+    o && this.resetEdgeObject(t), this._stageLayer.stage.renderer.ensureEdgeView().updateAllComponentOpacities(this.stageObject, [e]);
+  }
+  slicePlaneEnabledChanged(e, t) {
+    this._edgeState != null && (this._stageLayer.stage.renderer.ensureEdgeView().updateAllComponentMaterials(this.stageObject, this._edgeState.edgeMaterials, { hasSlicePlane: e }, !t), this._edgeState.properties.hasSlicePlane = e);
+  }
+  setVisibility(e) {
+    if (this._stageLayer != null && this._visible !== e && (this._visible = e, this.stageObject.visible = e, this._visible && !this._addedToStage && (this._stageLayer.add(this.stageObject), this._addedToStage = !0), this._edgeState)) {
+      const t = this._stageLayer.stage.renderer.ensureEdgeView();
+      t.hasObject(this.stageObject) ? t.updateObjectVisibility(this.stageObject, e) : e && this._addOrUpdateEdgeObject(t, !1);
+    }
+  }
+  get visible() {
+    return this._visible;
+  }
+  alignWithElevation(e, t, s, o) {
+    if (this.elevationAligner == null)
+      return;
+    s != null && V(this.elevationContext.featureExpressionInfoContext, s);
+    const n = (i, g) => T(i, e, this.elevationContext, t, g);
+    this.alignedSampledElevation = this.elevationAligner(this, this.elevationContext, e.spatialReference, n, t), this.resetEdgeObject(o);
+  }
+  alignWithAbsoluteElevation(e, t, s) {
+    const o = (n, i) => {
+      i.sampledElevation = e, i.verticalDistanceToGround = 0, i.z = e;
+    };
+    this.alignedSampledElevation = this.elevationAligner(this, this.elevationContext, null, o, t), this.resetEdgeObject(s);
+  }
+  getCenterObjectSpace(e = m()) {
+    return f(e, C(this.stageObject.boundingVolumeObjectSpace.bounds));
+  }
+  getBoundingBoxObjectSpace(e = M()) {
+    const t = this.stageObject.boundingVolumeObjectSpace;
+    return y(e, t.min), E(e, t.max), e;
+  }
+  computeAttachmentOrigin(e) {
+    const t = this.stageObject.effectiveTransformation;
+    if (this.useObjectOriginAsAttachmentOrigin)
+      e.render.origin[0] += t[12], e.render.origin[1] += t[13], e.render.origin[2] += t[14], e.render.num++;
+    else
+      for (const s of this.stageObject.geometries)
+        s.computeAttachmentOrigin(c) && (j(c, c, t), S(e.render.origin, e.render.origin, c), e.render.num++);
+  }
+  async getProjectedBoundingBox(e, t, s, o, n) {
+    const i = this.getBoundingBoxObjectSpace(n), g = P, d = A(i) ? 1 : g.length;
+    for (let a = 0; a < d; a++) {
+      const r = g[a];
+      l[0] = i[r[0]], l[1] = i[r[1]], l[2] = i[r[2]], j(l, l, this.stageObject.transformation), h[3 * a] = l[0], h[3 * a + 1] = l[1], h[3 * a + 2] = l[2];
+    }
+    if (!e(h, 0, d))
+      return null;
+    x(i);
+    let b = null;
+    this.calculateRelativeScreenBounds && (b = this.calculateRelativeScreenBounds());
+    for (let a = 0; a < 3 * d; a += 3) {
+      for (let r = 0; r < 3; r++)
+        i[r] = Math.min(i[r], h[a + r]), i[r + 3] = Math.max(i[r + 3], h[a + r]);
+      b && s.push({ location: h.slice(a, a + 3), screenSpaceBoundingRect: b });
+    }
+    if (t != null && t.service && this.elevationContext.mode !== "absolute-height") {
+      L(i, c);
+      const a = this.elevationContext.mode === "relative-to-scene" ? "scene" : "ground";
+      let r = 0;
+      if (t.useViewElevation)
+        r = t.service.getElevation(c[0], c[1], a) ?? 0;
+      else
+        try {
+          const p = R(i, t.service.spatialReference, t);
+          r = await t.service.queryElevation(c[0], c[1], o, p, a) ?? 0;
+        } catch {
+        }
+      B(i, 0, 0, -this.alignedSampledElevation + r);
+    }
+    return i;
+  }
+  addObjectState(e, t) {
+    e === v.Highlight && t.addObject(this.stageObject, this.stageObject.highlight()), e === v.MaskOccludee && t.addObject(this.stageObject, this.stageObject.maskOccludee());
+  }
+  removeObjectState(e) {
+    e.removeObject(this.stageObject);
+  }
+  resetEdgeObject(e) {
+    if (this._edgeState == null)
+      return;
+    const t = this._stageLayer.stage.renderer.ensureEdgeView();
+    this._visible ? this._addOrUpdateEdgeObject(t, e) : t.removeObject(this.stageObject);
+  }
+  _addOrUpdateEdgeObject(e, t) {
+    const s = this._edgeState;
+    if (s == null)
+      return;
+    const o = _(s.baseMaterial);
+    for (const n of s.edgeMaterials)
+      n.objectTransparency = o;
+    e.addOrUpdateObject3D(this.stageObject, s.edgeMaterials, s.properties, !t).then(() => {
+      var n;
+      return (n = this._stageLayer) == null ? void 0 : n.sync();
+    });
+  }
+}
+function _(u) {
+  return u.isVisible() ? u.parameters.transparent ? O.TRANSPARENT : O.OPAQUE : O.INVISIBLE;
+}
+const h = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], l = m(), c = m(), P = [[0, 1, 2], [3, 1, 2], [0, 4, 2], [3, 4, 2], [0, 1, 5], [3, 1, 5], [0, 4, 5], [3, 4, 5]];
+export {
+  F as Graphics3DObject3DGraphicLayer,
+  z as Object3DEdgeState
+};

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

@@ -0,0 +1,8 @@
+class s {
+  constructor(t, a = null) {
+    this.labelText = a, this.elevationOffset = t ?? 0;
+  }
+}
+export {
+  s as Graphics3DObjectMetadata
+};

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

@@ -0,0 +1,16 @@
+import { Object3DStateSet as s } from "../../webgl-engine/lib/Object3DStateSet.js";
+class h {
+  constructor(t, e) {
+    this.stateType = t, this.objectIdField = e, this.objectStateSet = new s(), this.ids = /* @__PURE__ */ new Set(), this.paused = !1;
+  }
+  hasGraphic(t) {
+    if (this.objectIdField) {
+      const e = t.graphic.attributes[this.objectIdField];
+      return this.ids.has(e);
+    }
+    return this.ids.has(t.graphic.uid);
+  }
+}
+export {
+  h as Graphics3DObjectStateSet
+};

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

@@ -0,0 +1,69 @@
+import { makeHandle as i } from "../../../../core/handleUtils.js";
+import { Graphics3DObjectStateSet as h } from "./Graphics3DObjectStateSet.js";
+class o {
+  constructor(t) {
+    this._graphicsCore = t, this._stateSets = new Array();
+  }
+  destroy() {
+    this.reset(), this._stateSets = null;
+  }
+  reset() {
+    this._stateSets && (this._stateSets.forEach((t) => t.objectStateSet.removeAll()), this._stateSets.length = 0);
+  }
+  acquireSet(t, e) {
+    const s = new h(t, e);
+    this._stateSets.push(s);
+    const a = i(() => this.releaseSet(s));
+    return { set: s, handle: a };
+  }
+  releaseSet(t) {
+    t.objectStateSet.removeAll();
+    const e = this._stateSets ? this._stateSets.indexOf(t) : -1;
+    e !== -1 && this._stateSets.splice(e, 1);
+  }
+  _addObjectStateSet(t, e) {
+    t.addObjectStateSet(e.stateType, e.objectStateSet);
+  }
+  _removeObjectStateSet(t, e) {
+    t.removeObjectState(e.objectStateSet);
+  }
+  setUid(t, e) {
+    t.ids.add(e);
+    const s = this._graphicsCore.graphics3DGraphics.get(e);
+    s && this._addObjectStateSet(s, t);
+  }
+  setUids(t, e) {
+    e.forEach((s) => this.setUid(t, s));
+  }
+  setObjectIds(t, e) {
+    e.forEach((s) => t.ids.add(s)), this._initializeSet(t);
+  }
+  addGraphic(t) {
+    this._stateSets.forEach((e) => {
+      !e.paused && e.hasGraphic(t) && this._addObjectStateSet(t, e);
+    });
+  }
+  removeGraphic(t) {
+    this._stateSets.forEach((e) => {
+      e.hasGraphic(t) && this._removeObjectStateSet(t, e);
+    });
+  }
+  allGraphicsDeleted() {
+    this._stateSets && this._stateSets.forEach((t) => t.objectStateSet.removeAll());
+  }
+  _initializeSet(t) {
+    const e = this._graphicsCore.graphics3DGraphics;
+    t.objectIdField ? e.forEach((s) => {
+      s && t.hasGraphic(s) && this._addObjectStateSet(s, t);
+    }) : t.ids.forEach((s) => {
+      const a = e.get(s);
+      a && this._addObjectStateSet(a, t);
+    });
+  }
+  get test() {
+    return { states: this._stateSets };
+  }
+}
+export {
+  o as Graphics3DObjectStates
+};

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

@@ -0,0 +1,347 @@
+import F from "../../../../Color.js";
+import W from "../../../../core/has.js";
+import { throwIfAborted as pe } from "../../../../core/promiseUtils.js";
+import { pt2px as k } from "../../../../core/screenUtils.js";
+import { estimateSize as ue } from "../../../../core/typedArrayUtil.js";
+import { identity as ye, scale as fe, translate as _e, copy as ge } from "../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as oe } from "../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { l as q, F as D, c as N, B as be, g as Pe, s as Y } from "../../../../chunks/vec32.js";
+import { fromArray as b, ONES as E, ZEROS as z, fromValues as J, create as ne } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { ONES as S, create as Re } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { computeTranslationToOriginAndRotation as ve } from "../../../../geometry/projection/computeTranslationToOriginAndRotation.js";
+import { projectPointToVector as xe } from "../../../../geometry/projection/projectPointToVector.js";
+import { create as Le, size as T, containsPoint as Se, center as O } from "../../../../geometry/support/aaBoundingBox.js";
+import { defaultPrimitive as Ce } from "../../../../symbols/support/ObjectSymbol3DLayerResource.js";
+import { objectSymbolLayerPrimitiveBoundingBox as Ee, objectSymbolLayerSizeWithResourceSize as V } from "../../../../symbols/support/symbolLayerUtils3D.js";
+import { estimateNumVerticesForLods as Te, defaultSymbolLayerMemoryComplexity as Oe } from "./defaultSymbolComplexity.js";
+import { perLodInstanceElevationAligner as we } from "./ElevationAligners.js";
+import { needsElevationUpdates3D as Q, evaluateElevationInfoAtPoint as Be, SampleElevationInfo as Ie } from "./elevationAlignmentUtils.js";
+import { Graphics3DLodInstanceGraphicLayer as Ue } from "./Graphics3DLodInstanceGraphicLayer.js";
+import { Graphics3DSymbolLayer as Ae } from "./Graphics3DSymbolLayer.js";
+import { validateSymbolLayerSize as Ge, mixinColorAndOpacity as Fe, computeObjectScale as Z, computeObjectRotation as De } from "./graphicUtils.js";
+import { ApplyRendererDiffResult as w } from "./interfaces.js";
+import { LoadStatus as ze } from "./Loadable.js";
+import { makeLodResources as Ve } from "./lodResourceUtils.js";
+import { fetch as je } from "./objectResourceUtils.js";
+import { placePointOnGeometry as K, extendPointGraphicElevationContext as X } from "./pointUtils.js";
+import { isValidPrimitive as Me, primitiveLodResources as He } from "./primitiveObjectSymbolUtils.js";
+import { SymbolComplexity as $e } from "./SymbolComplexity.js";
+import { getResourceUrlFromSymbolStyle as We } from "./webStyleUtils.js";
+import { initFastSymbolUpdatesState as ee, updateFastSymbolUpdatesState as te, ConvertOptions as ke, evaluateModelTransform as qe, evaluateModelTransformScale as Ne } from "../support/FastSymbolUpdates.js";
+import { CullFaceOptions as B } from "../../webgl-engine/lib/basicInterfaces.js";
+import { VertexAttribute as P } from "../../webgl-engine/lib/VertexAttribute.js";
+import { LodRenderer as Ye } from "../../webgl-engine/lib/lodRendering/LodRenderer.js";
+import { materialsFromLodResources as I, texturesFromLodResources as se, geometriesFromLodResources as re } from "../../webgl-engine/lib/lodRendering/LodResources.js";
+import { DefaultMaterial as Je } from "../../webgl-engine/materials/DefaultMaterial.js";
+import { defaultSchematicMRRFactors as Qe } from "../../webgl-engine/materials/pbrUtils.js";
+class ae {
+  constructor(e, t, s, r, a, i, o, n, c, l, p, h) {
+    this.lodResources = e, this.lodRenderer = t, this.stageResources = s, this.originalMaterialParameters = r, this.resourceSize = a, this.isEsriSymbolResource = i, this.isWosr = o, this.resourceBoundingBox = n, this.symbolSize = c, this.extentPadding = l, this.physicalBasedRenderingEnabled = p, this.pivotOffset = h;
+  }
+}
+class Ut extends Ae {
+  getCachedSize() {
+    const [e, t, s] = this._resources != null ? this._resources.symbolSize : [1, 1, 1];
+    return { width: e, depth: t, height: s };
+  }
+  constructor(e, t, s, r) {
+    super(e, t, s, r), this._resources = null, this._optionalFields = new Array(), this._instanceIndexToGraphicUid = /* @__PURE__ */ new Map(), this._hasLoadedPBRTextures = !1, this._disposeResourceHandles = new Array(), this.skipHighSymbolLodsChanged = !1, this.ensureDrapedStatus(!1), this._hasLoadedPBRTextures = s.physicalBasedRenderingEnabled;
+  }
+  async doLoad(e) {
+    if (!this._drivenProperties.size && Ge(this.symbolLayer))
+      throw new Error();
+    if (this._isPrimitive) {
+      const t = this.symbolLayer.resource, s = t && Me(t.primitive) ? t.primitive : Ce;
+      this._resources = await this._createResourcesForPrimitive(s, e);
+    } else {
+      const t = await We(this.symbol.styleOrigin), s = (t == null ? void 0 : t.href) ?? this.symbolLayer.resource.href;
+      this._resources = await this._createResourcesForUrl(s, e);
+    }
+    this.layerOpacityChanged(), this.slicePlaneEnabledChanged(), this.physicalBasedRenderingChanged(), this.complexity = this.computeComplexity();
+  }
+  get extentPadding() {
+    return this._resources != null ? this._resources.extentPadding : 0;
+  }
+  get _isPrimitive() {
+    var e;
+    return !((e = this.symbolLayer.resource) != null && e.href);
+  }
+  get lodRenderer() {
+    var e;
+    return (e = this._resources) == null ? void 0 : e.lodRenderer;
+  }
+  get materials() {
+    var e;
+    return ((e = this._resources) == null ? void 0 : e.stageResources.materials) ?? [];
+  }
+  _setMaterialTransparencyParameters(e, t = ((r) => (r = ((s) => (s = this.symbolLayer) == null ? void 0 : s.material)()) == null ? void 0 : r.color)()) {
+    const a = this._getCombinedOpacity(t), i = a < 1 || this.needsDrivenTransparentPass;
+    return e.transparent = i, e.opacity = a, e.cullFace = i ? B.None : B.Back, e;
+  }
+  async _createResourcesForPrimitive(e, t) {
+    const s = this.symbolLayer, r = Le(Ee(e)), a = b(T(r)), i = b(V(a, s)), o = q(i), n = !1, c = !1, l = { usePBR: this._context.physicalBasedRenderingEnabled, isSchematic: !0, mrrFactors: [...Qe], ambient: E, diffuse: E, hasSlicePlane: this._context.slicePlaneEnabled, hasSliceHighlight: !1, castShadows: this.symbolLayer.castShadows, offsetTransparentBackfaces: !this.symbolLayer.isPrimitive }, p = !!l.usePBR;
+    this._setMaterialTransparencyParameters(l);
+    const h = this.symbol;
+    if (h.type === "point-3d" && h.verticalOffset) {
+      const { screenLength: y, minWorldLength: g, maxWorldLength: x } = h.verticalOffset;
+      l.verticalOffset = { screenLength: k(y), minWorldLength: g || 0, maxWorldLength: x ?? 1 / 0 }, l.castShadows = !1;
+    }
+    if (this._context.screenSizePerspectiveEnabled && (l.screenSizePerspective = this._context.sharedResources.screenSizePerspectiveSettings), this._drivenProperties.color)
+      l.externalColor = S;
+    else {
+      const y = s.material != null ? s.material.color : null, g = y != null ? F.toUnitRGBA(y) : S;
+      l.externalColor = g;
+    }
+    this._fastUpdates = ee(this._context.renderer, this._fastVisualVariableConvertOptions(r, i, a, null)), l.isInstanced = !0, this._fastUpdates ? (Object.assign(l, this._fastUpdates.materialParameters), this._optionalFields.push(P.FEATUREATTRIBUTE)) : this._hasPerInstanceColor() && (l.hasInstancedColor = !0, this._optionalFields.push(P.COLOR)), W("enable-feature:objectAndLayerId-rendering") && this._optionalFields.push(P.OBJECTANDLAYERIDCOLOR);
+    const m = new Je(l), d = He(e, m);
+    if (!d)
+      throw new Error(`Unknown object symbol primitive: ${e}`);
+    const _ = I(d).map((y) => ({ opacity: 1, transparent: y.parameters.transparent })), f = await this._createStageResources(d, p, t), v = await this._createLodRenderer(d, t);
+    return new ae(d, v, f, _, a, n, c, r, i, o, p, null);
+  }
+  async _createResourcesForUrl(e, t) {
+    var H, $;
+    const s = { materialParameters: { isInstanced: !0, hasSlicePlane: this._context.slicePlaneEnabled, castShadows: this.symbolLayer.castShadows }, streamDataRequester: this._context.streamDataRequester, cache: this._context.sharedResources.objectResourceCache };
+    this._fastUpdates = ee(this._context.renderer, this._fastVisualVariableConvertOptions(null, null, null, null)), this._fastUpdates ? (Object.assign(s.materialParameters, this._fastUpdates.materialParameters), this._optionalFields.push(P.FEATUREATTRIBUTE)) : this._hasPerInstanceColor() && (s.materialParameters.hasInstancedColor = !0, this._optionalFields.push(P.COLOR)), W("enable-feature:objectAndLayerId-rendering") && this._optionalFields.push(P.OBJECTANDLAYERIDCOLOR);
+    const r = this.symbol;
+    if (r.type === "point-3d" && r.verticalOffset) {
+      const { screenLength: u, minWorldLength: C, maxWorldLength: L } = r.verticalOffset;
+      s.materialParameters.verticalOffset = { screenLength: k(u), minWorldLength: C || 0, maxWorldLength: L ?? 1 / 0 }, s.materialParameters.castShadows = !1;
+    }
+    const a = this._context.physicalBasedRenderingEnabled;
+    s.signal = t, s.usePBR = a, s.skipHighLods = this._context.skipHighSymbolLods;
+    const i = await je(e, s), o = i.isEsriSymbolResource, n = i.isWosr, c = Ve(i.lods), l = this._context, p = this.symbolLayer.material, h = this._getExternalColorParameters(p), m = ($ = (H = this.symbolLayer) == null ? void 0 : H.material) == null ? void 0 : $.color, d = this._getCombinedOpacity(m, { hasIntrinsicColor: !0 }), _ = this.needsDrivenTransparentPass, f = I(c), v = I(c).map((u) => ({ opacity: u.parameters.opacity || 1, transparent: u.parameters.transparent }));
+    f.forEach((u) => {
+      const C = u.parameters;
+      u.setParameters(h);
+      const L = C.opacity * d, me = L < 1 || _ || C.transparent;
+      u.setParameters({ opacity: L, transparent: me }), l.screenSizePerspectiveEnabled && u.setParameters({ screenSizePerspective: l.sharedResources.screenSizePerspectiveSettings });
+    });
+    const y = i.referenceBoundingBox, g = b(T(y)), x = b(c.levels[0].pivotOffset), G = b(V(g, this.symbolLayer)), ce = q(G), M = this._fastUpdates;
+    te(M, this._context.renderer, this._fastVisualVariableConvertOptions(y, G, g, x)) && f.forEach((u) => u.setParameters(M.materialParameters));
+    const he = await this._createStageResources(c, a, t), de = await this._createLodRenderer(c, t);
+    return new ae(c, de, he, v, g, o, n, y, G, ce, a, x);
+  }
+  _addDisposeResource(e) {
+    this._disposeResourceHandles.push(e);
+  }
+  async _createStageResources(e, t, s) {
+    const r = this._context.stage, a = I(e);
+    t !== this._context.physicalBasedRenderingEnabled && this.physicalBasedRenderingChanged(), r.addMany(a), this._addDisposeResource(() => r.removeMany(a));
+    const i = se(e);
+    r.addMany(i), this._addDisposeResource(() => {
+      i.forEach((n) => n.unload()), r.removeMany(i);
+    }), await Promise.all(i.map((n) => this._context.stage.schedule(() => n.load(r.renderView.renderingContext), s))), pe(s);
+    const o = re(e);
+    return r.addMany(o), this._addDisposeResource(() => r.removeMany(o)), { materials: a, textures: i, geometries: o };
+  }
+  async _createLodRenderer(e, t) {
+    const s = this._context.stage, r = { layerUid: this._context.layer.uid, graphicUid: (n) => this._instanceIndexToGraphicUid.get(n), notifyGraphicGeometryChanged: (n) => this._context.notifyGraphicGeometryChanged(this._instanceIndexToGraphicUid.get(n)), notifyGraphicVisibilityChanged: (n) => this._context.notifyGraphicVisibilityChanged(this._instanceIndexToGraphicUid.get(n)) }, a = this._fastUpdates, i = a ? { applyTransform: (n, c, l) => {
+      n.getFeatureAttribute(c, U), ge(l, qe(a.materialParameters, U, l));
+    }, scaleFactor: (n, c, l) => {
+      c.getFeatureAttribute(l, U), Ne(n, a.materialParameters, U);
+    } } : null, o = new Ye({ symbol: e, optionalFields: this._optionalFields, metadata: r, shaderTransformation: i }, this._context.scheduler);
+    return o.slicePlaneEnabled = this._context.slicePlaneEnabled, this._addDisposeResource(() => {
+      s.removeRenderPlugin(o), o.destroy();
+    }), await s.addRenderPlugin(o, t), o;
+  }
+  _getExternalColorParameters(e) {
+    const t = {};
+    return this._drivenProperties.color ? t.externalColor = S : (e == null ? void 0 : e.color) != null ? t.externalColor = F.toUnitRGBA(e.color) : (t.externalColor = S, t.colorMixMode = "ignore"), t;
+  }
+  destroy() {
+    super.destroy(), this._cleanupResources();
+  }
+  _cleanupResources() {
+    this._disposeResourceHandles.forEach((e) => e()), this._disposeResourceHandles.length = 0, this._resources = null;
+  }
+  createGraphics3DGraphic(e) {
+    const t = e.graphic;
+    if (!this._validateGeometry(t.geometry))
+      return null;
+    const s = K(t.geometry);
+    if (s == null)
+      return this.logger.warn(`unsupported geometry type for icon symbol: ${t.geometry.type}`), null;
+    const r = this.setGraphicElevationContext(t), a = e.renderingInfo;
+    return this._createAs3DShape(t, s, a, r, t.uid, e.layer.uid);
+  }
+  notifyDestroyGraphicLayer(e) {
+    this._instanceIndexToGraphicUid.delete(e.instanceIndex);
+  }
+  graphicLayerToGraphicId() {
+    return 0;
+  }
+  layerOpacityChanged() {
+    var a, i;
+    if (this._resources == null)
+      return;
+    const e = this._drivenProperties.opacity, t = !this._isPrimitive, s = this._resources.stageResources.materials, r = this._resources.originalMaterialParameters;
+    for (let o = 0; o < s.length; o++) {
+      const n = s[o], c = (i = (a = this.symbolLayer) == null ? void 0 : a.material) == null ? void 0 : i.color, l = r[o], p = this._getCombinedOpacity(c, { hasIntrinsicColor: t }) * l.opacity, h = p < 1 || e || l.transparent;
+      n.setParameters({ opacity: p, transparent: h }), this._isPrimitive && n.setParameters({ cullFace: h ? B.None : B.Back });
+    }
+  }
+  layerElevationInfoChanged(e, t) {
+    return this.updateGraphics3DGraphicElevationInfo(e, t, Q);
+  }
+  slicePlaneEnabledChanged() {
+    if (this._resources == null)
+      return !0;
+    this._resources.lodRenderer.slicePlaneEnabled = this._context.slicePlaneEnabled;
+    for (const e of this._resources.stageResources.materials)
+      e.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled });
+    return !0;
+  }
+  physicalBasedRenderingChanged() {
+    if (this._resources == null)
+      return !0;
+    const { stageResources: e, isWosr: t } = this._resources;
+    for (const s of e.materials)
+      this._isPrimitive ? s.setParameters({ usePBR: this._context.physicalBasedRenderingEnabled, isSchematic: !0 }) : t || s.setParameters({ usePBR: this._context.physicalBasedRenderingEnabled, isSchematic: !1 });
+    return this._hasLoadedPBRTextures !== !1 || this._context.physicalBasedRenderingEnabled !== !0 || (this._hasLoadedPBRTextures = !0, !1);
+  }
+  applyRendererDiff(e, t) {
+    if (this._resources == null)
+      return w.RecreateSymbol;
+    const { stageResources: { materials: s }, lodRenderer: r, resourceBoundingBox: a, symbolSize: i, resourceSize: o, pivotOffset: n } = this._resources;
+    for (const c in e.diff) {
+      if (c !== "visualVariables")
+        return w.RecreateSymbol;
+      if (!te(this._fastUpdates, t, this._fastVisualVariableConvertOptions(a, i, o, n)))
+        return w.RecreateSymbol;
+      for (const l of s)
+        l.setParameters(this._fastUpdates.materialParameters);
+      r.notifyShaderTransformationChanged();
+    }
+    return w.FastUpdate;
+  }
+  computeComplexity() {
+    if (this._resources == null)
+      return super.computeComplexity();
+    const e = this._resources.lodResources, t = Te(e.levels), s = (o) => Array.from(o.attributes.values()).reduce((n, c) => n + ue(c.data, c.indices), 0), r = re(e).reduce((o, n) => o + s(n), 0), a = se(e).reduce((o, n) => o + n.memoryEstimate, 0) + r, i = { ...Oe(this.symbol, this.symbolLayer), resourceBytes: a };
+    return new $e({ verticesPerFeature: t, memory: i });
+  }
+  _hasLodRenderer() {
+    return this._resources != null;
+  }
+  _createAs3DShape(e, t, s, r, a, i) {
+    if (!this._hasLodRenderer() || this._resources == null)
+      return null;
+    const o = this.getFastUpdateAttrValues(e), n = this._context.clippingExtent;
+    if (xe(t, R, this._context.elevationProvider.spatialReference), n != null && !Se(n, R))
+      return null;
+    const c = this._requiresTerrainElevation(r), l = this._computeGlobalTransform(t, r, j, A), p = this._computeLocalTransform(this._resources, this.symbolLayer, s, ie), h = this._resources.lodRenderer.instanceData, m = h.addInstance();
+    this._instanceIndexToGraphicUid.set(m, a), h.setLocalTransform(m, p, !1), h.setGlobalTransform(m, l), o && h.setFeatureAttribute(m, o), this._fastUpdates == null && this._hasPerInstanceColor() && h.setColor(m, Fe(s.color, s.opacity, 255)), this._context.stage.renderView.objectAndLayerIdRenderHelper != null && h.setObjectAndLayerIdColor(m, this._context.stage.renderView.objectAndLayerIdRenderHelper.getObjectAndLayerIdColor({ graphicUid: a, layerUid: i }));
+    const d = new Ue(this, m, we, r);
+    return c && (d.alignedSampledElevation = A.sampledElevation), d.needsElevationUpdates = Q(r.mode), X(d, t, this._context.elevationProvider), d;
+  }
+  _computeGlobalTransform(e, t, s, r) {
+    return Be(e, this._context.elevationProvider, t, this._context.renderCoordsHelper, r), R[0] = e.x, R[1] = e.y, R[2] = r.z, ve(e.spatialReference, R, s, this._context.renderCoordsHelper.spatialReference), s;
+  }
+  _computeLocalTransform(e, t, s, r) {
+    return ye(r), this._applyObjectRotation(s, !1, r), this._applyObjectRotation(t, !0, r), this._applyObjectScale(e, s, r), this._applyAnchor(e, t, r), r;
+  }
+  _applyObjectScale(e, t, s) {
+    var i;
+    if ((i = this._fastUpdates) != null && i.requiresShaderTransformation)
+      return;
+    const r = this._drivenProperties.size && t.size ? t.size : e.symbolSize, a = Z(r, e.symbolSize, e.resourceSize, this._context.renderCoordsHelper.unitInMeters);
+    a[0] === 1 && a[1] === 1 && a[2] === 1 || fe(s, s, a);
+  }
+  prepareSymbolLayerPatch(e) {
+    if (e.diff.type !== "partial")
+      return;
+    const t = e.diff.diff;
+    this._preparePatchTransform(e, t), this._preparePatchColor(e, t);
+  }
+  updateGeometry(e, t) {
+    if (this._resources == null)
+      return !0;
+    const s = t && K(t);
+    if (s == null)
+      return !1;
+    const r = this.getGeometryElevationMode(t);
+    return e.elevationContext.mode === r && (this._computeGlobalTransform(s, e.elevationContext, j, A), this._requiresTerrainElevation(e.elevationContext) && (e.alignedSampledElevation = A.sampledElevation), this._resources.lodRenderer.instanceData.setGlobalTransform(e.instanceIndex, j, !0), X(e, s, this._context.elevationProvider), !0);
+  }
+  _preparePatchTransform(e, t) {
+    if (!(t.heading || t.tilt || t.roll || t.width || t.height || t.depth || t.anchor || t.anchorPosition) || this._resources == null)
+      return;
+    const s = (d, _, f) => (d != null && d.type === "complete" ? d.newValue : _) ?? f, r = s(t.heading, this.symbolLayer.heading, 0), a = s(t.tilt, this.symbolLayer.tilt, 0), i = s(t.roll, this.symbolLayer.roll, 0), o = s(t.width, this.symbolLayer.width, void 0), n = s(t.height, this.symbolLayer.height, void 0), c = s(t.depth, this.symbolLayer.depth, void 0), l = s(t.anchor, this.symbolLayer.anchor, void 0), p = s(t.anchorPosition, this.symbolLayer.anchorPosition, void 0);
+    delete t.heading, delete t.tilt, delete t.roll, delete t.width, delete t.height, delete t.depth, delete t.anchor, delete t.anchorPosition;
+    const h = { heading: r, tilt: a, roll: i, anchor: l, anchorPosition: p }, m = this._resources;
+    this.loadStatus === ze.LOADED && e.symbolLayerStatePatches.push(() => {
+      m.symbolSize = b(V(m.resourceSize, { width: o, height: n, depth: c, isPrimitive: this.symbolLayer.isPrimitive }));
+    }), e.graphics3DGraphicPatches.push((d, _) => {
+      const f = this._computeLocalTransform(m, h, _, ie), v = d.instanceIndex;
+      m.lodRenderer.instanceData.setLocalTransform(v, f, !0);
+    });
+  }
+  _preparePatchColor(e, t) {
+    if (!t.material || t.material.type !== "partial")
+      return;
+    const s = t.material.diff;
+    if (!s.color || s.color.type !== "complete" || s.color.newValue == null || s.color.oldValue == null)
+      return;
+    const r = s.color.newValue, a = r != null ? F.toUnitRGBA(r) : S;
+    delete s.color;
+    const i = this._resources;
+    i != null && e.graphics3DGraphicPatches.push((o) => {
+      let n;
+      this._hasPerInstanceColor() ? (i.lodRenderer.instanceData.setColor(o.instanceIndex, a), n = this._setMaterialTransparencyParameters({}, r)) : n = this._setMaterialTransparencyParameters({ externalColor: a }, r);
+      for (const c of i.stageResources.materials)
+        c.setParameters(n);
+    });
+  }
+  _requiresTerrainElevation(e) {
+    return e.mode !== "absolute-height";
+  }
+  _applyObjectRotation(e, t, s) {
+    var r;
+    if (!((r = this._fastUpdates) != null && r.requiresShaderTransformation) || !t)
+      return De(e.heading, e.tilt, e.roll, s);
+  }
+  _computeAnchor(e, t, s) {
+    const r = ne();
+    switch (s.anchor) {
+      case "center":
+        N(r, O(e)), D(r, r);
+        break;
+      case "top": {
+        const a = O(e);
+        Y(r, -a[0], -a[1], -e[5]);
+        break;
+      }
+      case "bottom": {
+        const a = O(e);
+        Y(r, -a[0], -a[1], -e[2]);
+        break;
+      }
+      case "relative": {
+        const a = O(e), i = T(e), o = s.anchorPosition, n = o ? J(o.x, o.y, o.z) : z;
+        be(r, i, n), Pe(r, r, a), D(r, r);
+        break;
+      }
+      default:
+        t != null ? D(r, t) : N(r, z);
+    }
+    return r;
+  }
+  _applyAnchor(e, t, s) {
+    var a;
+    if ((a = this._fastUpdates) != null && a.requiresShaderTransformation)
+      return;
+    const r = this._computeAnchor(e.resourceBoundingBox, e.pivotOffset, t);
+    r && _e(s, s, r);
+  }
+  _hasPerInstanceColor() {
+    return this._drivenProperties.color || this._drivenProperties.opacity;
+  }
+  _fastVisualVariableConvertOptions(e, t, s, r) {
+    const a = e != null ? b(T(e)) : E, i = e != null ? this._computeAnchor(e, r, this.symbolLayer) : z, o = this._context.renderCoordsHelper.unitInMeters, n = Z(t ?? void 0, t, s, o), c = J(this.symbolLayer.tilt || 0, this.symbolLayer.roll || 0, this.symbolLayer.heading || 0);
+    return new ke({ size: !0, color: !0, rotation: !0, opacity: !1 }, a, t ?? E, o, i, n, c);
+  }
+}
+const R = ne(), ie = oe(), j = oe(), U = Re(), A = new Ie();
+export {
+  Ut as Graphics3DObjectSymbolLayer
+};