@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/webgl-engine/lib/lodRendering/InstanceData.js

@@ -0,0 +1,174 @@
+import { _ as c } from "../../../../../chunks/tslib.es6.js";
+import F from "../../../../../core/Accessor.js";
+import { reallocGrowthFactor as I } from "../../../../../core/arrayUtils.js";
+import M from "../../../../../core/Evented.js";
+import { property as f } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/has.js";
+import "../../../../../core/Logger.js";
+import { subclass as v } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { fromMat4 as S, invert as w, transpose as C } from "../../../../../core/libs/gl-matrix-2/math/mat3.js";
+import { create as R } from "../../../../../core/libs/gl-matrix-2/factories/mat3f64.js";
+import { multiply as V } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as O } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { s as y } from "../../../../../chunks/vec32.js";
+import { create as b } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { BufferViewMat4f64 as d, BufferViewVec3f64 as D, BufferViewMat3f as T, BufferViewVec2f as N, BufferViewVec4f64 as H, BufferViewVec4f as B, BufferViewVec4u8 as _, BufferViewUint8 as u } from "../../../../../geometry/support/buffer/BufferView.js";
+import { scaleFromMatrix as G } from "../../../support/mathUtils.js";
+import { newLayout as x } from "../../../support/buffer/InterleavedLayout.js";
+import { assert as L } from "../Util.js";
+import { VertexAttribute as s } from "../VertexAttribute.js";
+import { initialCapacity as A } from "./RenderInstanceData.js";
+var r;
+function $(e) {
+  let t = x().mat4f64(s.LOCALTRANSFORM).mat4f64(s.GLOBALTRANSFORM).vec4f64(s.BOUNDINGSPHERE).vec3f64(s.MODELORIGIN).mat3f(s.INSTANCEMODEL).mat3f(s.INSTANCEMODELNORMAL).vec2f(s.MODELSCALEFACTORS);
+  return e.includes(s.FEATUREATTRIBUTE) && (t = t.vec4f(s.FEATUREATTRIBUTE)), e.includes(s.COLOR) && (t = t.vec4u8(s.COLOR)), e.includes(s.OBJECTANDLAYERIDCOLOR) && (t = t.vec4u8(s.OBJECTANDLAYERIDCOLOR)), t = t.u8(s.STATE).u8(s.LODLEVEL), t;
+}
+(function(e) {
+  e[e.ALLOCATED = 1] = "ALLOCATED", e[e.DEFAULT_ACTIVE = 2] = "DEFAULT_ACTIVE", e[e.VISIBLE = 4] = "VISIBLE", e[e.HIGHLIGHT = 8] = "HIGHLIGHT", e[e.HIGHLIGHT_ACTIVE = 16] = "HIGHLIGHT_ACTIVE", e[e.REMOVE = 32] = "REMOVE", e[e.TRANSFORM_CHANGED = 64] = "TRANSFORM_CHANGED", e[e.ACTIVE = 18] = "ACTIVE";
+})(r || (r = {}));
+class E {
+  constructor(t) {
+    this.localTransform = t.getField(s.LOCALTRANSFORM, d), this.globalTransform = t.getField(s.GLOBALTRANSFORM, d), this.modelOrigin = t.getField(s.MODELORIGIN, D), this.model = t.getField(s.INSTANCEMODEL, T), this.modelNormal = t.getField(s.INSTANCEMODELNORMAL, T), this.modelScaleFactors = t.getField(s.MODELSCALEFACTORS, N), this.boundingSphere = t.getField(s.BOUNDINGSPHERE, H), this.featureAttribute = t.getField(s.FEATUREATTRIBUTE, B), this.color = t.getField(s.COLOR, _), this.objectAndLayerIdColor = t.getField(s.OBJECTANDLAYERIDCOLOR, _), this.state = t.getField(s.STATE, u), this.lodLevel = t.getField(s.LODLEVEL, u);
+  }
+}
+let h = class extends F {
+  constructor(e, t) {
+    super(e), this.events = new M(), this._capacity = 0, this._size = 0, this._next = 0, this._layout = $(t), this._capacity = A, this._buffer = this._layout.createBuffer(this._capacity), this._view = new E(this._buffer);
+  }
+  get capacity() {
+    return this._capacity;
+  }
+  get size() {
+    return this._size;
+  }
+  get view() {
+    return this._view;
+  }
+  addInstance() {
+    this._size + 1 > this._capacity && this._grow();
+    const e = this._findSlot();
+    return this._view.state.set(e, r.ALLOCATED), this._size++, this.events.emit("instances-changed"), e;
+  }
+  removeInstance(e) {
+    const t = this._view.state;
+    L(e >= 0 && e < this._capacity && (t.get(e) & r.ALLOCATED) != 0, "invalid instance handle"), this._getStateFlag(e, r.ACTIVE) ? this._setStateFlags(e, r.REMOVE) : this.freeInstance(e), this.events.emit("instances-changed");
+  }
+  freeInstance(e) {
+    const t = this._view.state;
+    L(e >= 0 && e < this._capacity && (t.get(e) & r.ALLOCATED) != 0, "invalid instance handle"), t.set(e, 0), this._size--;
+  }
+  setLocalTransform(e, t, a = !0) {
+    this._view.localTransform.setMat(e, t), a && this.updateModelTransform(e);
+  }
+  getLocalTransform(e, t) {
+    this._view.localTransform.getMat(e, t);
+  }
+  setGlobalTransform(e, t, a = !0) {
+    this._view.globalTransform.setMat(e, t), a && this.updateModelTransform(e);
+  }
+  getGlobalTransform(e, t) {
+    this._view.globalTransform.getMat(e, t);
+  }
+  updateModelTransform(e) {
+    const t = this._view, a = i, n = o;
+    t.localTransform.getMat(e, p), t.globalTransform.getMat(e, g);
+    const l = V(g, g, p);
+    y(a, l[12], l[13], l[14]), t.modelOrigin.setVec(e, a), S(n, l), t.model.setMat(e, n);
+    const m = G(i, l);
+    m.sort(), t.modelScaleFactors.set(e, 0, m[1]), t.modelScaleFactors.set(e, 1, m[2]), w(n, n), C(n, n), t.modelNormal.setMat(e, n), this._setStateFlags(e, r.TRANSFORM_CHANGED), this.events.emit("instance-transform-changed", { index: e });
+  }
+  getModelTransform(e, t) {
+    const a = this._view;
+    a.model.getMat(e, o), a.modelOrigin.getVec(e, i), t[0] = o[0], t[1] = o[1], t[2] = o[2], t[3] = 0, t[4] = o[3], t[5] = o[4], t[6] = o[5], t[7] = 0, t[8] = o[6], t[9] = o[7], t[10] = o[8], t[11] = 0, t[12] = i[0], t[13] = i[1], t[14] = i[2], t[15] = 1;
+  }
+  applyShaderTransformation(e, t) {
+    this.shaderTransformation != null && this.shaderTransformation.applyTransform(this, e, t);
+  }
+  getCombinedModelTransform(e, t) {
+    return this.getModelTransform(e, t), this.shaderTransformation != null && this.shaderTransformation.applyTransform(this, e, t), t;
+  }
+  getCombinedLocalTransform(e, t) {
+    this._view.localTransform.getMat(e, t), this.shaderTransformation != null && this.shaderTransformation.applyTransform(this, e, t);
+  }
+  getCombinedMaxScaleFactor(e) {
+    let t = this._view.modelScaleFactors.get(e, 1);
+    return this.shaderTransformation != null && (this.shaderTransformation.scaleFactor(i, this, e), t *= Math.max(i[0], i[1], i[2])), t;
+  }
+  getCombinedMedianScaleFactor(e) {
+    let t = this._view.modelScaleFactors.get(e, 0);
+    return this.shaderTransformation != null && (this.shaderTransformation.scaleFactor(i, this, e), t *= U(i[0], i[1], i[2])), t;
+  }
+  getModel(e, t) {
+    this._view.model.getMat(e, t);
+  }
+  setFeatureAttribute(e, t) {
+    this._view.featureAttribute.setVec(e, t);
+  }
+  getFeatureAttribute(e, t) {
+    this._view.featureAttribute.getVec(e, t);
+  }
+  setColor(e, t) {
+    this._view.color.setVec(e, t);
+  }
+  setObjectAndLayerIdColor(e, t) {
+    this._view.objectAndLayerIdColor.setVec(e, t);
+  }
+  setVisible(e, t) {
+    t !== this.getVisible(e) && (this._setStateFlag(e, r.VISIBLE, t), this.events.emit("instance-visibility-changed", { index: e }));
+  }
+  getVisible(e) {
+    return this._getStateFlag(e, r.VISIBLE);
+  }
+  setHighlight(e, t) {
+    t !== this.getHighlight(e) && (this._setStateFlag(e, r.HIGHLIGHT, t), this.events.emit("instance-highlight-changed"));
+  }
+  getHighlight(e) {
+    return this._getStateFlag(e, r.HIGHLIGHT);
+  }
+  getState(e) {
+    return this._view.state.get(e);
+  }
+  getLodLevel(e) {
+    return this._view.lodLevel.get(e);
+  }
+  countFlags(e) {
+    let t = 0;
+    for (let a = 0; a < this._capacity; ++a)
+      this.getState(a) & e && ++t;
+    return t;
+  }
+  _setStateFlags(e, t) {
+    const a = this._view.state;
+    t = a.get(e) | t, a.set(e, t);
+  }
+  _clearStateFlags(e, t) {
+    const a = this._view.state;
+    t = a.get(e) & ~t, a.set(e, t);
+  }
+  _setStateFlag(e, t, a) {
+    a ? this._setStateFlags(e, t) : this._clearStateFlags(e, t);
+  }
+  _getStateFlag(e, t) {
+    return !!(this._view.state.get(e) & t);
+  }
+  _grow() {
+    this._capacity = Math.max(A, Math.floor(this._capacity * I)), this._buffer = this._layout.createBuffer(this._capacity).copyFrom(this._buffer), this._view = new E(this._buffer);
+  }
+  _findSlot() {
+    const e = this._view.state;
+    let t = this._next;
+    for (; e.get(t) & r.ALLOCATED; )
+      t = t + 1 === this._capacity ? 0 : t + 1;
+    return this._next = t + 1 === this._capacity ? 0 : t + 1, t;
+  }
+};
+function U(e, t, a) {
+  return Math.max(Math.min(e, t), Math.min(Math.max(e, t), a));
+}
+c([f({ constructOnly: !0 })], h.prototype, "shaderTransformation", void 0), c([f()], h.prototype, "_size", void 0), c([f({ readOnly: !0 })], h.prototype, "size", null), h = c([v("esri.views.3d.webgl-engine.lib.lodRendering.InstanceData")], h);
+const i = b(), o = R(), p = O(), g = O();
+export {
+  h as InstanceData,
+  E as InstanceDataView,
+  r as StateFlags
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/InstanceOctree.js

@@ -0,0 +1,20 @@
+import { create as i } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { e as a } from "../../../../../chunks/vec32.js";
+import { w as r, c as n, g as h } from "../../../../../chunks/sphere.js";
+import { maxScale as m } from "../../../support/mathUtils.js";
+import p from "../Octree.js";
+class g extends p {
+  constructor(e, s) {
+    super((t) => r(this._instanceData.view.boundingSphere.getVec(t, this._tmpSphere)), { maximumDepth: 25 }), this._instanceData = e, this._boundingSphere = s, this._tmpSphere = n(), this._tmpMat4 = i();
+  }
+  addInstance(e) {
+    const s = this._instanceData.view.boundingSphere, t = this._instanceData.getCombinedModelTransform(e, this._tmpMat4);
+    a(h(this._tmpSphere), this._boundingSphere.center, t), this._tmpSphere[3] = this._boundingSphere.radius * m(t), s.setVec(e, this._tmpSphere), this.add([e]);
+  }
+  removeInstance(e) {
+    this.remove([e]);
+  }
+}
+export {
+  g as InstanceOctree
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/Intersector.js

@@ -0,0 +1,13 @@
+import "../IntersectorInterfaces.js";
+import { Graphic3DTarget as a } from "../IntersectorTarget.js";
+import "../../../../../chunks/vec32.js";
+import "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import "../../../../../chunks/boundedPlane.js";
+class c extends a {
+  constructor(r, t, i, s, e, o) {
+    super(r, t), this.layerUid = r, this.graphicUid = t, this.geometryId = i, this.triangleNr = s, this.baseBoundingSphere = e, this.numLodLevels = o;
+  }
+}
+export {
+  c as LodTarget
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/LevelSelector.js

@@ -0,0 +1,15 @@
+class n {
+  constructor(i, c) {
+    this._worldSpaceRadius = i, this._minScreenSpaceRadii = c;
+  }
+  selectLevel(i, c, r) {
+    const s = r.computeScreenPixelSizeAt(i), a = this._worldSpaceRadius * c / s;
+    let t = 0;
+    for (let e = 1; e < this._minScreenSpaceRadii.length; ++e)
+      a >= this._minScreenSpaceRadii[e] && (t = e);
+    return t;
+  }
+}
+export {
+  n as LevelSelector
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/LodComponentData.js

@@ -0,0 +1,43 @@
+import { glLayout as g } from "../../../support/buffer/glUtil.js";
+import { Default3D as L } from "../DefaultVertexAttributeLocations.js";
+import { GLMaterials as x } from "../GLMaterials.js";
+import { newIntersectorResult as O } from "../Intersector.js";
+import { IntersectorType as d, StoreResults as c } from "../IntersectorInterfaces.js";
+import { VertexArrayObject as b } from "../VertexArrayObject.js";
+import { LodTarget as v } from "./Intersector.js";
+import { BufferObject as D } from "../../../../webgl/BufferObject.js";
+import { Usage as C } from "../../../../webgl/enums.js";
+class G {
+  constructor(t, i) {
+    const n = t.renderContext.rctx, e = i.geometry;
+    this._materialRepository = t.materialRepository, e.material.setParameters({ instancedDoublePrecision: !0 });
+    const o = e.material.createBufferWriter(), s = o.vertexBufferLayout, m = o.elementCount(e), l = s.createBuffer(m);
+    o.write(null, null, e, l, 0), this.geometry = e, this.material = e.material, this.glMaterials = new x(e.material, this._materialRepository), this.vertexBufferLayout = s, this.vbo = D.createVertex(n, C.STATIC_DRAW, l.buffer), this.vao = new b(n, L, { geometry: g(s) }, { geometry: this.vbo }), this.vertexCount = m;
+  }
+  destroy() {
+    this.glMaterials.dispose(), this.vbo.dispose(), this.vao.dispose();
+  }
+  get boundingInfo() {
+    return this.geometry.boundingInfo;
+  }
+  get triangleCount() {
+    return this.vertexCount / 3;
+  }
+  intersect(t, i, n, e, o, s, m, l) {
+    const h = this.geometry.id;
+    this.material.intersect(this.geometry, t.transform.transform, t, n, e, (r, u, y, I, a) => {
+      if (r >= 0) {
+        if (i != null && !i(t.rayBegin, t.rayEnd, r))
+          return;
+        const f = new v(s.layerUid, s.graphicUid(o), h, y, m, l);
+        if ((t.results.min.drapedLayerOrder == null || a >= t.results.min.drapedLayerOrder) && (t.results.min.dist == null || r < t.results.min.dist) && t.results.min.set(d.LOD, f, r, u, t.transform.transform, a), t.options.store !== c.MIN && (t.results.max.drapedLayerOrder == null || a >= t.results.max.drapedLayerOrder) && (t.results.max.dist == null || r > t.results.max.dist) && t.results.max.set(d.LOD, f, r, u, t.transform.transform, a), t.options.store === c.ALL) {
+          const p = O(t.results.min.ray);
+          p.set(d.LOD, f, r, u, t.transform.transform, a), t.results.all.push(p);
+        }
+      }
+    });
+  }
+}
+export {
+  G as LodComponentData
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/LodLevel.js

@@ -0,0 +1,48 @@
+import { isSome as d } from "../../../../../core/arrayUtils.js";
+import { isAborted as h, throwIfAborted as l } from "../../../../../core/promiseUtils.js";
+import { create as m } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { empty as p, expandWithVec3 as i, center as f, diameter as g } from "../../../../../geometry/support/aaBoundingBox.js";
+import { LodComponentData as b } from "./LodComponentData.js";
+class a {
+  static async create(n, t, o) {
+    const s = await Promise.allSettled(t.components.map((e) => n.controller.schedule(() => new b(n, e), o))), r = s.map((e) => e.status === "fulfilled" ? e.value : null).filter(d);
+    if (h(o) || r.length !== s.length) {
+      r.forEach((e) => e.destroy()), l(o);
+      for (const e of s)
+        if (e.status === "rejected")
+          throw e.reason;
+    }
+    return new a(t.minScreenSpaceRadius, r);
+  }
+  constructor(n, t) {
+    this.minScreenSpaceRadius = n, this.components = t;
+  }
+  destroy() {
+    this.components.forEach((n) => n.destroy());
+  }
+  intersect(n, t, o, s, r, e, c) {
+    this.components.forEach((u) => u.intersect(n, t, o, s, r, e, this.boundingSphere, c));
+  }
+  get boundingBox() {
+    if (this._boundingBox == null) {
+      const n = p();
+      this.components.forEach((t) => {
+        t.boundingInfo != null && (i(n, t.boundingInfo.bbMin), i(n, t.boundingInfo.bbMax));
+      }), this._boundingBox = n;
+    }
+    return this._boundingBox;
+  }
+  get boundingSphere() {
+    if (this._boundingSphere == null) {
+      const n = this.boundingBox, t = m();
+      f(n, t), this._boundingSphere = { center: t, radius: 0.5 * g(n) };
+    }
+    return this._boundingSphere;
+  }
+  get triangleCount() {
+    return this.components.reduce((n, t) => n + t.triangleCount, 0);
+  }
+}
+export {
+  a as LodLevel
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/LodRenderer.js

@@ -0,0 +1,264 @@
+import { _ as g } from "../../../../../chunks/tslib.es6.js";
+import { isSome as U } from "../../../../../core/arrayUtils.js";
+import { destroyMaybe as G } from "../../../../../core/maybe.js";
+import { isAborted as q, throwIfAborted as $ } from "../../../../../core/promiseUtils.js";
+import { property as y } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/has.js";
+import "../../../../../core/Logger.js";
+import { subclass as z } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { create as k } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { f as b, k as L, e as S } from "../../../../../chunks/vec32.js";
+import { create as R } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { create as W, fromValues as A } from "../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { debugFlags as O } from "../../../support/debugFlags.js";
+import { glLayout as j } from "../../../support/buffer/glUtil.js";
+import { newLayout as K } from "../../../support/buffer/InterleavedLayout.js";
+import { ShaderOutput as C } from "../../core/shaderLibrary/ShaderOutput.js";
+import { ASyncPreparesRenderPlugin as Y } from "../../effects/RenderPlugin.js";
+import { Camera as J } from "../Camera.js";
+import { Default3D as N } from "../DefaultVertexAttributeLocations.js";
+import { IntersectorType as Q } from "../IntersectorInterfaces.js";
+import x from "../Octree.js";
+import { RenderSlot as T } from "../RenderSlot.js";
+import { assert as D } from "../Util.js";
+import { VertexAttribute as E } from "../VertexAttribute.js";
+import { InstanceData as Z, StateFlags as d } from "./InstanceData.js";
+import { InstanceOctree as X } from "./InstanceOctree.js";
+import { LevelSelector as ee } from "./LevelSelector.js";
+import { LodLevel as te } from "./LodLevel.js";
+import { RenderInstanceData as M } from "./RenderInstanceData.js";
+import { colorMixModes as ae } from "../../materials/internal/MaterialUtil.js";
+import { encodeDoubleVec3 as ne } from "../../materials/renderers/utils.js";
+import { DefaultMaterialDrawParameters as se } from "../../shaders/DefaultMaterialTechnique.js";
+import { TaskPriority as re, noBudget as ie } from "../../../../support/Scheduler.js";
+import { bindVertexBufferLayout as oe, unbindVertexBufferLayout as le } from "../../../../webgl/Util.js";
+const ce = (e) => {
+  const t = e.baseBoundingSphere.radius, a = e.levels.map((n) => n.minScreenSpaceRadius);
+  return new ee(t, a);
+};
+let f = class extends Y {
+  constructor(e, t) {
+    super(e), this.type = Q.LOD, this.isGround = !1, this._levels = [], this._defaultRenderInstanceData = [new Array()], this._highlightRenderInstanceData = [new Array()], this._allRenderInstanceData = [this._defaultRenderInstanceData[0], this._highlightRenderInstanceData[0]], this._instanceIndex = 0, this._cycleStartIndex = 0, this._slicePlane = !1, this._camera = new J(), this._updateCyclesWithStaticCamera = -1, this._needFullCycle = !1, this.produces = /* @__PURE__ */ new Map([[T.OPAQUE_MATERIAL, (a) => this._produces(a)], [T.TRANSPARENT_MATERIAL, (a) => !!this._hasTransparentLevels() && this._produces(a)]]), this._instanceData = new Z({ shaderTransformation: e.shaderTransformation }, e.optionalFields), this.addHandles(t.registerTask(re.LOD_RENDERER, this));
+  }
+  initialize() {
+    this._instanceBufferLayout = de(this.optionalFields), this._glInstanceBufferLayout = j(this._instanceBufferLayout, 1), this.addHandles([this._instanceData.events.on("instances-changed", () => this._requestUpdateCycle()), this._instanceData.events.on("instance-transform-changed", ({ index: e }) => {
+      this._requestUpdateCycle(), this.metadata.notifyGraphicGeometryChanged(e);
+    }), this._instanceData.events.on("instance-visibility-changed", ({ index: e }) => {
+      this._requestUpdateCycle(!0), this.metadata.notifyGraphicVisibilityChanged(e);
+    }), this._instanceData.events.on("instance-highlight-changed", () => this._requestUpdateCycle(!0))]);
+  }
+  get _enableLevelSelection() {
+    return this.symbol.levels.length > 1;
+  }
+  get levels() {
+    return this._levels;
+  }
+  get baseBoundingBox() {
+    return this._levels[this._levels.length - 1].boundingBox;
+  }
+  get baseBoundingSphere() {
+    return this._levels[this._levels.length - 1].boundingSphere;
+  }
+  get baseMaterial() {
+    return this._levels[this._levels.length - 1].components[0].material;
+  }
+  get slicePlaneEnabled() {
+    return this._slicePlane;
+  }
+  set slicePlaneEnabled(e) {
+    this._slicePlane = e;
+  }
+  get layerUid() {
+    return this.metadata.layerUid;
+  }
+  get instanceData() {
+    return this._instanceData;
+  }
+  get usedMemory() {
+    return this._allRenderInstanceData.reduce((e, t) => t.reduce((a, n) => a + n.usedMemory, e), 0);
+  }
+  get renderStats() {
+    const e = this._instanceData.size, t = [];
+    return this._levels.forEach((a, n) => {
+      const o = this._allRenderInstanceData[0][n].size + this._allRenderInstanceData[1][n].size, s = a.triangleCount;
+      t.push({ renderedInstances: o, renderedTriangles: o * s, trianglesPerInstance: s });
+    }), { totalInstances: e, renderedInstances: t.reduce((a, n) => a + n.renderedInstances, 0), renderedTriangles: t.reduce((a, n) => a + n.renderedTriangles, 0), levels: t };
+  }
+  async initializeRenderContext(e, t) {
+    this._context = e;
+    const a = e.renderContext.rctx, n = await Promise.allSettled(this.symbol.levels.map((s) => (this._defaultRenderInstanceData[0].push(new M(a, this._instanceBufferLayout)), this._highlightRenderInstanceData[0].push(new M(a, this._instanceBufferLayout)), te.create(e, s, t)))), o = n.map((s) => s.status === "fulfilled" ? s.value : null).filter(U);
+    if (q(t) || o.length !== n.length) {
+      o.forEach((s) => s.destroy()), $(t);
+      for (const s of n)
+        if (s.status === "rejected")
+          throw s.reason;
+    }
+    this._levels = o, this._levelSelector = ce(this);
+  }
+  uninitializeRenderContext() {
+    this._invalidateOctree(), this._levels.forEach((e) => e.destroy()), this._defaultRenderInstanceData[0].forEach((e) => e.destroy()), this._highlightRenderInstanceData[0].forEach((e) => e.destroy());
+  }
+  _hasTransparentLevels() {
+    return this._levels.some((e) => e.components.some((t) => {
+      const a = t.material.produces.get(T.TRANSPARENT_MATERIAL);
+      return a && a(C.Color);
+    }));
+  }
+  hasHighlights() {
+    return this._highlightRenderInstanceData[0].some((e) => e.size > 0);
+  }
+  _produces(e) {
+    return e !== C.Highlight && e !== C.ShadowHighlight || this.hasHighlights();
+  }
+  prepareRender(e) {
+    if (!O.LOD_INSTANCE_RENDERER_DISABLE_UPDATES) {
+      if (this._enableLevelSelection) {
+        const t = e.bindParameters.contentCamera.equals(this._camera);
+        this._camera.copyFrom(e.bindParameters.contentCamera), t || this._requestUpdateCycle();
+      }
+      this._needFullCycle && (this.runTask(ie), this._needFullCycle = !1);
+    }
+  }
+  prepareTechniques(e) {
+    if (!this.baseMaterial.isVisible() || !this.baseMaterial.isVisibleForOutput(e.output))
+      return null;
+    const t = this._getInstanceDatas(e.output);
+    if (!t)
+      return null;
+    const a = new Array();
+    return t.forEach((n) => this.levels.forEach((o, s) => {
+      o.components.forEach((l) => a.push(this._beginComponent(e, n[s], l)));
+    })), a;
+  }
+  renderNode(e, t) {
+    const a = this._getInstanceDatas(e.output);
+    if (!a || t == null)
+      return;
+    let n = 0;
+    e.rctx.bindVAO(), a.forEach((o) => this.levels.forEach((s, l) => {
+      s.components.forEach((m) => this._renderComponent(e, t[n++], o[l], m, l));
+    }));
+  }
+  _getInstanceDatas(e) {
+    const t = e !== C.Highlight && e !== C.ShadowHighlight, a = e !== C.ShadowExcludeHighlight;
+    return t && a ? this._allRenderInstanceData : t ? this._defaultRenderInstanceData : a ? this._highlightRenderInstanceData : null;
+  }
+  intersect(e, t, a, n) {
+    if (!this.baseMaterial.isVisible() || this._octree == null)
+      return;
+    const o = R();
+    b(o, n, a);
+    const s = (l) => {
+      this._instanceData.getCombinedModelTransform(l, F), e.transform.set(F), S(H, a, e.transform.inverse), S(B, n, e.transform.inverse);
+      const m = this._instanceData.getState(l), r = this._instanceData.getLodLevel(l), h = this._levels.length;
+      D((m & d.ACTIVE) != 0, "invalid instance state"), D(r >= 0 && r < h, "invaid lod level"), this._levels[r].intersect(e, t, H, B, l, this.metadata, h);
+    };
+    this.baseMaterial.parameters.verticalOffset ? this._octree.forEach(s) : this._octree.forEachAlongRay(a, o, s);
+  }
+  notifyShaderTransformationChanged() {
+    this._invalidateOctree(), this._requestUpdateCycle();
+  }
+  get _octree() {
+    var e;
+    if (this._octreeCached == null) {
+      const t = this._instanceData, a = (e = t.view) == null ? void 0 : e.state;
+      if (!a)
+        return null;
+      this._octreeCached = new X(t, this.baseBoundingSphere);
+      for (let n = 0; n < t.capacity; ++n)
+        a.get(n) & d.ACTIVE && this._octreeCached.addInstance(n);
+    }
+    return this._octreeCached;
+  }
+  _invalidateOctree() {
+    this._octreeCached = G(this._octreeCached);
+  }
+  queryDepthRange(e) {
+    if (this._octree == null)
+      return { near: 1 / 0, far: -1 / 0 };
+    const t = e.viewForward, a = this._octree.findClosest(t, x.DepthOrder.FRONT_TO_BACK, e.frustum), n = this._octree.findClosest(t, x.DepthOrder.BACK_TO_FRONT, e.frustum);
+    if (a == null || n == null)
+      return { near: 1 / 0, far: -1 / 0 };
+    const o = e.eye, s = this._instanceData.view;
+    s.boundingSphere.getVec(a, I), b(I, I, o);
+    const l = L(I, t) - I[3];
+    s.boundingSphere.getVec(n, I), b(I, I, o);
+    const m = L(I, t) + I[3];
+    return { near: Math.max(e.near, l), far: Math.min(e.far, m) };
+  }
+  _requestUpdateCycle(e = !1) {
+    this._updateCyclesWithStaticCamera = -1, this._cycleStartIndex = this._instanceIndex, e && (this._needFullCycle = !0, this._context.requestRender());
+  }
+  _startUpdateCycle() {
+    this._updateCyclesWithStaticCamera++, this._allRenderInstanceData.forEach((e) => e.forEach((t) => t.startUpdateCycle()));
+  }
+  get running() {
+    return this._instanceData.size > 0 && this._updateCyclesWithStaticCamera < 1;
+  }
+  runTask(e) {
+    const { _enableLevelSelection: t, _camera: a, _levelSelector: n } = this;
+    this._allRenderInstanceData.forEach((c) => c.forEach((i) => i.beginUpdate()));
+    const o = this._instanceData, s = o.view;
+    let l = o.size;
+    const m = o.capacity;
+    let r = this._instanceIndex;
+    const h = Math.ceil(m / 500);
+    for (let c = 0; c < l && !e.done; ++c) {
+      r === this._cycleStartIndex && this._startUpdateCycle();
+      const i = s.state.get(r);
+      let p = 0;
+      if (!(i & d.ALLOCATED)) {
+        r = r + 1 === m ? 0 : r + 1, l++;
+        continue;
+      }
+      const u = s.lodLevel.get(r);
+      if (i & d.DEFAULT_ACTIVE && this._defaultRenderInstanceData[0][u].freeTail(), i & d.HIGHLIGHT_ACTIVE && this._highlightRenderInstanceData[0][u].freeTail(), i & d.REMOVE)
+        o.freeInstance(r);
+      else if (i & d.VISIBLE) {
+        let _ = 0;
+        t && (s.modelOrigin.getVec(r, w), _ = n.selectLevel(w, o.getCombinedMedianScaleFactor(r), a)), p = i & ~(d.ACTIVE | d.TRANSFORM_CHANGED), _ >= 0 && (i & d.HIGHLIGHT ? (V(this._highlightRenderInstanceData[0][_], s, r), p |= d.HIGHLIGHT_ACTIVE) : (V(this._defaultRenderInstanceData[0][_], s, r), p |= d.DEFAULT_ACTIVE)), s.state.set(r, p), s.lodLevel.set(r, _);
+      } else
+        p = i & ~(d.ACTIVE | d.TRANSFORM_CHANGED), s.state.set(r, p);
+      if (this._octreeCached != null) {
+        const _ = !!(i & d.ACTIVE), v = !!(p & d.ACTIVE);
+        !_ && v ? this._octreeCached.addInstance(r) : _ && !v ? this._octreeCached.removeInstance(r) : _ && v && i & d.TRANSFORM_CHANGED && (this._octreeCached.removeInstance(r), this._octreeCached.addInstance(r));
+      }
+      r = r + 1 === m ? 0 : r + 1, r % h == 0 && e.madeProgress();
+    }
+    this._instanceIndex = r, this._allRenderInstanceData.forEach((c) => c.forEach((i) => i.endUpdate())), this._context.requestRender();
+  }
+  _beginComponent(e, t, a) {
+    if (t.size === 0)
+      return null;
+    const n = a.glMaterials.load(e.rctx, e.bindParameters.slot, e.output);
+    return n != null ? n.beginSlot(e.bindParameters) : null;
+  }
+  _renderComponent(e, t, a, n, o) {
+    if (!t)
+      return;
+    const { bindParameters: s, rctx: l } = e;
+    l.runAppleAmdDriverHelper();
+    const m = l.bindTechnique(t, s, n.material.parameters, ue);
+    l.bindVAO(n.vao), t.ensureAttributeLocations(n.vao), O.LOD_INSTANCE_RENDERER_COLORIZE_BY_LEVEL && e.output === C.Color && (m.setUniform4fv("externalColor", P[Math.min(o, P.length - 1)]), m.setUniform1i("colorMixMode", ae.replace));
+    const r = a.capacity, h = a.headIndex, c = a.tailIndex, i = a.firstIndex, p = this._glInstanceBufferLayout, u = (_, v) => {
+      oe(l, N, a.buffer, p, _), l.drawArraysInstanced(t.primitiveType, 0, n.vertexCount, v - _), le(l, N, a.buffer, p);
+    };
+    n.material.parameters.transparent && i != null ? h > c ? (D(i >= c && i <= h, "invalid firstIndex"), u(i, h), u(c, i)) : h < c && (i <= h ? (D(i >= 0 && i <= h, "invalid firstIndex"), u(i, h), u(c, r), u(0, i)) : (D(i >= c && i <= r, "invalid firstIndex"), u(i, r), u(0, h), u(c, i))) : h > c ? u(c, h) : h < c && (u(0, h), u(c, r)), l.bindVAO(null);
+  }
+};
+function V(e, t, a) {
+  const n = e.allocateHead();
+  he(t, a, e.view, n);
+}
+function he(e, t, a, n) {
+  ne(e.modelOrigin, t, a.modelOriginHi, a.modelOriginLo, n), a.model.copyFrom(n, e.model, t), a.modelNormal.copyFrom(n, e.modelNormal, t), e.color && a.color && a.color.copyFrom(n, e.color, t), e.objectAndLayerIdColor && a.objectAndLayerIdColor && a.objectAndLayerIdColor.copyFrom(n, e.objectAndLayerIdColor, t), e.featureAttribute && a.featureAttribute && a.featureAttribute.copyFrom(n, e.featureAttribute, t);
+}
+function de(e) {
+  let t = K().vec3f(E.INSTANCEMODELORIGINHI).vec3f(E.INSTANCEMODELORIGINLO).mat3f(E.INSTANCEMODEL).mat3f(E.INSTANCEMODELNORMAL);
+  return e != null && e.includes("featureAttribute") && (t = t.vec4f(E.INSTANCEFEATUREATTRIBUTE)), e != null && e.includes("color") && (t = t.vec4u8(E.INSTANCECOLOR)), e != null && e.includes("objectAndLayerIdColor") && (t = t.vec4u8(E.INSTANCEOBJECTANDLAYERIDCOLOR)), t;
+}
+g([y({ constructOnly: !0 })], f.prototype, "symbol", void 0), g([y({ constructOnly: !0 })], f.prototype, "optionalFields", void 0), g([y({ constructOnly: !0 })], f.prototype, "metadata", void 0), g([y({ constructOnly: !0 })], f.prototype, "shaderTransformation", void 0), g([y()], f.prototype, "_instanceData", void 0), g([y()], f.prototype, "_cycleStartIndex", void 0), g([y({ readOnly: !0 })], f.prototype, "_enableLevelSelection", null), g([y()], f.prototype, "_updateCyclesWithStaticCamera", void 0), g([y({ readOnly: !0 })], f.prototype, "running", null), f = g([z("esri.views.3d.webgl-engine.lib.lodRendering.LodRenderer")], f);
+const w = R(), I = W(), F = k(), H = R(), B = R(), P = [A(1, 0, 1, 1), A(0, 0, 1, 1), A(0, 1, 0, 1), A(1, 1, 0, 1), A(1, 0, 0, 1)], ue = new se();
+export {
+  f as LodRenderer
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/lib/lodRendering/LodResources.js

@@ -0,0 +1,44 @@
+import { unique as o } from "../../../../../core/arrayUtils.js";
+import { VertexAttribute as u } from "../VertexAttribute.js";
+class h {
+  constructor(e, s = null) {
+    this.geometry = e, this.textures = s;
+  }
+}
+class l {
+  constructor(e, s, t) {
+    this.components = e, this.minScreenSpaceRadius = s, this.pivotOffset = t;
+    const n = this.geometries;
+    this.numVertices = n.reduce((c, i) => c + i.attributes.get(u.POSITION).indices.length, 0);
+  }
+  get geometries() {
+    return o(this.components.map((e) => e.geometry));
+  }
+}
+class p {
+  constructor(e) {
+    this.levels = e, this.levels.sort((s, t) => s.minScreenSpaceRadius === t.minScreenSpaceRadius ? s.numVertices - t.numVertices : s.minScreenSpaceRadius - t.minScreenSpaceRadius);
+  }
+}
+function d(r) {
+  const e = [];
+  return r.levels.forEach((s) => s.components.forEach((t) => e.push(t.geometry.material))), o(e);
+}
+function f(r) {
+  const e = new Array();
+  return r.levels.forEach((s) => s.components.forEach((t) => {
+    t.textures != null && e.push(...t.textures);
+  })), o(e);
+}
+function R(r) {
+  const e = new Array();
+  return r.levels.forEach((s) => s.components.forEach((t) => e.push(t.geometry))), o(e);
+}
+export {
+  h as LodComponentResources,
+  l as LodLevelResources,
+  p as LodResources,
+  R as geometriesFromLodResources,
+  d as materialsFromLodResources,
+  f as texturesFromLodResources
+};