@agrotools1/at-components 0.2.1 → 0.2.3

package/dist/objectResourceUtils-642ab03e.js

@@ -0,0 +1,1455 @@
+import { a as ma } from "./devEnvironmentUtils-42cb97c7.js";
+import { jZ as pa, j_ as fa, fb as dt, cv as Ct, g6 as va, gf as ga, j$ as St, fs as xa, aS as Ot, fj as Te, e as d, y as ut, c as ba, o as ya, fG as Ta, Q as wa, I as Ma, b as Ca, fg as we, b9 as j, gn as qe, hk as ke, bg as xe, bm as Sa, bf as $t, bn as be, g7 as Et, bo as ht, bc as Oa, fh as $a, aO as Ea, k0 as _a, bI as _t, U as Aa, bO as At, W as Ra, k1 as Rt, hG as Me, s as Na, hs as mt, ge as za, ej as pt, jF as ft, gc as Pa } from "./index-01c737ed.js";
+import { t as Le, e as Nt, o as ee } from "./mat3f64-03233387.js";
+import { e as Ga } from "./mat4f64-cce69db4.js";
+import { e as Y, t as zt, c as f, a as Pt, E as La, b as Je, o as $, d as x, f as se, g as le, h as ce, l as de, s as z, P as Z, i as ja, j as Ze, n as Gt, k as R, m as Ba, p as Fa, q as Ia, r as k, u as Da, v as Lt, w as ue, x as te, y as He, z as _e, A as jt, B as Bt, C as Ae, D as Xe, F as Ke, O as Qe, G as Va, H as Ua, I as ye, J as Wa, K as qa, R as je, L, M as ka, N as Ya, Q as Ja, S as Za, T as Ft, U as It, V as Dt, W as Ce, X as Vt, Y as Ut, Z as Se, _ as Wt, $ as Ha, a0 as Xa, a1 as Ka, a2 as Qa, a3 as eo, a4 as to, a5 as h, a6 as ao, a7 as oo, a8 as Be, a9 as Fe, aa as ro, ab as io, ac as no, ad as so, ae as lo, af as qt, ag as kt, ah as fe } from "./VertexColor.glsl-e415cf02.js";
+import { c as co, x as Yt, L as uo, i as Jt, O as ho, E as mo } from "./BufferView-004ad517.js";
+import { r as po, n as fo, u as vt } from "./vec3-f79c600d.js";
+import { l as vo, n as go, i as X, o as xo, j as bo, k as yo, u as gt, t as To, m as wo } from "./DefaultMaterial_COLOR_GAMMA-337c63aa.js";
+import { r as Ie } from "./resourceUtils-43ce192b.js";
+import { t as Mo } from "./NestedMap-83f8e815.js";
+import { r as Zt } from "./Version-3de8cbca.js";
+import { l as Co } from "./Indices-e6dc3b15.js";
+import { t as So } from "./requestImageUtils-37d79281.js";
+import { t as K } from "./orientedBoundingBox-554ccdc6.js";
+import { s as M, n as he, e as J } from "./basicInterfaces-fa4f5fa7.js";
+import { e as C } from "./VertexAttribute-faad30bf.js";
+import { H as Oo } from "./InterleavedLayout-32973c8a.js";
+import { o as i, S as et, _ as tt, n as Ht, a as Q, c as $o, A as Eo, h as _o, l as Ao, b as Ro, d as No, e as zo } from "./OrderIndependentTransparency-3eadfe42.js";
+import { n as Po, r as Go } from "./vec4f64-043e974c.js";
+import { n as q } from "./symbolColorUtils-18fd6b3d.js";
+import { a as Re } from "./BindType-5e76c8e1.js";
+import "./RenderState-b244097f.js";
+import { D as Oe, G as Lo, t as jo, _ as Bo, O as xt } from "./enums-2c166c09.js";
+import { e as Fo, m as Io } from "./Texture-22a8cca5.js";
+import { s as V } from "./vec42-36edeb73.js";
+function at(e) {
+  e.uniforms.add(new Y("mainLightDirection", (t, a) => a.lighting.mainLight.direction));
+}
+function Ne(e) {
+  e.uniforms.add(new Y("mainLightIntensity", (t, a) => a.lighting.mainLight.intensity));
+}
+function bt(e) {
+  at(e.fragment), Ne(e.fragment), e.fragment.code.add(i`vec3 evaluateMainLighting(vec3 normal_global, float shadowing) {
+float dotVal = clamp(dot(normal_global, mainLightDirection), 0.0, 1.0);
+return mainLightIntensity * ((1.0 - shadowing) * dotVal);
+}`);
+}
+function Do(e) {
+  const t = e.fragment.code;
+  t.add(i`vec3 evaluateDiffuseIlluminationHemisphere(vec3 ambientGround, vec3 ambientSky, float NdotNG)
+{
+return ((1.0 - NdotNG) * ambientGround + (1.0 + NdotNG) * ambientSky) * 0.5;
+}`), t.add(i`float integratedRadiance(float cosTheta2, float roughness)
+{
+return (cosTheta2 - 1.0) / (cosTheta2 * (1.0 - roughness * roughness) - 1.0);
+}`), t.add(i`vec3 evaluateSpecularIlluminationHemisphere(vec3 ambientGround, vec3 ambientSky, float RdotNG, float roughness)
+{
+float cosTheta2 = 1.0 - RdotNG * RdotNG;
+float intRadTheta = integratedRadiance(cosTheta2, roughness);
+float ground = RdotNG < 0.0 ? 1.0 - intRadTheta : 1.0 + intRadTheta;
+float sky = 2.0 - ground;
+return (ground * ambientGround + sky * ambientSky) * 0.5;
+}`);
+}
+function ot(e, t) {
+  const a = e.fragment.code;
+  e.include(zt), t.pbrMode !== f.Normal && t.pbrMode !== f.Schematic && t.pbrMode !== f.Simplified && t.pbrMode !== f.TerrainWithWater || (a.add(i`float normalDistribution(float NdotH, float roughness)
+{
+float a = NdotH * roughness;
+float b = roughness / (1.0 - NdotH * NdotH + a * a);
+return b * b * INV_PI;
+}`), a.add(i`const vec4 c0 = vec4(-1.0, -0.0275, -0.572,  0.022);
+const vec4 c1 = vec4( 1.0,  0.0425,  1.040, -0.040);
+const vec2 c2 = vec2(-1.04, 1.04);
+vec2 prefilteredDFGAnalytical(float roughness, float NdotV) {
+vec4 r = roughness * c0 + c1;
+float a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;
+return c2 * a004 + r.zw;
+}`)), t.pbrMode !== f.Normal && t.pbrMode !== f.Schematic || (e.include(Do), a.add(i`struct PBRShadingInfo
+{
+float NdotL;
+float NdotV;
+float NdotH;
+float VdotH;
+float LdotH;
+float NdotNG;
+float RdotNG;
+float NdotAmbDir;
+float NdotH_Horizon;
+vec3 skyRadianceToSurface;
+vec3 groundRadianceToSurface;
+vec3 skyIrradianceToSurface;
+vec3 groundIrradianceToSurface;
+float averageAmbientRadiance;
+float ssao;
+vec3 albedoLinear;
+vec3 f0;
+vec3 f90;
+vec3 diffuseColor;
+float metalness;
+float roughness;
+};`), a.add(i`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
+vec3 indirectDiffuse = evaluateDiffuseIlluminationHemisphere(inputs.groundIrradianceToSurface, inputs.skyIrradianceToSurface, inputs.NdotNG);
+vec3 indirectSpecular = evaluateSpecularIlluminationHemisphere(inputs.groundRadianceToSurface, inputs.skyRadianceToSurface, inputs.RdotNG, inputs.roughness);
+vec3 diffuseComponent = inputs.diffuseColor * indirectDiffuse * INV_PI;
+vec2 dfg = prefilteredDFGAnalytical(inputs.roughness, inputs.NdotV);
+vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
+vec3 specularComponent = specularColor * indirectSpecular;
+return (diffuseComponent + specularComponent);
+}`), a.add(i`float gamutMapChanel(float x, vec2 p){
+return (x < p.x) ? mix(0.0, p.y, x/p.x) : mix(p.y, 1.0, (x - p.x) / (1.0 - p.x) );
+}`), a.add(i`vec3 blackLevelSoftCompression(vec3 inColor, PBRShadingInfo inputs){
+vec3 outColor;
+vec2 p = vec2(0.02 * (inputs.averageAmbientRadiance), 0.0075 * (inputs.averageAmbientRadiance));
+outColor.x = gamutMapChanel(inColor.x, p) ;
+outColor.y = gamutMapChanel(inColor.y, p) ;
+outColor.z = gamutMapChanel(inColor.z, p) ;
+return outColor;
+}`));
+}
+const Vo = 3e5, De = 5e5;
+function ie(e) {
+  if (e == null)
+    return null;
+  const t = e.offset != null ? e.offset : pa, a = e.rotation != null ? e.rotation : 0, o = e.scale != null ? e.scale : fa, n = Le(1, 0, 0, 0, 1, 0, t[0], t[1], 1), r = Le(Math.cos(a), -Math.sin(a), 0, Math.sin(a), Math.cos(a), 0, 0, 0, 1), c = Le(o[0], 0, 0, 0, o[1], 0, 0, 0, 1), l = Nt();
+  return dt(l, r, c), dt(l, n, l), l;
+}
+let Uo = class {
+  constructor() {
+    this.geometries = new Array(), this.materials = new Array(), this.textures = new Array();
+  }
+}, Wo = class {
+  constructor(t, a, o) {
+    this.name = t, this.lodThreshold = a, this.pivotOffset = o, this.stageResources = new Uo(), this.numberOfVertices = 0;
+  }
+};
+function qo(e, t) {
+  const a = e.fragment;
+  switch (a.code.add(i`struct ShadingNormalParameters {
+vec3 normalView;
+vec3 viewDirection;
+} shadingParams;`), t.doubleSidedMode) {
+    case N.None:
+      a.code.add(i`vec3 shadingNormal(ShadingNormalParameters params) {
+return normalize(params.normalView);
+}`);
+      break;
+    case N.View:
+      a.code.add(i`vec3 shadingNormal(ShadingNormalParameters params) {
+return dot(params.normalView, params.viewDirection) > 0.0 ? normalize(-params.normalView) : normalize(params.normalView);
+}`);
+      break;
+    case N.WindingOrder:
+      a.code.add(i`vec3 shadingNormal(ShadingNormalParameters params) {
+return gl_FrontFacing ? normalize(params.normalView) : normalize(-params.normalView);
+}`);
+      break;
+    default:
+      Ct(t.doubleSidedMode);
+    case N.COUNT:
+  }
+}
+var N;
+(function(e) {
+  e[e.None = 0] = "None", e[e.View = 1] = "View", e[e.WindingOrder = 2] = "WindingOrder", e[e.COUNT = 3] = "COUNT";
+})(N || (N = {}));
+function ko({ normalTexture: e, metallicRoughnessTexture: t, metallicFactor: a, roughnessFactor: o, emissiveTexture: n, emissiveFactor: r, occlusionTexture: c }) {
+  return e == null && t == null && n == null && (r == null || va(r, ga)) && c == null && (o == null || o === 1) && (a == null || a === 1);
+}
+const Xt = [1, 1, 0.5], Yo = [0, 0.6, 0.2], Jo = [0, 1, 0.2];
+function Kt(e) {
+  e.vertex.code.add(i`vec4 offsetBackfacingClipPosition(vec4 posClip, vec3 posWorld, vec3 normalWorld, vec3 camPosWorld) {
+vec3 camToVert = posWorld - camPosWorld;
+bool isBackface = dot(camToVert, normalWorld) > 0.0;
+if (isBackface) {
+posClip.z += 0.0000003 * posClip.w;
+}
+return posClip;
+}`);
+}
+function Zo(e) {
+  e.vertex.code.add(i`
+    vec4 decodeSymbolColor(vec4 symbolColor, out int colorMixMode) {
+      float symbolAlpha = 0.0;
+
+      const float maxTint = 85.0;
+      const float maxReplace = 170.0;
+      const float scaleAlpha = 3.0;
+
+      if (symbolColor.a > maxReplace) {
+        colorMixMode = ${i.int(q.Multiply)};
+        symbolAlpha = scaleAlpha * (symbolColor.a - maxReplace);
+      } else if (symbolColor.a > maxTint) {
+        colorMixMode = ${i.int(q.Replace)};
+        symbolAlpha = scaleAlpha * (symbolColor.a - maxTint);
+      } else if (symbolColor.a > 0.0) {
+        colorMixMode = ${i.int(q.Tint)};
+        symbolAlpha = scaleAlpha * symbolColor.a;
+      } else {
+        colorMixMode = ${i.int(q.Multiply)};
+        symbolAlpha = 0.0;
+      }
+
+      return vec4(symbolColor.r, symbolColor.g, symbolColor.b, symbolAlpha);
+    }
+  `);
+}
+function Qt(e, t) {
+  t.hasSymbolColors ? (e.include(Zo), e.attributes.add(C.SYMBOLCOLOR, "vec4"), e.varyings.add("colorMixMode", "mediump float"), e.vertex.code.add(i`int symbolColorMixMode;
+vec4 getSymbolColor() {
+return decodeSymbolColor(symbolColor, symbolColorMixMode) * 0.003921568627451;
+}
+void forwardColorMixMode() {
+colorMixMode = float(symbolColorMixMode) + 0.5;
+}`)) : (e.fragment.uniforms.add(new Pt("colorMixMode", (a) => La[a.colorMixMode])), e.vertex.code.add(i`vec4 getSymbolColor() { return vec4(1.0); }
+void forwardColorMixMode() {}`));
+}
+function Ho(e) {
+  e.fragment.code.add(i`
+    #define discardOrAdjustAlpha(color) { if (color.a < ${i.float(Je)}) { discard; } }
+  `);
+}
+function H(e, t) {
+  Xo(e, t, new $("textureAlphaCutoff", (a) => a.textureAlphaCutoff));
+}
+function Xo(e, t, a) {
+  const o = e.fragment;
+  switch (t.alphaDiscardMode !== M.Mask && t.alphaDiscardMode !== M.MaskBlend || o.uniforms.add(a), t.alphaDiscardMode) {
+    case M.Blend:
+      return e.include(Ho);
+    case M.Opaque:
+      o.code.add(i`void discardOrAdjustAlpha(inout vec4 color) {
+color.a = 1.0;
+}`);
+      break;
+    case M.Mask:
+      o.code.add(i`#define discardOrAdjustAlpha(color) { if (color.a < textureAlphaCutoff) { discard; } else { color.a = 1.0; } }`);
+      break;
+    case M.MaskBlend:
+      e.fragment.code.add(i`#define discardOrAdjustAlpha(color) { if (color.a < textureAlphaCutoff) { discard; } }`);
+  }
+}
+function ea(e, t) {
+  const { vertex: a, fragment: o } = e, n = t.hasColorTexture && t.alphaDiscardMode !== M.Opaque;
+  switch (t.output) {
+    case x.LinearDepth:
+    case x.Shadow:
+    case x.ShadowHighlight:
+    case x.ShadowExcludeHighlight:
+    case x.ObjectAndLayerIdColor:
+      se(a, t), e.include(le, t), e.include(ce, t), e.include(de, t), e.include(Ba, t), e.include(Z, t), e.include(Fa, t), Ia(e), e.varyings.add("depth", "float"), n && o.uniforms.add(new z("tex", (r) => r.texture)), a.code.add(i`void main(void) {
+vpos = getVertexInLocalOriginSpace();
+vpos = subtractOrigin(vpos);
+vpos = addVerticalOffset(vpos, localOrigin);
+gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);
+forwardTextureCoordinates();
+forwardObjectAndLayerIdColor();
+}`), e.include(H, t), o.code.add(i`
+          void main(void) {
+            discardBySlice(vpos);
+            ${n ? i`
+                    vec4 texColor = texture(tex, ${t.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                    discardOrAdjustAlpha(texColor);` : ""}
+            ${t.output === x.ObjectAndLayerIdColor ? i`outputObjectAndLayerIdColor();` : i`outputDepth(depth);`}
+          }
+        `);
+      break;
+    case x.Normal: {
+      se(a, t), e.include(le, t), e.include(Ze, t), e.include(Gt, t), e.include(ce, t), e.include(de, t), n && o.uniforms.add(new z("tex", (c) => c.texture)), t.normalType === R.ScreenDerivative && e.varyings.add("vPositionView", "vec3");
+      const r = t.normalType === R.Attribute || t.normalType === R.Compressed;
+      a.code.add(i`
+          void main(void) {
+            vpos = getVertexInLocalOriginSpace();
+
+            ${r ? i`vNormalWorld = dpNormalView(vvLocalNormal(normalModel()));` : i`
+                  // Get vertex position in camera space for screen-space derivative normals
+                  vPositionView = (view * vec4(vpos, 1.0)).xyz;
+                `}
+            vpos = subtractOrigin(vpos);
+            vpos = addVerticalOffset(vpos, localOrigin);
+            gl_Position = transformPosition(proj, view, vpos);
+            forwardTextureCoordinates();
+          }
+        `), e.include(Z, t), e.include(H, t), o.code.add(i`
+          void main() {
+            discardBySlice(vpos);
+            ${n ? i`
+                    vec4 texColor = texture(tex, ${t.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                    discardOrAdjustAlpha(texColor);` : ""}
+
+            ${t.normalType === R.ScreenDerivative ? i`vec3 normal = screenDerivativeNormal(vPositionView);` : i`
+                  vec3 normal = normalize(vNormalWorld);
+                  if (gl_FrontFacing == false){
+                    normal = -normal;
+                  }`}
+            fragColor = vec4(0.5 + 0.5 * normal, 1.0);
+          }
+        `);
+      break;
+    }
+    case x.Highlight:
+      se(a, t), e.include(le, t), e.include(ce, t), e.include(de, t), n && o.uniforms.add(new z("tex", (r) => r.texture)), a.code.add(i`void main(void) {
+vpos = getVertexInLocalOriginSpace();
+vpos = subtractOrigin(vpos);
+vpos = addVerticalOffset(vpos, localOrigin);
+gl_Position = transformPosition(proj, view, vpos);
+forwardTextureCoordinates();
+}`), e.include(Z, t), e.include(H, t), e.include(ja, t), o.code.add(i`
+          void main() {
+            discardBySlice(vpos);
+            ${n ? i`
+                    vec4 texColor = texture(tex, ${t.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                    discardOrAdjustAlpha(texColor);` : ""}
+            outputHighlight();
+          }
+        `);
+  }
+}
+function Ko(e, t) {
+  const a = e.fragment;
+  t.hasVertexTangents ? (e.attributes.add(C.TANGENT, "vec4"), e.varyings.add("vTangent", "vec4"), t.doubleSidedMode === N.WindingOrder ? a.code.add(i`mat3 computeTangentSpace(vec3 normal) {
+float tangentHeadedness = gl_FrontFacing ? vTangent.w : -vTangent.w;
+vec3 tangent = normalize(gl_FrontFacing ? vTangent.xyz : -vTangent.xyz);
+vec3 bitangent = cross(normal, tangent) * tangentHeadedness;
+return mat3(tangent, bitangent, normal);
+}`) : a.code.add(i`mat3 computeTangentSpace(vec3 normal) {
+float tangentHeadedness = vTangent.w;
+vec3 tangent = normalize(vTangent.xyz);
+vec3 bitangent = cross(normal, tangent) * tangentHeadedness;
+return mat3(tangent, bitangent, normal);
+}`)) : a.code.add(i`mat3 computeTangentSpace(vec3 normal, vec3 pos, vec2 st) {
+vec3 Q1 = dFdx(pos);
+vec3 Q2 = dFdy(pos);
+vec2 stx = dFdx(st);
+vec2 sty = dFdy(st);
+float det = stx.t * sty.s - sty.t * stx.s;
+vec3 T = stx.t * Q2 - sty.t * Q1;
+T = T - normal * dot(normal, T);
+T *= inversesqrt(max(dot(T,T), 1.e-10));
+vec3 B = sign(det) * cross(normal, T);
+return mat3(T, B, normal);
+}`), t.textureCoordinateType !== k.None && (e.include(Da, t), a.uniforms.add(t.pbrTextureBindType === Re.Pass ? new z("normalTexture", (o) => o.textureNormal) : new Lt("normalTexture", (o) => o.textureNormal)), t.hasNormalTextureTransform && (a.uniforms.add(new ue("scale", (o) => o.scale ?? St)), a.uniforms.add(new te("normalTextureTransformMatrix", (o) => o.normalTextureTransformMatrix ?? ee))), a.code.add(i`vec3 computeTextureNormal(mat3 tangentSpace, vec2 uv) {
+vec3 rawNormal = textureLookup(normalTexture, uv).rgb * 2.0 - 1.0;`), t.hasNormalTextureTransform && a.code.add(i`mat3 normalTextureRotation = mat3(normalTextureTransformMatrix[0][0]/scale[0], normalTextureTransformMatrix[0][1]/scale[1], 0.0,
+normalTextureTransformMatrix[1][0]/scale[0], normalTextureTransformMatrix[1][1]/scale[1], 0.0,
+0.0, 0.0, 0.0 );
+rawNormal.xy = (normalTextureRotation * vec3(rawNormal.x, rawNormal.y, 1.0)).xy;`), a.code.add(i`return tangentSpace * rawNormal;
+}`));
+}
+let Qo = class extends He {
+  constructor(t, a) {
+    super(t, "vec2", Re.Draw, (o, n, r, c) => o.setUniform2fv(t, a(n, r, c)));
+  }
+};
+const Ve = 4;
+function er() {
+  const e = new _e(), t = e.fragment;
+  e.include(jt);
+  const a = (Ve + 1) / 2, o = 1 / (2 * a * a);
+  return t.include(Bt), t.uniforms.add(new z("depthMap", (n) => n.depthTexture), new Lt("tex", (n) => n.colorTexture), new Qo("blurSize", (n) => n.blurSize), new $("projScale", (n, r) => {
+    const c = xa(r.camera.eye, r.camera.center);
+    return c > 5e4 ? Math.max(0, n.projScale - (c - 5e4)) : n.projScale;
+  }), new ue("nearFar", (n, r) => r.camera.nearFar)), t.code.add(i`
+    void blurFunction(vec2 uv, float r, float center_d, float sharpness, inout float wTotal, inout float bTotal) {
+      float c = texture(tex, uv).r;
+      float d = linearDepthFromTexture(depthMap, uv, nearFar);
+
+      float ddiff = d - center_d;
+
+      float w = exp(-r * r * ${i.float(o)} - ddiff * ddiff * sharpness);
+      wTotal += w;
+      bTotal += w * c;
+    }
+  `), e.outputs.add("fragBlur", "float"), t.code.add(i`
+    void main(void) {
+      float b = 0.0;
+      float w_total = 0.0;
+
+      float center_d = linearDepthFromTexture(depthMap, uv, nearFar);
+
+      float sharpness = -0.05 * projScale / center_d;
+      for (int r = -${i.int(Ve)}; r <= ${i.int(Ve)}; ++r) {
+        float rf = float(r);
+        vec2 uvOffset = uv + rf * blurSize;
+        blurFunction(uvOffset, rf, center_d, sharpness, w_total, b);
+      }
+
+      fragBlur = b / w_total;
+    }
+  `), e;
+}
+const tr = Object.freeze(Object.defineProperty({ __proto__: null, build: er }, Symbol.toStringTag, { value: "Module" }));
+let ta = class aa extends Xe {
+  initializeProgram(t) {
+    return new Ke(t.rctx, aa.shader.get().build(), Qe);
+  }
+  initializePipeline() {
+    return et({ colorWrite: tt });
+  }
+};
+ta.shader = new Ae(tr, () => import("./SSAOBlur.glsl-f3068b8e.js"));
+const ar = "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";
+let or = class extends Ht {
+  constructor() {
+    super(...arguments), this.projScale = 1;
+  }
+}, rr = class extends or {
+  constructor() {
+    super(...arguments), this.intensity = 1;
+  }
+}, ir = class extends Ht {
+}, nr = class extends ir {
+  constructor() {
+    super(...arguments), this.blurSize = Ot();
+  }
+};
+const yt = 16;
+function sr() {
+  const e = new _e(), t = e.fragment;
+  return e.include(jt), e.include(Va), t.include(Bt), t.uniforms.add(new $("radius", (a, o) => rt(o.camera))), t.code.add(i`vec3 sphere[16] = vec3[16](
+vec3(0.186937, 0.0, 0.0),
+vec3(0.700542, 0.0, 0.0),
+vec3(-0.864858, -0.481795, -0.111713),
+vec3(-0.624773, 0.102853, -0.730153),
+vec3(-0.387172, 0.260319, 0.007229),
+vec3(-0.222367, -0.642631, -0.707697),
+vec3(-0.01336, -0.014956, 0.169662),
+vec3(0.122575, 0.1544, -0.456944),
+vec3(-0.177141, 0.85997, -0.42346),
+vec3(-0.131631, 0.814545, 0.524355),
+vec3(-0.779469, 0.007991, 0.624833),
+vec3(0.308092, 0.209288,0.35969),
+vec3(0.359331, -0.184533, -0.377458),
+vec3(0.192633, -0.482999, -0.065284),
+vec3(0.233538, 0.293706, -0.055139),
+vec3(0.417709, -0.386701, 0.442449)
+);
+float fallOffFunction(float vv, float vn, float bias) {
+float f = max(radius * radius - vv, 0.0);
+return f * f * f * max(vn - bias, 0.0);
+}`), t.code.add(i`float aoValueFromPositionsAndNormal(vec3 C, vec3 n_C, vec3 Q) {
+vec3 v = Q - C;
+float vv = dot(v, v);
+float vn = dot(normalize(v), n_C);
+return fallOffFunction(vv, vn, 0.1);
+}`), t.uniforms.add(new ue("nearFar", (a, o) => o.camera.nearFar), new z("normalMap", (a) => a.normalTexture), new z("depthMap", (a) => a.depthTexture), new $("projScale", (a) => a.projScale), new z("rnm", (a) => a.noiseTexture), new ue("rnmScale", (a, o) => Te(Tt, o.camera.fullWidth / a.noiseTexture.descriptor.width, o.camera.fullHeight / a.noiseTexture.descriptor.height)), new $("intensity", (a) => a.intensity), new ue("screenSize", (a, o) => Te(Tt, o.camera.fullWidth, o.camera.fullHeight))), e.outputs.add("fragOcclusion", "float"), t.code.add(i`
+    void main(void) {
+      float currentPixelDepth = linearDepthFromTexture(depthMap, uv, nearFar);
+
+      if (-currentPixelDepth > nearFar.y || -currentPixelDepth < nearFar.x) {
+        fragOcclusion = 1.0;
+        return;
+      }
+
+      // get the normal of current fragment
+      vec4 norm4 = texture(normalMap, uv);
+      if(norm4.a != 1.0) {
+        fragOcclusion = 1.0;
+        return;
+      }
+      vec3 norm = vec3(-1.0) + 2.0 * norm4.xyz;
+
+      vec3 currentPixelPos = reconstructPosition(gl_FragCoord.xy, currentPixelDepth);
+
+      float sum = 0.0;
+      vec3 tapPixelPos;
+
+      vec3 fres = normalize(2.0 * texture(rnm, uv * rnmScale).xyz - 1.0);
+
+      // note: the factor 2.0 should not be necessary, but makes ssao much nicer.
+      // bug or deviation from CE somewhere else?
+      float ps = projScale / (2.0 * currentPixelPos.z * zScale.x + zScale.y);
+
+      for(int i = 0; i < ${i.int(yt)}; ++i) {
+        vec2 unitOffset = reflect(sphere[i], fres).xy;
+        vec2 offset = vec2(-unitOffset * radius * ps);
+
+        // don't use current or very nearby samples
+        if( abs(offset.x) < 2.0 || abs(offset.y) < 2.0){
+          continue;
+        }
+
+        vec2 tc = vec2(gl_FragCoord.xy + offset);
+        if (tc.x < 0.0 || tc.y < 0.0 || tc.x > screenSize.x || tc.y > screenSize.y) continue;
+        vec2 tcTap = tc / screenSize;
+        float occluderFragmentDepth = linearDepthFromTexture(depthMap, tcTap, nearFar);
+
+        tapPixelPos = reconstructPosition(tc, occluderFragmentDepth);
+
+        sum += aoValueFromPositionsAndNormal(currentPixelPos, norm, tapPixelPos);
+      }
+
+      // output the result
+      float A = max(1.0 - sum * intensity / float(${i.int(yt)}), 0.0);
+
+      // Anti-tone map to reduce contrast and drag dark region farther: (x^0.2 + 1.2 * x^4) / 2.2
+      A = (pow(A, 0.2) + 1.2 * A*A*A*A) / 2.2;
+
+      fragOcclusion = A;
+    }
+  `), e;
+}
+function rt(e) {
+  return Math.max(10, 20 * e.computeScreenPixelSizeAtDist(Math.abs(4 * e.relativeElevation)));
+}
+const Tt = Ot(), lr = Object.freeze(Object.defineProperty({ __proto__: null, build: sr, getRadius: rt }, Symbol.toStringTag, { value: "Module" }));
+class ze extends Xe {
+  initializeProgram(t) {
+    return new Ke(t.rctx, ze.shader.get().build(), Qe);
+  }
+  initializePipeline() {
+    return et({ colorWrite: tt });
+  }
+}
+ze.shader = new Ae(lr, () => import("./SSAO.glsl-5491a708.js"));
+var Ye;
+(function(e) {
+  e[e.Antialiasing = 0] = "Antialiasing", e[e.HighQualityTransparency = 1] = "HighQualityTransparency", e[e.HighResolutionVoxel = 2] = "HighResolutionVoxel", e[e.HighResolutionAtmosphere = 3] = "HighResolutionAtmosphere", e[e.SSAO = 4] = "SSAO", e[e.WaterReflection = 5] = "WaterReflection", e[e.HighResolutionShadows = 6] = "HighResolutionShadows", e[e.PhysicalPixelRendering = 7] = "PhysicalPixelRendering";
+})(Ye || (Ye = {}));
+const ne = 2;
+let ve = class extends Ua {
+  constructor(e) {
+    super(e), this._context = null, this._passParameters = new rr(), this._drawParameters = new nr(), this.produces = /* @__PURE__ */ new Map([[ye.SSAO, () => this._produces()]]);
+  }
+  _getCameraElevation() {
+    var e;
+    return ((e = this._context) == null ? void 0 : e.renderContext.bindParameters.camera.relativeElevation) ?? 1 / 0;
+  }
+  _produces() {
+    return this._enableTime != null && this._context != null && this._getCameraElevation() < De;
+  }
+  consumes() {
+    return this._produces() ? Wa : qa;
+  }
+  initializeRenderContext(e) {
+    this._context = e, this.addHandles([ya(() => {
+      var t;
+      return this.view.qualitySettings.ambientOcclusion || ((t = this._context) == null ? void 0 : t.isFeatureEnabled(Ye.SSAO));
+    }, (t) => t ? this._enable() : this._disable(), Ta)]);
+  }
+  uninitializeRenderContext() {
+    this._disable(), this._context = null;
+  }
+  _disable() {
+    this._passParameters.noiseTexture = wa(this._passParameters.noiseTexture), this._enableTime = null;
+  }
+  destroy() {
+    this._disable();
+  }
+  _enable() {
+    var a;
+    if (this._enableTime != null || !this._context)
+      return;
+    const e = Uint8Array.from(atob(ar), (o) => o.charCodeAt(0)), t = new Fo();
+    t.wrapMode = Oe.CLAMP_TO_EDGE, t.pixelFormat = Lo.RGB, t.wrapMode = Oe.REPEAT, t.hasMipmap = !0, t.width = 32, t.height = 32, this._passParameters.noiseTexture = new Io(this._context.renderContext.rctx, t, e), this._ssaoTechnique == null && (this._ssaoTechnique = this._context.techniqueRepository.acquire(ze)), this._blurTechnique == null && (this._blurTechnique = this._context.techniqueRepository.acquire(ta)), this._enableTime = Ma(0), (a = this._context) == null || a.requestRender();
+  }
+  renderNode(e, t, a) {
+    const o = e.bindParameters, n = a == null ? void 0 : a.get("normals"), r = n == null ? void 0 : n.getTexture(), c = n == null ? void 0 : n.getTexture(jo);
+    if (this._enableTime == null || this._context == null || !r || !c)
+      return;
+    if (!this._ssaoTechnique.compiled || !this._blurTechnique.compiled)
+      return this._enableTime = e.time, void this._context.requestRender();
+    this._enableTime === 0 && (this._enableTime = e.time);
+    const l = e.rctx, s = o.camera, p = this.view.qualitySettings.fadeDuration, m = s.relativeElevation, v = Ca((De - m) / (De - Vo), 0, 1), b = p > 0 ? Math.min(p, e.time - this._enableTime) / p : 1, y = b * v;
+    this._passParameters.normalTexture = r, this._passParameters.depthTexture = c, this._passParameters.projScale = 1 / s.computeScreenPixelSizeAtDist(1), this._passParameters.intensity = 4 * cr / rt(s) ** 6 * y;
+    const w = s.fullViewport[2], g = s.fullViewport[3], T = Math.round(w / ne), S = Math.round(g / ne), E = this._context.fbos, _ = E.acquire(w, g, "ssao input", je.RG);
+    l.unbindTexture(_.fbo.colorTexture), l.bindFramebuffer(_.fbo), l.setViewport(0, 0, w, g), l.bindTechnique(this._ssaoTechnique, o, this._passParameters, this._drawParameters), l.screen.draw();
+    const B = E.acquire(T, S, "ssao blur", je.RED);
+    l.unbindTexture(B.fbo.colorTexture), l.bindFramebuffer(B.fbo), this._drawParameters.colorTexture = _.getTexture(), Te(this._drawParameters.blurSize, 0, ne / g), l.bindTechnique(this._blurTechnique, o, this._passParameters, this._drawParameters), l.setViewport(0, 0, T, S), l.screen.draw(), _.release();
+    const F = E.acquire(T, S, "ssao", je.RED);
+    return l.unbindTexture(F.fbo.colorTexture), l.bindFramebuffer(F.fbo), l.setViewport(0, 0, w, g), l.setClearColor(1, 1, 1, 0), l.clear(Bo.COLOR_BUFFER_BIT), this._drawParameters.colorTexture = B.getTexture(), Te(this._drawParameters.blurSize, ne / w, 0), l.bindTechnique(this._blurTechnique, o, this._passParameters, this._drawParameters), l.setViewport(0, 0, T, S), l.screen.draw(), l.setViewport4fv(s.fullViewport), B.release(), b < 1 && this._context.requestRender(), F;
+  }
+};
+d([ut({ constructOnly: !0 })], ve.prototype, "view", void 0), d([ut()], ve.prototype, "_context", void 0), ve = d([ba("esri.views.3d.webgl-engine.effects.ssao.SSAO")], ve);
+const cr = 0.5;
+function it(e, t) {
+  const a = e.fragment;
+  t.receiveAmbientOcclusion ? (a.uniforms.add(new z("ssaoTex", (o, n) => {
+    var r;
+    return (r = n.ssao) == null ? void 0 : r.getTexture();
+  })), a.constants.add("blurSizePixelsInverse", "float", 1 / ne), a.code.add(i`float evaluateAmbientOcclusionInverse() {
+vec2 ssaoTextureSizeInverse = 1.0 / vec2(textureSize(ssaoTex, 0));
+return texture(ssaoTex, gl_FragCoord.xy * blurSizePixelsInverse * ssaoTextureSizeInverse).r;
+}
+float evaluateAmbientOcclusion() {
+return 1.0 - evaluateAmbientOcclusionInverse();
+}`)) : a.code.add(i`float evaluateAmbientOcclusionInverse() { return 1.0; }
+float evaluateAmbientOcclusion() { return 0.0; }`);
+}
+function dr(e, t) {
+  const a = e.fragment, o = t.lightingSphericalHarmonicsOrder !== void 0 ? t.lightingSphericalHarmonicsOrder : 2;
+  o === 0 ? (a.uniforms.add(new Y("lightingAmbientSH0", (n, r) => we(wt, r.lighting.sh.r[0], r.lighting.sh.g[0], r.lighting.sh.b[0]))), a.code.add(i`vec3 calculateAmbientIrradiance(vec3 normal, float ambientOcclusion) {
+vec3 ambientLight = 0.282095 * lightingAmbientSH0;
+return ambientLight * (1.0 - ambientOcclusion);
+}`)) : o === 1 ? (a.uniforms.add(new L("lightingAmbientSH_R", (n, r) => V(U, r.lighting.sh.r[0], r.lighting.sh.r[1], r.lighting.sh.r[2], r.lighting.sh.r[3])), new L("lightingAmbientSH_G", (n, r) => V(U, r.lighting.sh.g[0], r.lighting.sh.g[1], r.lighting.sh.g[2], r.lighting.sh.g[3])), new L("lightingAmbientSH_B", (n, r) => V(U, r.lighting.sh.b[0], r.lighting.sh.b[1], r.lighting.sh.b[2], r.lighting.sh.b[3]))), a.code.add(i`vec3 calculateAmbientIrradiance(vec3 normal, float ambientOcclusion) {
+vec4 sh0 = vec4(
+0.282095,
+0.488603 * normal.x,
+0.488603 * normal.z,
+0.488603 * normal.y
+);
+vec3 ambientLight = vec3(
+dot(lightingAmbientSH_R, sh0),
+dot(lightingAmbientSH_G, sh0),
+dot(lightingAmbientSH_B, sh0)
+);
+return ambientLight * (1.0 - ambientOcclusion);
+}`)) : o === 2 && (a.uniforms.add(new Y("lightingAmbientSH0", (n, r) => we(wt, r.lighting.sh.r[0], r.lighting.sh.g[0], r.lighting.sh.b[0])), new L("lightingAmbientSH_R1", (n, r) => V(U, r.lighting.sh.r[1], r.lighting.sh.r[2], r.lighting.sh.r[3], r.lighting.sh.r[4])), new L("lightingAmbientSH_G1", (n, r) => V(U, r.lighting.sh.g[1], r.lighting.sh.g[2], r.lighting.sh.g[3], r.lighting.sh.g[4])), new L("lightingAmbientSH_B1", (n, r) => V(U, r.lighting.sh.b[1], r.lighting.sh.b[2], r.lighting.sh.b[3], r.lighting.sh.b[4])), new L("lightingAmbientSH_R2", (n, r) => V(U, r.lighting.sh.r[5], r.lighting.sh.r[6], r.lighting.sh.r[7], r.lighting.sh.r[8])), new L("lightingAmbientSH_G2", (n, r) => V(U, r.lighting.sh.g[5], r.lighting.sh.g[6], r.lighting.sh.g[7], r.lighting.sh.g[8])), new L("lightingAmbientSH_B2", (n, r) => V(U, r.lighting.sh.b[5], r.lighting.sh.b[6], r.lighting.sh.b[7], r.lighting.sh.b[8]))), a.code.add(i`vec3 calculateAmbientIrradiance(vec3 normal, float ambientOcclusion) {
+vec3 ambientLight = 0.282095 * lightingAmbientSH0;
+vec4 sh1 = vec4(
+0.488603 * normal.x,
+0.488603 * normal.z,
+0.488603 * normal.y,
+1.092548 * normal.x * normal.y
+);
+vec4 sh2 = vec4(
+1.092548 * normal.y * normal.z,
+0.315392 * (3.0 * normal.z * normal.z - 1.0),
+1.092548 * normal.x * normal.z,
+0.546274 * (normal.x * normal.x - normal.y * normal.y)
+);
+ambientLight += vec3(
+dot(lightingAmbientSH_R1, sh1),
+dot(lightingAmbientSH_G1, sh1),
+dot(lightingAmbientSH_B1, sh1)
+);
+ambientLight += vec3(
+dot(lightingAmbientSH_R2, sh2),
+dot(lightingAmbientSH_G2, sh2),
+dot(lightingAmbientSH_B2, sh2)
+);
+return ambientLight * (1.0 - ambientOcclusion);
+}`), t.pbrMode !== f.Normal && t.pbrMode !== f.Schematic || a.code.add(i`const vec3 skyTransmittance = vec3(0.9, 0.9, 1.0);
+vec3 calculateAmbientRadiance(float ambientOcclusion)
+{
+vec3 ambientLight = 1.2 * (0.282095 * lightingAmbientSH0) - 0.2;
+return ambientLight *= (1.0 - ambientOcclusion) * skyTransmittance;
+}`));
+}
+const wt = j(), U = Po();
+function nt(e) {
+  e.constants.add("ambientBoostFactor", "float", ka);
+}
+function st(e) {
+  e.uniforms.add(new $("lightingGlobalFactor", (t, a) => a.lighting.globalFactor));
+}
+function oa(e, t) {
+  const a = e.fragment;
+  switch (e.include(it, t), t.pbrMode !== f.Disabled && e.include(ot, t), e.include(dr, t), e.include(zt), a.code.add(i`
+    const float GAMMA_SRGB = 2.1;
+    const float INV_GAMMA_SRGB = 0.4761904;
+    ${t.pbrMode === f.Disabled ? "" : "const vec3 GROUND_REFLECTANCE = vec3(0.2);"}
+  `), nt(a), st(a), at(a), a.code.add(i`
+    float additionalDirectedAmbientLight(vec3 vPosWorld) {
+      float vndl = dot(${t.spherical ? i`normalize(vPosWorld)` : i`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
+      return smoothstep(0.0, 1.0, clamp(vndl * 2.5, 0.0, 1.0));
+    }
+  `), Ne(a), a.code.add(i`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
+float additionalAmbientScale = additionalDirectedAmbientLight(vPosWorld);
+return (1.0 - ambientOcclusion) * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor * mainLightIntensity;
+}`), t.pbrMode) {
+    case f.Disabled:
+    case f.WaterOnIntegratedMesh:
+    case f.Water:
+      e.include(bt), a.code.add(i`vec3 evaluateSceneLighting(vec3 normalWorld, vec3 albedo, float shadow, float ssao, vec3 additionalLight)
+{
+vec3 mainLighting = evaluateMainLighting(normalWorld, shadow);
+vec3 ambientLighting = calculateAmbientIrradiance(normalWorld, ssao);
+vec3 albedoLinear = pow(albedo, vec3(GAMMA_SRGB));
+vec3 totalLight = mainLighting + ambientLighting + additionalLight;
+totalLight = min(totalLight, vec3(PI));
+vec3 outColor = vec3((albedoLinear / PI) * totalLight);
+return pow(outColor, vec3(INV_GAMMA_SRGB));
+}`);
+      break;
+    case f.Normal:
+    case f.Schematic:
+      a.code.add(i`const float fillLightIntensity = 0.25;
+const float horizonLightDiffusion = 0.4;
+const float additionalAmbientIrradianceFactor = 0.02;
+vec3 evaluateSceneLightingPBR(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight, vec3 viewDir, vec3 normalGround, vec3 mrr, vec3 _emission, float additionalAmbientIrradiance)
+{
+vec3 viewDirection = -viewDir;
+vec3 h = normalize(viewDirection + mainLightDirection);
+PBRShadingInfo inputs;
+inputs.NdotL = clamp(dot(normal, mainLightDirection), 0.001, 1.0);
+inputs.NdotV = clamp(abs(dot(normal, viewDirection)), 0.001, 1.0);
+inputs.NdotH = clamp(dot(normal, h), 0.0, 1.0);
+inputs.VdotH = clamp(dot(viewDirection, h), 0.0, 1.0);
+inputs.NdotNG = clamp(dot(normal, normalGround), -1.0, 1.0);
+vec3 reflectedView = normalize(reflect(viewDirection, normal));
+inputs.RdotNG = clamp(dot(reflectedView, normalGround), -1.0, 1.0);
+inputs.albedoLinear = pow(albedo, vec3(GAMMA_SRGB));
+inputs.ssao = ssao;
+inputs.metalness = mrr[0];
+inputs.roughness = clamp(mrr[1] * mrr[1], 0.001, 0.99);`), a.code.add(i`inputs.f0 = (0.16 * mrr[2] * mrr[2]) * (1.0 - inputs.metalness) + inputs.albedoLinear * inputs.metalness;
+inputs.f90 = vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
+inputs.diffuseColor = inputs.albedoLinear * (vec3(1.0) - inputs.f0) * (1.0 - inputs.metalness);`), t.useFillLights ? a.uniforms.add(new Ya("hasFillLights", (o, n) => n.enableFillLights)) : a.constants.add("hasFillLights", "bool", !1), a.code.add(i`vec3 ambientDir = vec3(5.0 * normalGround[1] - normalGround[0] * normalGround[2], - 5.0 * normalGround[0] - normalGround[2] * normalGround[1], normalGround[1] * normalGround[1] + normalGround[0] * normalGround[0]);
+ambientDir = ambientDir != vec3(0.0) ? normalize(ambientDir) : normalize(vec3(5.0, -1.0, 0.0));
+inputs.NdotAmbDir = hasFillLights ? abs(dot(normal, ambientDir)) : 1.0;
+vec3 mainLightIrradianceComponent = inputs.NdotL * (1.0 - shadow) * mainLightIntensity;
+vec3 fillLightsIrradianceComponent = inputs.NdotAmbDir * mainLightIntensity * fillLightIntensity;
+vec3 ambientLightIrradianceComponent = calculateAmbientIrradiance(normal, ssao) + additionalLight;
+inputs.skyIrradianceToSurface = ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
+inputs.groundIrradianceToSurface = GROUND_REFLECTANCE * ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;`), a.uniforms.add(new $("lightingSpecularStrength", (o, n) => n.lighting.mainLight.specularStrength), new $("lightingEnvironmentStrength", (o, n) => n.lighting.mainLight.environmentStrength)), a.code.add(i`vec3 horizonRingDir = inputs.RdotNG * normalGround - reflectedView;
+vec3 horizonRingH = normalize(viewDirection + horizonRingDir);
+inputs.NdotH_Horizon = dot(normal, horizonRingH);
+vec3 mainLightRadianceComponent = lightingSpecularStrength * normalDistribution(inputs.NdotH, inputs.roughness) * mainLightIntensity * (1.0 - shadow);
+vec3 horizonLightRadianceComponent = lightingEnvironmentStrength * normalDistribution(inputs.NdotH_Horizon, min(inputs.roughness + horizonLightDiffusion, 1.0)) * mainLightIntensity * fillLightIntensity;
+vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance(ssao) + additionalLight;
+float normalDirectionModifier = mix(1., min(mix(0.1, 2.0, (inputs.NdotNG + 1.) * 0.5), 1.0), clamp(inputs.roughness * 5.0, 0.0 , 1.0));
+inputs.skyRadianceToSurface = (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
+inputs.groundRadianceToSurface = 0.5 * GROUND_REFLECTANCE * (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
+inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + GROUND_REFLECTANCE[1]);`), a.code.add(i`
+        vec3 reflectedColorComponent = evaluateEnvironmentIllumination(inputs);
+        vec3 additionalMaterialReflectanceComponent = inputs.albedoLinear * additionalAmbientIrradiance;
+        vec3 emissionComponent = _emission == vec3(0.0) ? _emission : pow(_emission, vec3(GAMMA_SRGB));
+        vec3 outColorLinear = reflectedColorComponent + additionalMaterialReflectanceComponent + emissionComponent;
+        ${t.pbrMode !== f.Schematic || t.hasColorTexture ? i`vec3 outColor = pow(blackLevelSoftCompression(outColorLinear, inputs), vec3(INV_GAMMA_SRGB));` : i`vec3 outColor = pow(max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance), vec3(INV_GAMMA_SRGB));`}
+        return outColor;
+      }
+    `);
+      break;
+    case f.Simplified:
+    case f.TerrainWithWater:
+      e.include(bt), a.code.add(i`const float roughnessTerrain = 0.5;
+const float specularityTerrain = 0.5;
+const vec3 fresnelReflectionTerrain = vec3(0.04);
+vec3 evaluatePBRSimplifiedLighting(vec3 n, vec3 c, float shadow, float ssao, vec3 al, vec3 vd, vec3 nup) {
+vec3 viewDirection = -vd;
+vec3 h = normalize(viewDirection + mainLightDirection);
+float NdotL = clamp(dot(n, mainLightDirection), 0.001, 1.0);
+float NdotV = clamp(abs(dot(n, viewDirection)), 0.001, 1.0);
+float NdotH = clamp(dot(n, h), 0.0, 1.0);
+float NdotNG = clamp(dot(n, nup), -1.0, 1.0);
+vec3 albedoLinear = pow(c, vec3(GAMMA_SRGB));
+float lightness = 0.3 * albedoLinear[0] + 0.5 * albedoLinear[1] + 0.2 * albedoLinear[2];
+vec3 f0 = (0.85 * lightness + 0.15) * fresnelReflectionTerrain;
+vec3 f90 =  vec3(clamp(dot(f0, vec3(50.0 * 0.33)), 0.0, 1.0));
+vec3 mainLightIrradianceComponent = (1. - shadow) * NdotL * mainLightIntensity;
+vec3 ambientLightIrradianceComponent = calculateAmbientIrradiance(n, ssao) + al;
+vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
+vec3 indirectDiffuse = ((1.0 - NdotNG) * mainLightIrradianceComponent + (1.0 + NdotNG ) * ambientSky) * 0.5;
+vec3 outDiffColor = albedoLinear * (1.0 - f0) * indirectDiffuse / PI;
+vec3 mainLightRadianceComponent = normalDistribution(NdotH, roughnessTerrain) * mainLightIntensity;
+vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, NdotV);
+vec3 specularColor = f0 * dfg.x + f90 * dfg.y;
+vec3 specularComponent = specularityTerrain * specularColor * mainLightRadianceComponent;
+vec3 outColorLinear = outDiffColor + specularComponent;
+vec3 outColor = pow(outColorLinear, vec3(INV_GAMMA_SRGB));
+return outColor;
+}`);
+      break;
+    default:
+      Ct(t.pbrMode);
+    case f.COUNT:
+  }
+}
+class ur extends He {
+  constructor(t, a, o) {
+    super(t, "mat4", Re.Draw, (n, r, c, l) => n.setUniformMatrix4fv(t, a(r, c, l)), o);
+  }
+}
+class hr extends He {
+  constructor(t, a, o) {
+    super(t, "mat4", Re.Pass, (n, r, c) => n.setUniformMatrix4fv(t, a(r, c)), o);
+  }
+}
+function ra(e, t) {
+  t.receiveShadows && (e.fragment.uniforms.add(new hr("shadowMapMatrix", (a, o) => o.shadowMap.getShadowMapMatrices(a.origin), 4)), na(e));
+}
+function ia(e, t) {
+  t.receiveShadows && (e.fragment.uniforms.add(new ur("shadowMapMatrix", (a, o) => o.shadowMap.getShadowMapMatrices(a.origin), 4)), na(e));
+}
+function na(e) {
+  const t = e.fragment;
+  t.include(Ja), t.uniforms.add(new z("shadowMap", (a, o) => o.shadowMap.depthTexture), new Pt("numCascades", (a, o) => o.shadowMap.numCascades), new L("cascadeDistances", (a, o) => o.shadowMap.cascadeDistances)), t.code.add(i`int chooseCascade(float depth, out mat4 mat) {
+vec4 distance = cascadeDistances;
+int i = depth < distance[1] ? 0 : depth < distance[2] ? 1 : depth < distance[3] ? 2 : 3;
+mat = i == 0 ? shadowMapMatrix[0] : i == 1 ? shadowMapMatrix[1] : i == 2 ? shadowMapMatrix[2] : shadowMapMatrix[3];
+return i;
+}
+vec3 lightSpacePosition(vec3 _vpos, mat4 mat) {
+vec4 lv = mat * vec4(_vpos, 1.0);
+lv.xy /= lv.w;
+return 0.5 * lv.xyz + vec3(0.5);
+}
+vec2 cascadeCoordinates(int i, ivec2 textureSize, vec3 lvpos) {
+float xScale = float(textureSize.y) / float(textureSize.x);
+return vec2((float(i) + lvpos.x) * xScale, lvpos.y);
+}
+float readShadowMapDepth(ivec2 uv, sampler2D _depthTex) {
+return rgba4ToFloat(texelFetch(_depthTex, uv, 0));
+}
+float posIsInShadow(ivec2 uv, vec3 lvpos, sampler2D _depthTex) {
+return readShadowMapDepth(uv, _depthTex) < lvpos.z ? 1.0 : 0.0;
+}
+float filterShadow(vec2 uv, vec3 lvpos, ivec2 texSize, sampler2D _depthTex) {
+vec2 st = fract(uv * vec2(texSize) + vec2(0.5));
+ivec2 base = ivec2(uv * vec2(texSize) - vec2(0.5));
+float s00 = posIsInShadow(ivec2(base.x, base.y), lvpos, _depthTex);
+float s10 = posIsInShadow(ivec2(base.x + 1, base.y), lvpos, _depthTex);
+float s11 = posIsInShadow(ivec2(base.x + 1, base.y + 1), lvpos, _depthTex);
+float s01 = posIsInShadow(ivec2(base.x, base.y + 1), lvpos, _depthTex);
+return mix(mix(s00, s10, st.x), mix(s01, s11, st.x), st.y);
+}
+float readShadowMap(const in vec3 _vpos, float _linearDepth) {
+mat4 mat;
+int i = chooseCascade(_linearDepth, mat);
+if (i >= numCascades) { return 0.0; }
+vec3 lvpos = lightSpacePosition(_vpos, mat);
+if (lvpos.z >= 1.0 || lvpos.x < 0.0 || lvpos.x > 1.0 || lvpos.y < 0.0 || lvpos.y > 1.0) { return 0.0; }
+ivec2 size = textureSize(shadowMap, 0);
+vec2 uv = cascadeCoordinates(i, size, lvpos);
+return filterShadow(uv, lvpos, size, shadowMap);
+}`);
+}
+function mr(e, t) {
+  t.hasColorTextureTransform ? (e.vertex.uniforms.add(new te("colorTextureTransformMatrix", (a) => a.colorTextureTransformMatrix ?? ee)), e.varyings.add("colorUV", "vec2"), e.vertex.code.add(i`void forwardColorUV(){
+colorUV = (colorTextureTransformMatrix * vec3(vuv0, 1.0)).xy;
+}`)) : e.vertex.code.add(i`void forwardColorUV(){}`);
+}
+function pr(e, t) {
+  t.hasNormalTextureTransform && t.textureCoordinateType !== k.None ? (e.vertex.uniforms.add(new te("normalTextureTransformMatrix", (a) => a.normalTextureTransformMatrix ?? ee)), e.varyings.add("normalUV", "vec2"), e.vertex.code.add(i`void forwardNormalUV(){
+normalUV = (normalTextureTransformMatrix * vec3(vuv0, 1.0)).xy;
+}`)) : e.vertex.code.add(i`void forwardNormalUV(){}`);
+}
+function fr(e, t) {
+  t.hasEmissionTextureTransform && t.textureCoordinateType !== k.None ? (e.vertex.uniforms.add(new te("emissiveTextureTransformMatrix", (a) => a.emissiveTextureTransformMatrix ?? ee)), e.varyings.add("emissiveUV", "vec2"), e.vertex.code.add(i`void forwardEmissiveUV(){
+emissiveUV = (emissiveTextureTransformMatrix * vec3(vuv0, 1.0)).xy;
+}`)) : e.vertex.code.add(i`void forwardEmissiveUV(){}`);
+}
+function vr(e, t) {
+  t.hasOcclusionTextureTransform && t.textureCoordinateType !== k.None ? (e.vertex.uniforms.add(new te("occlusionTextureTransformMatrix", (a) => a.occlusionTextureTransformMatrix ?? ee)), e.varyings.add("occlusionUV", "vec2"), e.vertex.code.add(i`void forwardOcclusionUV(){
+occlusionUV = (occlusionTextureTransformMatrix * vec3(vuv0, 1.0)).xy;
+}`)) : e.vertex.code.add(i`void forwardOcclusionUV(){}`);
+}
+function gr(e, t) {
+  t.hasMetallicRoughnessTextureTransform && t.textureCoordinateType !== k.None ? (e.vertex.uniforms.add(new te("metallicRoughnessTextureTransformMatrix", (a) => a.metallicRoughnessTextureTransformMatrix ?? ee)), e.varyings.add("metallicRoughnessUV", "vec2"), e.vertex.code.add(i`void forwardMetallicRoughnessUV(){
+metallicRoughnessUV = (metallicRoughnessTextureTransformMatrix * vec3(vuv0, 1.0)).xy;
+}`)) : e.vertex.code.add(i`void forwardMetallicRoughnessUV(){}`);
+}
+function $e(e) {
+  e.include(Za), e.code.add(i`
+    vec3 mixExternalColor(vec3 internalColor, vec3 textureColor, vec3 externalColor, int mode) {
+      // workaround for artifacts in OSX using Intel Iris Pro
+      // see: https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/10475
+      vec3 internalMixed = internalColor * textureColor;
+      vec3 allMixed = internalMixed * externalColor;
+
+      if (mode == ${i.int(q.Multiply)}) {
+        return allMixed;
+      }
+      if (mode == ${i.int(q.Ignore)}) {
+        return internalMixed;
+      }
+      if (mode == ${i.int(q.Replace)}) {
+        return externalColor;
+      }
+
+      // tint (or something invalid)
+      float vIn = rgb2v(internalMixed);
+      vec3 hsvTint = rgb2hsv(externalColor);
+      vec3 hsvOut = vec3(hsvTint.x, hsvTint.y, vIn * hsvTint.z);
+      return hsv2rgb(hsvOut);
+    }
+
+    float mixExternalOpacity(float internalOpacity, float textureOpacity, float externalOpacity, int mode) {
+      // workaround for artifacts in OSX using Intel Iris Pro
+      // see: https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/10475
+      float internalMixed = internalOpacity * textureOpacity;
+      float allMixed = internalMixed * externalOpacity;
+
+      if (mode == ${i.int(q.Ignore)}) {
+        return internalMixed;
+      }
+      if (mode == ${i.int(q.Replace)}) {
+        return externalOpacity;
+      }
+
+      // multiply or tint (or something invalid)
+      return allMixed;
+    }
+  `);
+}
+function xr(e) {
+  const t = new _e(), { vertex: a, fragment: o, varyings: n } = t;
+  if (se(a, e), t.include(Ft), n.add("vpos", "vec3"), t.include(de, e), t.include(It, e), t.include(Dt, e), t.include(mr, e), e.output === x.Color || e.output === x.Alpha) {
+    t.include(pr, e), t.include(fr, e), t.include(vr, e), t.include(gr, e), Ce(a, e), t.include(Ze, e), t.include(le, e);
+    const r = e.normalType === R.Attribute || e.normalType === R.Compressed;
+    r && e.offsetBackfaces && t.include(Kt), t.include(Ko, e), t.include(Gt, e), e.instancedColor && t.attributes.add(C.INSTANCECOLOR, "vec4"), n.add("vPositionLocal", "vec3"), t.include(ce, e), t.include(Vt, e), t.include(Qt, e), t.include(Ut, e), a.uniforms.add(new L("externalColor", (c) => c.externalColor)), n.add("vcolorExt", "vec4"), e.multipassEnabled && n.add("depth", "float"), a.code.add(i`
+      void main(void) {
+        forwardNormalizedVertexColor();
+        vcolorExt = externalColor;
+        ${e.instancedColor ? "vcolorExt *= instanceColor * 0.003921568627451;" : ""}
+        vcolorExt *= vvColor();
+        vcolorExt *= getSymbolColor();
+        forwardColorMixMode();
+
+        if (vcolorExt.a < ${i.float(Je)}) {
+          gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
+        } else {
+          vpos = getVertexInLocalOriginSpace();
+          vPositionLocal = vpos - view[3].xyz;
+          vpos = subtractOrigin(vpos);
+          ${r ? i`vNormalWorld = dpNormal(vvLocalNormal(normalModel()));` : ""}
+          vpos = addVerticalOffset(vpos, localOrigin);
+          ${e.hasVertexTangents ? "vTangent = dpTransformVertexTangent(tangent);" : ""}
+          gl_Position = transformPosition(proj, view, vpos);
+          ${r && e.offsetBackfaces ? "gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);" : ""}
+        }
+
+        ${e.multipassEnabled ? "depth = (view * vec4(vpos, 1.0)).z;" : ""}
+        forwardLinearDepth();
+        forwardTextureCoordinates();
+        forwardColorUV();
+        forwardNormalUV();
+        forwardEmissiveUV();
+        forwardOcclusionUV();
+        forwardMetallicRoughnessUV();
+      }
+    `);
+  }
+  switch (e.output) {
+    case x.Alpha:
+      t.include(Z, e), t.include(H, e), t.include(Se, e), o.uniforms.add(new $("opacity", (r) => r.opacity), new $("layerOpacity", (r) => r.layerOpacity)), e.hasColorTexture && o.uniforms.add(new z("tex", (r) => r.texture)), o.include($e), o.code.add(i`
+      void main() {
+        discardBySlice(vpos);
+        ${e.multipassEnabled ? "terrainDepthTest(depth);" : ""}
+        ${e.hasColorTexture ? i`
+                vec4 texColor = texture(tex, ${e.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                ${e.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
+                discardOrAdjustAlpha(texColor);` : i`vec4 texColor = vec4(1.0);`}
+        ${e.hasVertexColors ? i`float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));` : i`float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
+        fragColor = vec4(opacity_);
+      }
+    `);
+      break;
+    case x.Color:
+      t.include(Z, e), t.include(oa, e), t.include(it, e), t.include(H, e), t.include(e.instancedDoublePrecision ? ra : ia, e), t.include(Se, e), Ce(o, e), o.uniforms.add(a.uniforms.get("localOrigin"), new Y("ambient", (r) => r.ambient), new Y("diffuse", (r) => r.diffuse), new $("opacity", (r) => r.opacity), new $("layerOpacity", (r) => r.layerOpacity)), e.hasColorTexture && o.uniforms.add(new z("tex", (r) => r.texture)), t.include(Wt, e), t.include(ot, e), o.include($e), t.include(qo, e), nt(o), st(o), Ne(o), o.code.add(i`
+      void main() {
+        discardBySlice(vpos);
+        ${e.multipassEnabled ? "terrainDepthTest(depth);" : ""}
+        ${e.hasColorTexture ? i`
+                vec4 texColor = texture(tex, ${e.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                ${e.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
+                discardOrAdjustAlpha(texColor);` : i`vec4 texColor = vec4(1.0);`}
+        shadingParams.viewDirection = normalize(vpos - cameraPosition);
+        ${e.normalType === R.ScreenDerivative ? i`
+                vec3 normal = screenDerivativeNormal(vPositionLocal);` : i`
+                shadingParams.normalView = vNormalWorld;
+                vec3 normal = shadingNormal(shadingParams);`}
+        ${e.pbrMode === f.Normal ? "applyPBRFactors();" : ""}
+        float ssao = evaluateAmbientOcclusionInverse() * getBakedOcclusion();
+
+        vec3 posWorld = vpos + localOrigin;
+
+        float additionalAmbientScale = additionalDirectedAmbientLight(posWorld);
+        float shadow = ${e.receiveShadows ? "readShadowMap(vpos, linearDepth)" : e.spherical ? "lightingGlobalFactor * (1.0 - additionalAmbientScale)" : "0.0"};
+
+        vec3 matColor = max(ambient, diffuse);
+        ${e.hasVertexColors ? i`
+                vec3 albedo = mixExternalColor(vColor.rgb * matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
+                float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));` : i`
+                vec3 albedo = mixExternalColor(matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
+                float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
+        ${e.hasNormalTexture ? i`
+                mat3 tangentSpace = ${e.hasVertexTangents ? "computeTangentSpace(normal);" : "computeTangentSpace(normal, vpos, vuv0);"}
+                vec3 shadingNormal = computeTextureNormal(tangentSpace, ${e.hasNormalTextureTransform ? i`normalUV` : "vuv0"});` : i`vec3 shadingNormal = normal;`}
+        vec3 normalGround = ${e.spherical ? i`normalize(posWorld);` : i`vec3(0.0, 0.0, 1.0);`}
+
+        ${e.snowCover ? i`
+                float snow = smoothstep(0.5, 0.55, dot(normal, normalGround));
+                albedo = mix(albedo, vec3(1), snow);
+                shadingNormal = mix(shadingNormal, normal, snow);
+                ssao = mix(ssao, 1.0, snow);` : ""}
+
+        vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
+
+        ${e.pbrMode === f.Normal || e.pbrMode === f.Schematic ? i`
+                float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
+                ${e.snowCover ? i`
+                        mrr = mix(mrr, vec3(0.0, 1.0, 0.04), snow);
+                        emission = mix(emission, vec3(0.0), snow);` : ""}
+
+                vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, emission, additionalAmbientIrradiance);` : i`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
+        fragColor = highlightSlice(vec4(shadedColor, opacity_), vpos);
+        ${e.transparencyPassType === Q.Color ? i`fragColor = premultiplyAlpha(fragColor);` : ""}
+      }
+    `);
+  }
+  return t.include(ea, e), t;
+}
+const br = Object.freeze(Object.defineProperty({ __proto__: null, build: xr }, Symbol.toStringTag, { value: "Module" }));
+let yr = class extends Qa {
+  constructor() {
+    super(...arguments), this.isSchematic = !1, this.usePBR = !1, this.mrrFactors = ke(Xt), this.hasVertexColors = !1, this.hasSymbolColors = !1, this.doubleSided = !1, this.doubleSidedType = "normal", this.cullFace = J.Back, this.isInstanced = !1, this.hasInstancedColor = !1, this.emissiveFactor = xe(0, 0, 0), this.instancedDoublePrecision = !1, this.normalType = R.Attribute, this.receiveShadows = !0, this.receiveAmbientOcclusion = !0, this.castShadows = !0, this.shadowMappingEnabled = !1, this.ambient = xe(0.2, 0.2, 0.2), this.diffuse = xe(0.8, 0.8, 0.8), this.externalColor = Go(1, 1, 1, 1), this.colorMixMode = "multiply", this.opacity = 1, this.layerOpacity = 1, this.origin = j(), this.hasSlicePlane = !1, this.hasSliceHighlight = !0, this.offsetTransparentBackfaces = !1, this.vvSize = null, this.vvColor = null, this.vvOpacity = null, this.vvSymbolAnchor = null, this.vvSymbolRotationMatrix = null, this.modelTransformation = null, this.transparent = !1, this.writeDepth = !0, this.customDepthTest = he.Less, this.textureAlphaMode = M.Blend, this.textureAlphaCutoff = eo, this.textureAlphaPremultiplied = !1, this.hasOccludees = !1, this.renderOccluded = to.Occlude, this.isDecoration = !1;
+  }
+}, lt = class sa extends Xe {
+  initializeConfiguration(t, a) {
+    a.spherical = t.viewingMode === qe.Global, a.doublePrecisionRequiresObfuscation = t.rctx.driverTest.doublePrecisionRequiresObfuscation.result, a.textureCoordinateType = a.hasColorTexture || a.hasMetallicRoughnessTexture || a.hasEmissionTexture || a.hasOcclusionTexture || a.hasNormalTexture ? k.Default : k.None, a.objectAndLayerIdColorInstanced = a.instanced;
+  }
+  initializeProgram(t) {
+    return this._initializeProgram(t, sa.shader);
+  }
+  _initializeProgram(t, a) {
+    return new Ke(t.rctx, a.get().build(this.configuration), Qe);
+  }
+  _convertDepthTestFunction(t) {
+    return t === he.Lequal ? xt.LEQUAL : xt.LESS;
+  }
+  _makePipeline(t, a) {
+    const o = this.configuration, n = t === Q.NONE, r = t === Q.FrontFace;
+    return et({ blending: o.output !== x.Color && o.output !== x.Alpha || !o.transparent ? null : n ? $o : Eo(t), culling: Tr(o) ? _o(o.cullFace) : null, depthTest: { func: Ao(t, this._convertDepthTestFunction(o.customDepthTest)) }, depthWrite: (n || r) && o.writeDepth ? Ro : null, colorWrite: tt, stencilWrite: o.hasOccludees ? Ha : null, stencilTest: o.hasOccludees ? a ? Xa : Ka : null, polygonOffset: n || r ? null : No(o.enableOffset) });
+  }
+  initializePipeline() {
+    return this._occludeePipelineState = this._makePipeline(this.configuration.transparencyPassType, !0), this._makePipeline(this.configuration.transparencyPassType, !1);
+  }
+  getPipeline(t) {
+    return t ? this._occludeePipelineState : super.getPipeline();
+  }
+};
+function Tr(e) {
+  return e.cullFace !== J.None || !e.hasSlicePlane && !e.transparent && !e.doubleSidedMode;
+}
+lt.shader = new Ae(br, () => import("./DefaultMaterial.glsl-3cc4efe7.js"));
+class u extends ao {
+  constructor() {
+    super(...arguments), this.output = x.Color, this.alphaDiscardMode = M.Opaque, this.doubleSidedMode = N.None, this.pbrMode = f.Disabled, this.cullFace = J.None, this.transparencyPassType = Q.NONE, this.normalType = R.Attribute, this.textureCoordinateType = k.None, this.customDepthTest = he.Less, this.spherical = !1, this.hasVertexColors = !1, this.hasSymbolColors = !1, this.hasVerticalOffset = !1, this.hasSlicePlane = !1, this.hasSliceHighlight = !0, this.hasColorTexture = !1, this.hasMetallicRoughnessTexture = !1, this.hasEmissionTexture = !1, this.hasOcclusionTexture = !1, this.hasNormalTexture = !1, this.hasScreenSizePerspective = !1, this.hasVertexTangents = !1, this.hasOccludees = !1, this.multipassEnabled = !1, this.hasModelTransformation = !1, this.offsetBackfaces = !1, this.vvSize = !1, this.vvColor = !1, this.receiveShadows = !1, this.receiveAmbientOcclusion = !1, this.textureAlphaPremultiplied = !1, this.instanced = !1, this.instancedColor = !1, this.objectAndLayerIdColorInstanced = !1, this.instancedDoublePrecision = !1, this.doublePrecisionRequiresObfuscation = !1, this.writeDepth = !0, this.transparent = !1, this.enableOffset = !0, this.cullAboveGround = !1, this.snowCover = !1, this.hasColorTextureTransform = !1, this.hasEmissionTextureTransform = !1, this.hasNormalTextureTransform = !1, this.hasOcclusionTextureTransform = !1, this.hasMetallicRoughnessTextureTransform = !1;
+  }
+}
+d([h({ count: x.COUNT })], u.prototype, "output", void 0), d([h({ count: M.COUNT })], u.prototype, "alphaDiscardMode", void 0), d([h({ count: N.COUNT })], u.prototype, "doubleSidedMode", void 0), d([h({ count: f.COUNT })], u.prototype, "pbrMode", void 0), d([h({ count: J.COUNT })], u.prototype, "cullFace", void 0), d([h({ count: Q.COUNT })], u.prototype, "transparencyPassType", void 0), d([h({ count: R.COUNT })], u.prototype, "normalType", void 0), d([h({ count: k.COUNT })], u.prototype, "textureCoordinateType", void 0), d([h({ count: he.COUNT })], u.prototype, "customDepthTest", void 0), d([h()], u.prototype, "spherical", void 0), d([h()], u.prototype, "hasVertexColors", void 0), d([h()], u.prototype, "hasSymbolColors", void 0), d([h()], u.prototype, "hasVerticalOffset", void 0), d([h()], u.prototype, "hasSlicePlane", void 0), d([h()], u.prototype, "hasSliceHighlight", void 0), d([h()], u.prototype, "hasColorTexture", void 0), d([h()], u.prototype, "hasMetallicRoughnessTexture", void 0), d([h()], u.prototype, "hasEmissionTexture", void 0), d([h()], u.prototype, "hasOcclusionTexture", void 0), d([h()], u.prototype, "hasNormalTexture", void 0), d([h()], u.prototype, "hasScreenSizePerspective", void 0), d([h()], u.prototype, "hasVertexTangents", void 0), d([h()], u.prototype, "hasOccludees", void 0), d([h()], u.prototype, "multipassEnabled", void 0), d([h()], u.prototype, "hasModelTransformation", void 0), d([h()], u.prototype, "offsetBackfaces", void 0), d([h()], u.prototype, "vvSize", void 0), d([h()], u.prototype, "vvColor", void 0), d([h()], u.prototype, "receiveShadows", void 0), d([h()], u.prototype, "receiveAmbientOcclusion", void 0), d([h()], u.prototype, "textureAlphaPremultiplied", void 0), d([h()], u.prototype, "instanced", void 0), d([h()], u.prototype, "instancedColor", void 0), d([h()], u.prototype, "objectAndLayerIdColorInstanced", void 0), d([h()], u.prototype, "instancedDoublePrecision", void 0), d([h()], u.prototype, "doublePrecisionRequiresObfuscation", void 0), d([h()], u.prototype, "writeDepth", void 0), d([h()], u.prototype, "transparent", void 0), d([h()], u.prototype, "enableOffset", void 0), d([h()], u.prototype, "cullAboveGround", void 0), d([h()], u.prototype, "snowCover", void 0), d([h()], u.prototype, "hasColorTextureTransform", void 0), d([h()], u.prototype, "hasEmissionTextureTransform", void 0), d([h()], u.prototype, "hasNormalTextureTransform", void 0), d([h()], u.prototype, "hasOcclusionTextureTransform", void 0), d([h()], u.prototype, "hasMetallicRoughnessTextureTransform", void 0), d([h({ constValue: !1 })], u.prototype, "occlusionPass", void 0), d([h({ constValue: !0 })], u.prototype, "hasVvInstancing", void 0), d([h({ constValue: !1 })], u.prototype, "useCustomDTRExponentForWater", void 0), d([h({ constValue: !1 })], u.prototype, "supportsTextureAtlas", void 0), d([h({ constValue: !0 })], u.prototype, "useFillLights", void 0);
+function wr(e) {
+  const t = new _e(), { vertex: a, fragment: o, varyings: n } = t;
+  return se(a, e), t.include(Ft), n.add("vpos", "vec3"), t.include(de, e), t.include(It, e), t.include(Dt, e), e.output !== x.Color && e.output !== x.Alpha || (Ce(t.vertex, e), t.include(Ze, e), t.include(le, e), e.offsetBackfaces && t.include(Kt), e.instancedColor && t.attributes.add(C.INSTANCECOLOR, "vec4"), n.add("vNormalWorld", "vec3"), n.add("localvpos", "vec3"), e.multipassEnabled && n.add("depth", "float"), t.include(ce, e), t.include(Vt, e), t.include(Qt, e), t.include(Ut, e), a.uniforms.add(new L("externalColor", (r) => r.externalColor)), n.add("vcolorExt", "vec4"), a.code.add(i`
+        void main(void) {
+          forwardNormalizedVertexColor();
+          vcolorExt = externalColor;
+          ${e.instancedColor ? "vcolorExt *= instanceColor * 0.003921568627451;" : ""}
+          vcolorExt *= vvColor();
+          vcolorExt *= getSymbolColor();
+          forwardColorMixMode();
+
+          if (vcolorExt.a < ${i.float(Je)}) {
+            gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
+          } else {
+            vpos = getVertexInLocalOriginSpace();
+            localvpos = vpos - view[3].xyz;
+            vpos = subtractOrigin(vpos);
+            vNormalWorld = dpNormal(vvLocalNormal(normalModel()));
+            vpos = addVerticalOffset(vpos, localOrigin);
+            gl_Position = transformPosition(proj, view, vpos);
+            ${e.offsetBackfaces ? "gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);" : ""}
+          }
+          ${e.multipassEnabled ? i`depth = (view * vec4(vpos, 1.0)).z;` : ""}
+          forwardLinearDepth();
+          forwardTextureCoordinates();
+        }
+      `)), e.output === x.Alpha && (t.include(Z, e), t.include(H, e), t.include(Se, e), o.uniforms.add(new $("opacity", (r) => r.opacity), new $("layerOpacity", (r) => r.layerOpacity)), e.hasColorTexture && o.uniforms.add(new z("tex", (r) => r.texture)), o.include($e), o.code.add(i`
+      void main() {
+        discardBySlice(vpos);
+        ${e.multipassEnabled ? i`terrainDepthTest(depth);` : ""}
+        ${e.hasColorTexture ? i`
+                vec4 texColor = texture(tex, ${e.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                ${e.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
+                discardOrAdjustAlpha(texColor);` : i`vec4 texColor = vec4(1.0);`}
+        ${e.hasVertexColors ? i`float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));` : i`float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
+
+        fragColor = vec4(opacity_);
+      }
+    `)), e.output === x.Color && (t.include(Z, e), t.include(oa, e), t.include(it, e), t.include(H, e), t.include(e.instancedDoublePrecision ? ra : ia, e), t.include(Se, e), Ce(t.fragment, e), at(o), nt(o), st(o), o.uniforms.add(a.uniforms.get("localOrigin"), a.uniforms.get("view"), new Y("ambient", (r) => r.ambient), new Y("diffuse", (r) => r.diffuse), new $("opacity", (r) => r.opacity), new $("layerOpacity", (r) => r.layerOpacity)), e.hasColorTexture && o.uniforms.add(new z("tex", (r) => r.texture)), t.include(Wt, e), t.include(ot, e), o.include($e), Ne(o), o.code.add(i`
+      void main() {
+        discardBySlice(vpos);
+        ${e.multipassEnabled ? i`terrainDepthTest(depth);` : ""}
+        ${e.hasColorTexture ? i`
+                vec4 texColor = texture(tex, ${e.hasColorTextureTransform ? i`colorUV` : i`vuv0`});
+                ${e.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
+                discardOrAdjustAlpha(texColor);` : i`vec4 texColor = vec4(1.0);`}
+        vec3 viewDirection = normalize(vpos - cameraPosition);
+        ${e.pbrMode === f.Normal ? "applyPBRFactors();" : ""}
+        float ssao = evaluateAmbientOcclusionInverse();
+        ssao *= getBakedOcclusion();
+
+        float additionalAmbientScale = additionalDirectedAmbientLight(vpos + localOrigin);
+        vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
+        ${e.receiveShadows ? "float shadow = readShadowMap(vpos, linearDepth);" : e.spherical ? "float shadow = lightingGlobalFactor * (1.0 - additionalAmbientScale);" : "float shadow = 0.0;"}
+        vec3 matColor = max(ambient, diffuse);
+        ${e.hasVertexColors ? i`
+                vec3 albedo = mixExternalColor(vColor.rgb * matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
+                float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));` : i`
+                vec3 albedo = mixExternalColor(matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
+                float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
+        ${e.snowCover ? i`albedo = mix(albedo, vec3(1), 0.9);` : i``}
+        ${i`
+            vec3 shadingNormal = normalize(vNormalWorld);
+            albedo *= 1.2;
+            vec3 viewForward = vec3(view[0][2], view[1][2], view[2][2]);
+            float alignmentLightView = clamp(dot(viewForward, -mainLightDirection), 0.0, 1.0);
+            float transmittance = 1.0 - clamp(dot(viewForward, shadingNormal), 0.0, 1.0);
+            float treeRadialFalloff = vColor.r;
+            float backLightFactor = 0.5 * treeRadialFalloff * alignmentLightView * transmittance * (1.0 - shadow);
+            additionalLight += backLightFactor * mainLightIntensity;`}
+        ${e.pbrMode === f.Normal || e.pbrMode === f.Schematic ? e.spherical ? i`vec3 normalGround = normalize(vpos + localOrigin);` : i`vec3 normalGround = vec3(0.0, 0.0, 1.0);` : i``}
+        ${e.pbrMode === f.Normal || e.pbrMode === f.Schematic ? i`
+                float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
+                ${e.snowCover ? i`
+                        mrr = vec3(0.0, 1.0, 0.04);
+                        emission = vec3(0.0);` : ""}
+
+                vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, viewDirection, normalGround, mrr, emission, additionalAmbientIrradiance);` : i`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
+        fragColor = highlightSlice(vec4(shadedColor, opacity_), vpos);
+        ${e.transparencyPassType === Q.Color ? i`fragColor = premultiplyAlpha(fragColor);` : i``}
+      }
+    `)), t.include(ea, e), t;
+}
+const Mr = Object.freeze(Object.defineProperty({ __proto__: null, build: wr }, Symbol.toStringTag, { value: "Module" }));
+class Pe extends lt {
+  initializeConfiguration(t, a) {
+    super.initializeConfiguration(t, a), a.hasMetallicRoughnessTexture = !1, a.hasEmissionTexture = !1, a.hasOcclusionTexture = !1, a.hasNormalTexture = !1, a.hasModelTransformation = !1, a.normalType = R.Attribute, a.doubleSidedMode = N.WindingOrder, a.hasVertexTangents = !1;
+  }
+  initializeProgram(t) {
+    return this._initializeProgram(t, Pe.shader);
+  }
+}
+Pe.shader = new Ae(Mr, () => import("./RealisticTree.glsl-bc07c4dc.js"));
+let Ee = class extends oo {
+  constructor(t) {
+    super(t, Or), this.supportsEdges = !0, this.produces = /* @__PURE__ */ new Map([[ye.OPAQUE_MATERIAL, (a) => (Be(a) || Fe(a)) && !this.parameters.transparent], [ye.TRANSPARENT_MATERIAL, (a) => (Be(a) || Fe(a)) && this.parameters.transparent && this.parameters.writeDepth], [ye.TRANSPARENT_DEPTH_WRITE_DISABLED_MATERIAL, (a) => (Be(a) || Fe(a)) && this.parameters.transparent && !this.parameters.writeDepth]]), this._configuration = new u(), this._vertexBufferLayout = $r(this.parameters);
+  }
+  isVisibleForOutput(t) {
+    return t !== x.Shadow && t !== x.ShadowExcludeHighlight && t !== x.ShadowHighlight || this.parameters.castShadows;
+  }
+  isVisible() {
+    const t = this.parameters;
+    if (!super.isVisible() || t.layerOpacity === 0)
+      return !1;
+    const { hasInstancedColor: a, hasVertexColors: o, hasSymbolColors: n, vvColor: r } = t, c = t.colorMixMode === "replace", l = t.opacity > 0, s = t.externalColor && t.externalColor[3] > 0, p = a || r || n;
+    return o && p ? c || l : o ? c ? s : l : p ? c || l : c ? s : l;
+  }
+  getConfiguration(t, a) {
+    return this._configuration.output = t, this._configuration.hasNormalTexture = !!this.parameters.normalTextureId, this._configuration.hasColorTexture = !!this.parameters.textureId, this._configuration.hasVertexTangents = this.parameters.hasVertexTangents, this._configuration.instanced = this.parameters.isInstanced, this._configuration.instancedDoublePrecision = this.parameters.instancedDoublePrecision, this._configuration.vvSize = !!this.parameters.vvSize, this._configuration.hasVerticalOffset = this.parameters.verticalOffset != null, this._configuration.hasScreenSizePerspective = this.parameters.screenSizePerspective != null, this._configuration.hasSlicePlane = this.parameters.hasSlicePlane, this._configuration.hasSliceHighlight = this.parameters.hasSliceHighlight, this._configuration.alphaDiscardMode = this.parameters.textureAlphaMode, this._configuration.normalType = this.parameters.normalType, this._configuration.transparent = this.parameters.transparent, this._configuration.writeDepth = this.parameters.writeDepth, this.parameters.customDepthTest != null && (this._configuration.customDepthTest = this.parameters.customDepthTest), this._configuration.hasOccludees = this.parameters.hasOccludees, this._configuration.cullFace = this.parameters.hasSlicePlane ? J.None : this.parameters.cullFace, this._configuration.multipassEnabled = a.multipassEnabled, this._configuration.cullAboveGround = a.multipassTerrain.cullAboveGround, this._configuration.hasModelTransformation = this.parameters.modelTransformation != null, t !== x.Color && t !== x.Alpha || (this._configuration.hasVertexColors = this.parameters.hasVertexColors, this._configuration.hasSymbolColors = this.parameters.hasSymbolColors, this.parameters.treeRendering ? this._configuration.doubleSidedMode = N.WindingOrder : this._configuration.doubleSidedMode = this.parameters.doubleSided && this.parameters.doubleSidedType === "normal" ? N.View : this.parameters.doubleSided && this.parameters.doubleSidedType === "winding-order" ? N.WindingOrder : N.None, this._configuration.instancedColor = this.parameters.hasInstancedColor, this._configuration.receiveShadows = this.parameters.receiveShadows && this.parameters.shadowMappingEnabled, this._configuration.receiveAmbientOcclusion = this.parameters.receiveAmbientOcclusion && a.ssao != null, this._configuration.vvColor = !!this.parameters.vvColor, this._configuration.textureAlphaPremultiplied = !!this.parameters.textureAlphaPremultiplied, this._configuration.pbrMode = this.parameters.usePBR ? this.parameters.isSchematic ? f.Schematic : f.Normal : f.Disabled, this._configuration.hasMetallicRoughnessTexture = !!this.parameters.metallicRoughnessTextureId, this._configuration.hasEmissionTexture = !!this.parameters.emissiveTextureId, this._configuration.hasOcclusionTexture = !!this.parameters.occlusionTextureId, this._configuration.offsetBackfaces = !(!this.parameters.transparent || !this.parameters.offsetTransparentBackfaces), this._configuration.transparencyPassType = a.transparencyPassType, this._configuration.enableOffset = a.camera.relativeElevation < zo, this._configuration.snowCover = this.hasSnowCover(a), this._configuration.hasColorTextureTransform = !!this.parameters.colorTextureTransformMatrix, this._configuration.hasNormalTextureTransform = !!this.parameters.normalTextureTransformMatrix, this._configuration.hasEmissionTextureTransform = !!this.parameters.emissiveTextureTransformMatrix, this._configuration.hasOcclusionTextureTransform = !!this.parameters.occlusionTextureTransformMatrix, this._configuration.hasMetallicRoughnessTextureTransform = !!this.parameters.metallicRoughnessTextureTransformMatrix), this._configuration;
+  }
+  hasSnowCover(t) {
+    return t.weather != null && t.weatherVisible && t.weather.type === "snowy" && t.weather.snowCover === "enabled";
+  }
+  intersect(t, a, o, n, r, c) {
+    if (this.parameters.verticalOffset != null) {
+      const l = o.camera;
+      we(We, a[12], a[13], a[14]);
+      let s = null;
+      switch (o.viewingMode) {
+        case qe.Global:
+          s = $t(Mt, We);
+          break;
+        case qe.Local:
+          s = Sa(Mt, Ar);
+      }
+      let p = 0;
+      const m = be(Rr, We, l.eye), v = Et(m), b = ht(m, m, 1 / v);
+      let y = null;
+      this.parameters.screenSizePerspective && (y = Oa(s, b)), p += ro(l, v, this.parameters.verticalOffset, y ?? 0, this.parameters.screenSizePerspective), ht(s, s, p), $a(Ue, s, o.transform.inverseRotation), n = be(Er, n, Ue), r = be(_r, r, Ue);
+    }
+    io(t, o, n, r, no(o.verticalOffset), c);
+  }
+  createGLMaterial(t) {
+    return new Cr(t);
+  }
+  createBufferWriter() {
+    return new so(this._vertexBufferLayout);
+  }
+}, Cr = class extends lo {
+  constructor(t) {
+    super({ ...t, ...t.material.parameters });
+  }
+  _updateShadowState(t) {
+    t.shadowMap.enabled !== this._material.parameters.shadowMappingEnabled && this._material.setParameters({ shadowMappingEnabled: t.shadowMap.enabled });
+  }
+  _updateOccludeeState(t) {
+    t.hasOccludees !== this._material.parameters.hasOccludees && this._material.setParameters({ hasOccludees: t.hasOccludees });
+  }
+  beginSlot(t) {
+    this._output !== x.Color && this._output !== x.Alpha || (this._updateShadowState(t), this._updateOccludeeState(t));
+    const a = this._material.parameters;
+    this.updateTexture(a.textureId);
+    const o = t.camera.viewInverseTransposeMatrix;
+    return we(a.origin, o[3], o[7], o[11]), this._material.setParameters(this.textureBindParameters), this.ensureTechnique(a.treeRendering ? Pe : lt, t);
+  }
+};
+class Sr extends yr {
+  constructor() {
+    super(...arguments), this.initTextureTransparent = !1, this.treeRendering = !1, this.hasVertexTangents = !1;
+  }
+}
+const Or = new Sr();
+function $r(e) {
+  const t = Oo().vec3f(C.POSITION);
+  return e.normalType === R.Compressed ? t.vec2i16(C.NORMALCOMPRESSED, { glNormalized: !0 }) : t.vec3f(C.NORMAL), e.hasVertexTangents && t.vec4f(C.TANGENT), (e.textureId || e.normalTextureId || e.metallicRoughnessTextureId || e.emissiveTextureId || e.occlusionTextureId) && t.vec2f(C.UV0), e.hasVertexColors && t.vec4u8(C.COLOR), e.hasSymbolColors && t.vec4u8(C.SYMBOLCOLOR), Ea("enable-feature:objectAndLayerId-rendering") && t.vec4u8(C.OBJECTANDLAYERIDCOLOR), t;
+}
+const Er = j(), _r = j(), Ar = xe(0, 0, 1), Mt = j(), Ue = j(), We = j(), Rr = j(), W = () => Na.getLogger("esri.views.3d.layers.graphics.objectResourceUtils");
+async function Nr(e, t) {
+  const a = await zr(e, t), o = await Br(a.textureDefinitions ?? {}, t);
+  let n = 0;
+  for (const r in o)
+    if (o.hasOwnProperty(r)) {
+      const c = o[r];
+      n += c != null && c.image ? c.image.width * c.image.height * 4 : 0;
+    }
+  return { resource: a, textures: o, size: n + _a(a) };
+}
+async function zr(e, t) {
+  const a = t == null ? void 0 : t.streamDataRequester;
+  if (a)
+    return Pr(e, a, t);
+  const o = await _t(Aa(e, t));
+  if (o.ok === !0)
+    return o.value.data;
+  At(o.error), la(o.error);
+}
+async function Pr(e, t, a) {
+  const o = await _t(t.request(e, "json", a));
+  if (o.ok === !0)
+    return o.value;
+  At(o.error), la(o.error.details.url);
+}
+function la(e) {
+  throw new Ra("", `Request for object resource failed: ${e}`);
+}
+function Gr(e) {
+  const t = e.params, a = t.topology;
+  let o = !0;
+  switch (t.vertexAttributes || (W().warn("Geometry must specify vertex attributes"), o = !1), t.topology) {
+    case "PerAttributeArray":
+      break;
+    case "Indexed":
+    case null:
+    case void 0: {
+      const r = t.faces;
+      if (r) {
+        if (t.vertexAttributes)
+          for (const c in t.vertexAttributes) {
+            const l = r[c];
+            l != null && l.values ? (l.valueType != null && l.valueType !== "UInt32" && (W().warn(`Unsupported indexed geometry indices type '${l.valueType}', only UInt32 is currently supported`), o = !1), l.valuesPerElement != null && l.valuesPerElement !== 1 && (W().warn(`Unsupported indexed geometry values per element '${l.valuesPerElement}', only 1 is currently supported`), o = !1)) : (W().warn(`Indexed geometry does not specify face indices for '${c}' attribute`), o = !1);
+          }
+      } else
+        W().warn("Indexed geometries must specify faces"), o = !1;
+      break;
+    }
+    default:
+      W().warn(`Unsupported topology '${a}'`), o = !1;
+  }
+  e.params.material || (W().warn("Geometry requires material"), o = !1);
+  const n = e.params.vertexAttributes;
+  for (const r in n)
+    n[r].values || (W().warn("Geometries with externally defined attributes are not yet supported"), o = !1);
+  return o;
+}
+function Lr(e, t) {
+  var w, g;
+  const a = new Array(), o = new Array(), n = new Array(), r = new Mo(), c = e.resource, l = Zt.parse(c.version || "1.0", "wosr");
+  Ir.validate(l);
+  const s = c.model.name, p = c.model.geometries, m = c.materialDefinitions ?? {}, v = e.textures;
+  let b = 0;
+  const y = /* @__PURE__ */ new Map();
+  for (let T = 0; T < p.length; T++) {
+    const S = p[T];
+    if (!Gr(S))
+      continue;
+    const E = Fr(S), _ = S.params.vertexAttributes, B = [], F = (O) => {
+      if (S.params.topology === "PerAttributeArray")
+        return null;
+      const I = S.params.faces;
+      for (const D in I)
+        if (D === O)
+          return I[D].values;
+      return null;
+    }, ae = _[C.POSITION], me = ae.values.length / ae.valuesPerElement;
+    for (const O in _) {
+      const I = _[O], D = I.values, Ge = F(O) ?? Co(me);
+      B.push([O, new K(D, Ge, I.valuesPerElement, !0)]);
+    }
+    const P = E.texture, A = v && v[P];
+    if (A && !y.has(P)) {
+      const { image: O, parameters: I } = A, D = new qt(O, I);
+      o.push(D), y.set(P, D);
+    }
+    const pe = y.get(P), oe = pe ? pe.id : void 0, G = E.material;
+    let re = r.get(G, P);
+    if (re == null) {
+      const O = m[G.substring(G.lastIndexOf("/") + 1)].params;
+      O.transparency === 1 && (O.transparency = 0);
+      const I = A && A.alphaChannelUsage, D = O.transparency > 0 || I === "transparency" || I === "maskAndTransparency", Ge = A ? ca(A.alphaChannelUsage) : void 0, ct = { ambient: ke(O.diffuse), diffuse: ke(O.diffuse), opacity: 1 - (O.transparency || 0), transparent: D, textureAlphaMode: Ge, textureAlphaCutoff: 0.33, textureId: oe, initTextureTransparent: !0, doubleSided: !0, cullFace: J.None, colorMixMode: O.externalColorMixMode || "tint", textureAlphaPremultiplied: (A == null ? void 0 : A.parameters.preMultiplyAlpha) ?? !1 };
+      t != null && t.materialParameters && Object.assign(ct, t.materialParameters), re = new Ee(ct), r.set(G, P, re);
+    }
+    n.push(re);
+    const ha = new kt(re, B);
+    b += ((g = (w = B.find((O) => O[0] === C.POSITION)) == null ? void 0 : w[1]) == null ? void 0 : g.indices.length) ?? 0, a.push(ha);
+  }
+  return { engineResources: [{ name: s, stageResources: { textures: o, materials: n, geometries: a }, pivotOffset: c.model.pivotOffset, numberOfVertices: b, lodThreshold: null }], referenceBoundingBox: jr(a) };
+}
+function jr(e) {
+  const t = Rt();
+  return e.forEach((a) => {
+    const o = a.boundingInfo;
+    o != null && (Me(t, o.bbMin), Me(t, o.bbMax));
+  }), t;
+}
+async function Br(e, t) {
+  const a = new Array();
+  for (const r in e) {
+    const c = e[r], l = c.images[0].data;
+    if (!l) {
+      W().warn("Externally referenced texture data is not yet supported");
+      continue;
+    }
+    const s = c.encoding + ";base64," + l, p = "/textureDefinitions/" + r, m = c.channels === "rgba" ? c.alphaChannelUsage || "transparency" : "none", v = { noUnpackFlip: !0, wrap: { s: Oe.REPEAT, t: Oe.REPEAT }, preMultiplyAlpha: ca(m) !== M.Opaque }, b = t != null && t.disableTextures ? Promise.resolve(null) : So(s, t);
+    a.push(b.then((y) => ({ refId: p, image: y, parameters: v, alphaChannelUsage: m })));
+  }
+  const o = await Promise.all(a), n = {};
+  for (const r of o)
+    n[r.refId] = r;
+  return n;
+}
+function ca(e) {
+  switch (e) {
+    case "mask":
+      return M.Mask;
+    case "maskAndTransparency":
+      return M.MaskBlend;
+    case "none":
+      return M.Opaque;
+    default:
+      return M.Blend;
+  }
+}
+function Fr(e) {
+  const t = e.params;
+  return { id: 1, material: t.material, texture: t.texture, region: t.texture };
+}
+const Ir = new Zt(1, 2, "wosr");
+async function Dr(e, t) {
+  var v;
+  const a = da(ma(e));
+  if (a.fileType === "wosr") {
+    const b = await (t.cache ? t.cache.loadWOSR(a.url, t) : Nr(a.url, t)), { engineResources: y, referenceBoundingBox: w } = Lr(b, t);
+    return { lods: y, referenceBoundingBox: w, isEsriSymbolResource: !1, isWosr: !0 };
+  }
+  const o = await (t.cache ? t.cache.loadGLTF(a.url, t, !!t.usePBR) : vo(new go(t.streamDataRequester), a.url, t, t.usePBR)), n = (v = o.model.meta) == null ? void 0 : v.ESRI_proxyEllipsoid, r = o.meta.isEsriSymbolResource && n != null && o.meta.ESRI_webstyle === "EsriRealisticTreesStyle";
+  r && !o.customMeta.esriTreeRendering && (o.customMeta.esriTreeRendering = !0, qr(o, n));
+  const c = !!t.usePBR, l = o.meta.isEsriSymbolResource ? { usePBR: c, isSchematic: !1, treeRendering: r, mrrFactors: [...Jo] } : { usePBR: c, isSchematic: !1, treeRendering: !1, mrrFactors: [...Xt] }, s = { ...t.materialParameters, treeRendering: r }, { engineResources: p, referenceBoundingBox: m } = ua(o, l, s, t.skipHighLods && a.specifiedLodIndex == null ? { skipHighLods: !0 } : { skipHighLods: !1, singleLodIndex: a.specifiedLodIndex });
+  return { lods: p, referenceBoundingBox: m, isEsriSymbolResource: o.meta.isEsriSymbolResource, isWosr: !1 };
+}
+function da(e) {
+  const t = e.match(/(.*\.(gltf|glb))(\?lod=([0-9]+))?$/);
+  return t ? { fileType: "gltf", url: t[1], specifiedLodIndex: t[4] != null ? Number(t[4]) : null } : e.match(/(.*\.(json|json\.gz))$/) ? { fileType: "wosr", url: e, specifiedLodIndex: null } : { fileType: "unknown", url: e, specifiedLodIndex: null };
+}
+function ua(e, t, a, o) {
+  const n = e.model, r = new Array(), c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), s = n.lods.length, p = Rt();
+  return n.lods.forEach((m, v) => {
+    const b = o.skipHighLods === !0 && (s > 1 && v === 0 || s > 3 && v === 1) || o.skipHighLods === !1 && o.singleLodIndex != null && v !== o.singleLodIndex;
+    if (b && v !== 0)
+      return;
+    const y = new Wo(m.name, m.lodThreshold, [0, 0, 0]);
+    m.parts.forEach((w) => {
+      const g = b ? new Ee({}) : Vr(n, w, y, t, a, c, l), { geometry: T, vertexCount: S } = Ur(w, g ?? new Ee({})), E = T.boundingInfo;
+      E != null && v === 0 && (Me(p, E.bbMin), Me(p, E.bbMax)), g != null && (y.stageResources.geometries.push(T), y.numberOfVertices += S);
+    }), b || r.push(y);
+  }), { engineResources: r, referenceBoundingBox: p };
+}
+function Vr(e, t, a, o, n, r, c) {
+  var y, w;
+  const l = t.material + (t.attributes.normal ? "_normal" : "") + (t.attributes.color ? "_color" : "") + (t.attributes.texCoord0 ? "_texCoord0" : "") + (t.attributes.tangent ? "_tangent" : ""), s = e.materials.get(t.material), p = t.attributes.texCoord0 != null, m = t.attributes.normal != null;
+  if (s == null)
+    return null;
+  const v = Wr(s.alphaMode);
+  if (!r.has(l)) {
+    if (p) {
+      const P = (A, pe = !1) => {
+        if (A != null && !c.has(A)) {
+          const oe = e.textures.get(A);
+          if (oe != null) {
+            const G = oe.data;
+            c.set(A, new qt(Ie(G) ? G.data : G, { ...oe.parameters, preMultiplyAlpha: !Ie(G) && pe, encoding: Ie(G) && G.encoding != null ? G.encoding : void 0 }));
+          }
+        }
+      };
+      P(s.textureColor, v !== M.Opaque), P(s.textureNormal), P(s.textureOcclusion), P(s.textureEmissive), P(s.textureMetallicRoughness);
+    }
+    const g = s.color[0] ** (1 / X), T = s.color[1] ** (1 / X), S = s.color[2] ** (1 / X), E = s.emissiveFactor[0] ** (1 / X), _ = s.emissiveFactor[1] ** (1 / X), B = s.emissiveFactor[2] ** (1 / X), F = s.textureColor != null && p ? c.get(s.textureColor) : null, ae = ko({ normalTexture: s.textureNormal, metallicRoughnessTexture: s.textureMetallicRoughness, metallicFactor: s.metallicFactor, roughnessFactor: s.roughnessFactor, emissiveTexture: s.textureEmissive, emissiveFactor: s.emissiveFactor, occlusionTexture: s.textureOcclusion }), me = ((y = s.normalTextureTransform) == null ? void 0 : y.scale) != null ? (w = s.normalTextureTransform) == null ? void 0 : w.scale : St;
+    r.set(l, new Ee({ ...o, transparent: v === M.Blend, customDepthTest: he.Lequal, textureAlphaMode: v, textureAlphaCutoff: s.alphaCutoff, diffuse: [g, T, S], ambient: [g, T, S], opacity: s.opacity, doubleSided: s.doubleSided, doubleSidedType: "winding-order", cullFace: s.doubleSided ? J.None : J.Back, hasVertexColors: !!t.attributes.color, hasVertexTangents: !!t.attributes.tangent, normalType: m ? R.Attribute : R.ScreenDerivative, castShadows: !0, receiveShadows: s.receiveShadows, receiveAmbientOcclusion: s.receiveAmbientOcclustion, textureId: F != null ? F.id : void 0, colorMixMode: s.colorMixMode, normalTextureId: s.textureNormal != null && p ? c.get(s.textureNormal).id : void 0, textureAlphaPremultiplied: F != null && !!F.parameters.preMultiplyAlpha, occlusionTextureId: s.textureOcclusion != null && p ? c.get(s.textureOcclusion).id : void 0, emissiveTextureId: s.textureEmissive != null && p ? c.get(s.textureEmissive).id : void 0, metallicRoughnessTextureId: s.textureMetallicRoughness != null && p ? c.get(s.textureMetallicRoughness).id : void 0, emissiveFactor: [E, _, B], mrrFactors: ae ? [...Yo] : [s.metallicFactor, s.roughnessFactor, o.mrrFactors[2]], isSchematic: ae, colorTextureTransformMatrix: ie(s.colorTextureTransform), normalTextureTransformMatrix: ie(s.normalTextureTransform), scale: [me[0], me[1]], occlusionTextureTransformMatrix: ie(s.occlusionTextureTransform), emissiveTextureTransformMatrix: ie(s.emissiveTextureTransform), metallicRoughnessTextureTransformMatrix: ie(s.metallicRoughnessTextureTransform), ...n }));
+  }
+  const b = r.get(l);
+  if (a.stageResources.materials.push(b), p) {
+    const g = (T) => {
+      T != null && a.stageResources.textures.push(c.get(T));
+    };
+    g(s.textureColor), g(s.textureNormal), g(s.textureOcclusion), g(s.textureEmissive), g(s.textureMetallicRoughness);
+  }
+  return b;
+}
+function Ur(e, t) {
+  const a = e.attributes.position.count, o = xo(e.indices || a, e.primitiveType), n = fe(3 * a), { typedBuffer: r, typedBufferStride: c } = e.attributes.position;
+  po(n, r, e.transform, 3, c);
+  const l = [[C.POSITION, new K(n, o, 3, !0)]];
+  if (e.attributes.normal != null) {
+    const s = fe(3 * a), { typedBuffer: p, typedBufferStride: m } = e.attributes.normal;
+    mt(ge, e.transform), fo(s, p, ge, 3, m), l.push([C.NORMAL, new K(s, o, 3, !0)]);
+  }
+  if (e.attributes.tangent != null) {
+    const s = fe(4 * a), { typedBuffer: p, typedBufferStride: m } = e.attributes.tangent;
+    mt(ge, e.transform), bo(s, p, ge, 4, m), l.push([C.TANGENT, new K(s, o, 4, !0)]);
+  }
+  if (e.attributes.texCoord0 != null) {
+    const s = fe(2 * a), { typedBuffer: p, typedBufferStride: m } = e.attributes.texCoord0;
+    yo(s, p, 2, m), l.push([C.UV0, new K(s, o, 2, !0)]);
+  }
+  if (e.attributes.color != null) {
+    const s = new Uint8Array(4 * a);
+    e.attributes.color.elementCount === 4 ? e.attributes.color instanceof co ? gt(s, e.attributes.color, 255) : e.attributes.color instanceof Yt ? To(s, e.attributes.color) : e.attributes.color instanceof uo && gt(s, e.attributes.color, 1 / 256) : (s.fill(255), e.attributes.color instanceof Jt ? vt(s, e.attributes.color, 255, 4) : e.attributes.color instanceof ho ? wo(s, e.attributes.color.typedBuffer, 4, e.attributes.color.typedBufferStride) : e.attributes.color instanceof mo && vt(s, e.attributes.color, 1 / 256, 4)), l.push([C.COLOR, new K(s, o, 4, !0)]);
+  }
+  return { geometry: new kt(t, l), vertexCount: a };
+}
+const ge = Nt();
+function Wr(e) {
+  switch (e) {
+    case "BLEND":
+      return M.Blend;
+    case "MASK":
+      return M.Mask;
+    case "OPAQUE":
+    case null:
+    case void 0:
+      return M.Opaque;
+  }
+}
+function qr(e, t) {
+  for (let a = 0; a < e.model.lods.length; ++a) {
+    const o = e.model.lods[a];
+    for (const n of o.parts) {
+      const r = n.attributes.normal;
+      if (r == null)
+        return;
+      const c = n.attributes.position, l = c.count, s = j(), p = j(), m = j(), v = new Uint8Array(4 * l), b = new Float64Array(3 * l), y = za(Ga(), n.transform);
+      let w = 0, g = 0;
+      for (let T = 0; T < l; T++) {
+        c.getVec(T, p), r.getVec(T, s), pt(p, p, n.transform), be(m, p, t.center), ft(m, m, t.radius);
+        const S = m[2], E = Et(m), _ = Math.min(0.45 + 0.55 * E * E, 1);
+        ft(m, m, t.radius), y !== null && pt(m, m, y), $t(m, m), a + 1 !== e.model.lods.length && e.model.lods.length > 1 && Pa(m, m, s, S > -1 ? 0.2 : Math.min(-4 * S - 3.8, 1)), b[w] = m[0], b[w + 1] = m[1], b[w + 2] = m[2], w += 3, v[g] = 255 * _, v[g + 1] = 255 * _, v[g + 2] = 255 * _, v[g + 3] = 255, g += 4;
+      }
+      n.attributes.normal = new Jt(b), n.attributes.color = new Yt(v);
+    }
+  }
+}
+const $i = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  fetch: Dr,
+  gltfToEngineResources: ua,
+  parseUrl: da
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  xr as H,
+  wr as I,
+  rt as d,
+  sr as f,
+  $i as o,
+  er as u
+};