@agrotools1/at-components 0.6.15 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/support/renderInfoUtils/polygon.js

@@ -0,0 +1,63 @@
+import { projectBuffer as w } from "../../../../geometry/projection/projectBuffer.js";
+import { newDoubleArray as C, doubleSubArray as p } from "../../../../geometry/support/DoubleArray.js";
+import { pathsToTriangulationInfo as u, CounterClockwiseMode as h } from "../../../../geometry/support/triangulationUtils.js";
+import { applyPerVertexElevationAlignment as P } from "../../layers/graphics/elevationAlignmentUtils.js";
+import { drapedZ as R } from "../../terrain/OverlayRenderer.js";
+function b(i, e, n, t) {
+  const o = u(i.rings, !!i.hasZ && t.mode !== "on-the-ground", h.CCW_IS_HOLE, i.spatialReference), s = C(o.position.length), r = P(o.position, i.spatialReference, 0, s, 0, o.position, 0, o.position.length / 3, e, n, t), a = r != null;
+  return new S(o.position, s, g(o.polygons, o.position, s), f(o.outlines, o.position, s), a, r);
+}
+function j(i, e) {
+  const n = u(i.rings, !1, h.CCW_IS_HOLE), t = w(n.position, i.spatialReference, 0, n.position, e, 0, n.position.length / 3);
+  for (let o = 2; o < n.position.length; o += 3)
+    n.position[o] = R;
+  return { position: n.position, polygons: g(n.polygons, n.position), outlines: f(n.outlines, n.position), projectionSuccess: t };
+}
+function f(i, e, n = null) {
+  return i.filter(({ count: t }) => t > 1).map(({ index: t, count: o }) => {
+    const s = 3 * t, r = 3 * o;
+    return n != null ? new d(t, o, p(e, s, r), p(n, s, r)) : new l(t, o, p(e, s, r));
+  });
+}
+function g(i, e, n = null) {
+  const t = new Array();
+  for (const { index: o, count: s, holeIndices: r, pathLengths: a } of i) {
+    if (s <= 1)
+      continue;
+    const m = 3 * o, y = 3 * s, c = r.map((I) => I - o), x = n != null ? new D(o, s, p(e, 3 * o, 3 * s), p(n, m, y), c, a) : new L(o, s, p(e, 3 * o, 3 * s), c, a);
+    t.push(x);
+  }
+  return t;
+}
+class l {
+  constructor(e, n, t) {
+    this.index = e, this.count = n, this.position = t;
+  }
+}
+class d extends l {
+  constructor(e, n, t, o) {
+    super(e, n, t), this.mapPositions = o;
+  }
+}
+class D extends d {
+  constructor(e, n, t, o, s, r) {
+    super(e, n, t, o), this.holeIndices = s, this.pathLengths = r;
+  }
+}
+class L extends l {
+  constructor(e, n, t, o, s) {
+    super(e, n, t), this.holeIndices = o, this.pathLengths = s;
+  }
+}
+class S {
+  constructor(e, n, t, o, s, r) {
+    this.position = e, this.mapPositions = n, this.polygons = t, this.outlines = o, this.projectionSuccess = s, this.sampledElevation = r;
+  }
+}
+export {
+  S as PolygonRenderInfo,
+  D as PolygonVertexData,
+  L as PolygonVertexDataDraped,
+  b as geometryToRenderInfo,
+  j as geometryToRenderInfoDraped
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js

@@ -1,29 +1,35 @@
 var h;
-function n(t) {
+function o(t) {
   return r(t) || t === h.Depth || t === h.LinearDepth || t === h.Normal || t === h.ObjectAndLayerIdColor;
 }
 function r(t) {
   return t === h.Shadow || t === h.ShadowHighlight || t === h.ShadowExcludeHighlight;
 }
-function o(t) {
-  return l(t) || t === h.Normal;
+function u(t) {
+  return n(t) || t === h.Normal;
 }
-function i(t) {
+function e(t) {
   return t === h.Highlight || t === h.ObjectAndLayerIdColor;
 }
-function u(t) {
-  return t === h.Color || i(t);
+function g(t) {
+  return t === h.Color || e(t);
 }
-function e(t) {
+function i(t) {
   return t === h.Color || t === h.Alpha;
 }
+function p(t) {
+  return i(t) || t === h.ObjectAndLayerIdColor;
+}
+function l(t) {
+  return i(t) || t === h.Highlight;
+}
 function d(t) {
-  return e(t) || t === h.ObjectAndLayerIdColor;
+  return l(t) || t === h.LinearDepth;
 }
 function a(t) {
-  return e(t) || i(t);
+  return i(t) || e(t);
 }
-function l(t) {
+function n(t) {
   return a(t) || t === h.LinearDepth;
 }
 (function(t) {
@@ -31,13 +37,15 @@ function l(t) {
 })(h || (h = {}));
 export {
   h as ShaderOutput,
-  u as is2DGeometryOutput,
-  o as is3DGeometryOutput,
-  l as isColorAlphaHighlightOIDOrDepth,
+  g as is2DGeometryOutput,
+  u as is3DGeometryOutput,
+  n as isColorAlphaHighlightOIDOrDepth,
+  d as isColorAlphaHighlightOrDepth,
   a as isColorAlphaHighlightOrOID,
-  d as isColorAlphaOrOID,
-  e as isColorOrAlpha,
-  n as isDepthLikeOutput,
-  i as isOIDorHighlight,
+  l as isColorAlphaOrHighlight,
+  p as isColorAlphaOrOID,
+  i as isColorOrAlpha,
+  o as isDepthLikeOutput,
+  e as isOIDorHighlight,
   r as isShadowRelatedOutput
 };

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js

@@ -0,0 +1,105 @@
+import { fromValues as p } from "../../../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { PositionAttribute as f } from "./PositionAttribute.glsl.js";
+import { Float2PassUniform as u } from "../../shaderModules/Float2PassUniform.js";
+import { Float3PassUniform as a } from "../../shaderModules/Float3PassUniform.js";
+import { Float4sPassUniform as m } from "../../shaderModules/Float4sPassUniform.js";
+import { FloatsPassUniform as s } from "../../shaderModules/FloatsPassUniform.js";
+import { glsl as r } from "../../shaderModules/interfaces.js";
+import { VertexAttribute as l } from "../../../lib/VertexAttribute.js";
+import { vvColorNumber as c, VisualVariablePassParameters as d } from "../../../materials/VisualVariablePassParameters.js";
+const n = 8;
+function N(i, v) {
+  const t = l.FEATUREVALUE;
+  i.attributes.add(t, "vec4");
+  const e = i.vertex;
+  e.code.add(r`
+  bool isCapVertex() {
+    return ${t}.w == 1.0;
+  }
+  `), e.uniforms.add(new u("size", (o) => o.size)), v.vvSize ? (e.uniforms.add(new a("vvSizeMinSize", (o) => o.vvSize.minSize), new a("vvSizeMaxSize", (o) => o.vvSize.maxSize), new a("vvSizeOffset", (o) => o.vvSize.offset), new a("vvSizeFactor", (o) => o.vvSize.factor)), e.code.add(r`
+    vec2 getSize() {
+      return size * clamp(vvSizeOffset + ${t}.x * vvSizeFactor, vvSizeMinSize, vvSizeMaxSize).xz;
+    }
+    `)) : e.code.add(r`vec2 getSize(){
+return size;
+}`), v.vvOpacity ? (e.constants.add("vvOpacityNumber", "int", n), e.uniforms.add(new s("vvOpacityValues", (o) => o.vvOpacity.values, n), new s("vvOpacityOpacities", (o) => o.vvOpacity.opacityValues, n)), e.code.add(r`
+    vec4 applyOpacity(vec4 color) {
+      float value = ${t}.z;
+      if (value <= vvOpacityValues[0]) {
+        return vec4( color.xyz, vvOpacityOpacities[0]);
+      }
+
+      for (int i = 1; i < vvOpacityNumber; ++i) {
+        if (vvOpacityValues[i] >= value) {
+          float f = (value - vvOpacityValues[i-1]) / (vvOpacityValues[i] - vvOpacityValues[i-1]);
+          return vec4( color.xyz, mix(vvOpacityOpacities[i-1], vvOpacityOpacities[i], f));
+        }
+      }
+
+      return vec4( color.xyz, vvOpacityOpacities[vvOpacityNumber - 1]);
+    }
+    `)) : e.code.add(r`vec4 applyOpacity(vec4 color){
+return color;
+}`), v.vvColor ? (e.constants.add("vvColorNumber", "int", c), e.uniforms.add(new s("vvColorValues", (o) => o.vvColor.values, c), new m("vvColorColors", (o) => o.vvColor.colors, c)), e.code.add(r`
+    vec4 getColor() {
+      float value = ${t}.y;
+      if (value <= vvColorValues[0]) {
+        return applyOpacity(vvColorColors[0]);
+      }
+
+      for (int i = 1; i < vvColorNumber; ++i) {
+        if (vvColorValues[i] >= value) {
+          float f = (value - vvColorValues[i-1]) / (vvColorValues[i] - vvColorValues[i-1]);
+          return applyOpacity(mix(vvColorColors[i-1], vvColorColors[i], f));
+        }
+      }
+
+      return applyOpacity(vvColorColors[vvColorNumber - 1]);
+    }
+    `)) : e.code.add(r`vec4 getColor(){
+return applyOpacity(vec4(1, 1, 1, 1));
+}`), i.include(f), i.attributes.add(l.PROFILERIGHT, "vec4"), i.attributes.add(l.PROFILEUP, "vec4"), i.attributes.add(l.PROFILEVERTEXANDNORMAL, "vec4"), e.code.add(r`vec3 calculateVPos() {
+vec2 size = getSize();
+vec3 origin = position;
+vec3 right = profileRight.xyz;
+vec3 up = profileUp.xyz;
+vec3 forward = cross(up, right);
+vec2 profileVertex = profileVertexAndNormal.xy * size;
+vec2 profileNormal = profileVertexAndNormal.zw;
+float positionOffsetAlongProfilePlaneNormal = 0.0;
+float normalOffsetAlongProfilePlaneNormal = 0.0;`), e.code.add(r`if(!isCapVertex()) {
+vec2 rotationRight = vec2(profileRight.w, profileUp.w);
+float maxDistance = length(rotationRight);`), e.code.add(r`rotationRight = maxDistance > 0.0 ? normalize(rotationRight) : vec2(0, 0);
+float rx = dot(profileVertex, rotationRight);
+if (abs(rx) > maxDistance) {
+vec2 rotationUp = vec2(-rotationRight.y, rotationRight.x);
+float ry = dot(profileVertex, rotationUp);
+profileVertex = rotationRight * maxDistance * sign(rx) + rotationUp * ry;
+}
+}else{
+positionOffsetAlongProfilePlaneNormal = profileRight.w * size[0];
+normalOffsetAlongProfilePlaneNormal = profileUp.w;
+}
+vec3 offset = right * profileVertex.x + up * profileVertex.y + forward * positionOffsetAlongProfilePlaneNormal;
+return origin + offset;
+}`), e.code.add(r`vec3 localNormal() {
+vec3 right = profileRight.xyz;
+vec3 up = profileUp.xyz;
+vec3 forward = cross(up, right);
+vec2 profileNormal = profileVertexAndNormal.zw;
+vec3 normal = right * profileNormal.x + up * profileNormal.y;
+if(isCapVertex()) {
+normal += forward * profileUp.w;
+}
+return normal;
+}`);
+}
+class S extends d {
+  constructor() {
+    super(...arguments), this.size = p(1, 1);
+  }
+}
+export {
+  N as PathVertexPosition,
+  S as PathVertexPositionPassParameters
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js

@@ -2,7 +2,7 @@ import { neverReached as l } from "../../../../../../core/compilerUtils.js";
 import { create as s } from "../../../../../../core/libs/gl-matrix-2/factories/mat3f64.js";
 import { create as t } from "../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
 import { NormalType as o, NormalAttribute as i } from "./NormalAttribute.glsl.js";
-import { VertexPositionDrawParameters as d, VertexPosition as n, VertexPositionPassParameters as c } from "./VertexPosition.glsl.js";
+import { VertexPosition as d, VertexPositionDrawParameters as n, VertexPositionPassParameters as c } from "./VertexPosition.glsl.js";
 import { glsl as e } from "../../shaderModules/interfaces.js";
 import { Matrix3DrawUniform as v } from "../../shaderModules/Matrix3DrawUniform.js";
 import { Matrix3PassUniform as f } from "../../shaderModules/Matrix3PassUniform.js";
@@ -16,7 +16,7 @@ vNormalView = transformNormalViewFromGlobal * vNormalWorld;
 }`);
       break;
     case o.Ground:
-      r.include(n, a), r.varyings.add("vNormalWorld", "vec3"), r.vertex.code.add(e`
+      r.include(d, a), r.varyings.add("vNormalWorld", "vec3"), r.vertex.code.add(e`
         void forwardNormal() {
           vNormalWorld = ${a.spherical ? e`normalize(vPositionWorldCameraRelative);` : e`vec3(0.0, 0.0, 1.0);`}
         }
@@ -35,7 +35,7 @@ class G extends c {
     super(...arguments), this.transformNormalViewFromGlobal = s();
   }
 }
-class M extends d {
+class M extends n {
   constructor() {
     super(...arguments), this.transformNormalGlobalFromModel = s(), this.toMapSpace = t();
   }

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js

@@ -5,7 +5,7 @@ import { PositionAttribute as f } from "./PositionAttribute.glsl.js";
 import { DoublePrecision as v } from "../util/DoublePrecision.glsl.js";
 import { Float3DrawUniform as s } from "../../shaderModules/Float3DrawUniform.js";
 import { Float3PassUniform as i } from "../../shaderModules/Float3PassUniform.js";
-import { NoParameters as d, glsl as e } from "../../shaderModules/interfaces.js";
+import { glsl as e, NoParameters as d } from "../../shaderModules/interfaces.js";
 import { Matrix3DrawUniform as F } from "../../shaderModules/Matrix3DrawUniform.js";
 import { Matrix3PassUniform as W } from "../../shaderModules/Matrix3PassUniform.js";
 import { Matrix4PassUniform as w } from "../../shaderModules/Matrix4PassUniform.js";

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/FoamRendering.glsl.js

@@ -0,0 +1,16 @@
+import { glsl as t } from "../../shaderModules/interfaces.js";
+function a(o) {
+  o.fragment.code.add(t`float normals2FoamIntensity(vec3 n, float waveStrength){
+float normalizationFactor =  max(0.015, waveStrength);
+return max((n.x + n.y)*0.3303545/normalizationFactor + 0.3303545, 0.0);
+}`);
+}
+function e(o) {
+  o.fragment.code.add(t`vec3 foamIntensity2FoamColor(float foamIntensityExternal, float foamPixelIntensity, vec3 skyZenitColor, float dayMod){
+return foamIntensityExternal * (0.075 * skyZenitColor * pow(foamPixelIntensity, 4.) +  50.* pow(foamPixelIntensity, 23.0)) * dayMod;
+}`);
+}
+export {
+  e as FoamColor,
+  a as FoamIntensity
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js

@@ -0,0 +1,14 @@
+import { glsl as e } from "../../shaderModules/interfaces.js";
+function r(o) {
+  o.fragment.code.add(e`const float GAMMA = 2.2;
+const float INV_GAMMA = 0.4545454545;
+vec4 delinearizeGamma(vec4 color) {
+return vec4(pow(color.rgb, vec3(INV_GAMMA)), color.w);
+}
+vec3 linearizeGamma(vec3 color) {
+return pow(color, vec3(GAMMA));
+}`);
+}
+export {
+  r as Gamma
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js

@@ -0,0 +1,19 @@
+import { glsl as r } from "../../shaderModules/interfaces.js";
+function n(e, t) {
+  t.spherical ? e.vertex.code.add(r`vec3 getLocalUp(in vec3 pos, in vec3 origin) {
+return normalize(pos + origin);
+}`) : e.vertex.code.add(r`vec3 getLocalUp(in vec3 pos, in vec3 origin) {
+return vec3(0.0, 0.0, 1.0);
+}`), t.spherical ? e.vertex.code.add(r`mat3 getTBNMatrix(in vec3 n) {
+vec3 t = normalize(cross(vec3(0.0, 0.0, 1.0), n));
+vec3 b = normalize(cross(n, t));
+return mat3(t, b, n);
+}`) : e.vertex.code.add(r`mat3 getTBNMatrix(in vec3 n) {
+vec3 t = vec3(1.0, 0.0, 0.0);
+vec3 b = normalize(cross(n, t));
+return mat3(t, b, n);
+}`);
+}
+export {
+  n as NormalUtils
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js

@@ -1,22 +1,22 @@
-import { AnalyticalSkyModel as r } from "./AnalyticalSkyModel.glsl.js";
-import { PBRMode as a } from "./PhysicallyBasedRenderingParameters.glsl.js";
-import { PiUtils as i } from "./PiUtils.glsl.js";
-import { glsl as t } from "../../shaderModules/interfaces.js";
-function s(n, e) {
-  const o = n.fragment.code;
-  n.include(i), e.pbrMode !== a.Normal && e.pbrMode !== a.Schematic && e.pbrMode !== a.Simplified && e.pbrMode !== a.TerrainWithWater || (o.add(t`float normalDistribution(float NdotH, float roughness)
+import { AnalyticalSkyModel as l } from "./AnalyticalSkyModel.glsl.js";
+import { PBRMode as n } from "./PhysicallyBasedRenderingParameters.glsl.js";
+import { PiUtils as r } from "./PiUtils.glsl.js";
+import { glsl as o } from "../../shaderModules/interfaces.js";
+function f(a, t) {
+  const e = a.fragment.code;
+  a.include(r), t.pbrMode !== n.Normal && t.pbrMode !== n.Schematic && t.pbrMode !== n.Simplified && t.pbrMode !== n.TerrainWithWater || (e.add(o`float normalDistribution(float NdotH, float roughness)
 {
 float a = NdotH * roughness;
 float b = roughness / (1.0 - NdotH * NdotH + a * a);
 return b * b * INV_PI;
-}`), o.add(t`const vec4 c0 = vec4(-1.0, -0.0275, -0.572,  0.022);
+}`), e.add(o`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;
-}`)), e.pbrMode !== a.Normal && e.pbrMode !== a.Schematic || (n.include(r), o.add(t`struct PBRShadingInfo
+}`)), t.pbrMode !== n.Normal && t.pbrMode !== n.Schematic || (a.include(l), e.add(o`struct PBRShadingInfo
 {
 float NdotL;
 float NdotV;
@@ -39,7 +39,7 @@ vec3 f90;
 vec3 diffuseColor;
 float metalness;
 float roughness;
-};`), o.add(t`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
+};`), e.add(o`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;
@@ -47,9 +47,9 @@ vec2 dfg = prefilteredDFGAnalytical(inputs.roughness, inputs.NdotV);
 vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
 vec3 specularComponent = specularColor * indirectSpecular;
 return (diffuseComponent + specularComponent);
-}`), o.add(t`float gamutMapChanel(float x, vec2 p){
+}`), e.add(o`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) );
-}`), o.add(t`vec3 blackLevelSoftCompression(vec3 inColor, PBRShadingInfo inputs){
+}`), e.add(o`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) ;
@@ -58,6 +58,46 @@ outColor.z = gamutMapChanel(inColor.z, p) ;
 return outColor;
 }`));
 }
+function u(a, t) {
+  const e = a.fragment.code;
+  a.include(r), e.add(o`
+  struct PBRShadingWater
+  {
+      float NdotL;   // cos angle between normal and light direction
+      float NdotV;   // cos angle between normal and view direction
+      float NdotH;   // cos angle between normal and half vector
+      float VdotH;   // cos angle between view direction and half vector
+      float LdotH;   // cos angle between light direction and half vector
+      float VdotN;   // cos angle between view direction and normal vector
+  };
+
+  float dtrExponent = ${t.useCustomDTRExponentForWater ? "2.2" : "2.0"};
+  `), e.add(o`vec3 fresnelReflection(float angle, vec3 f0, float f90) {
+return f0 + (f90 - f0) * pow(1.0 - angle, 5.0);
+}`), e.add(o`float normalDistributionWater(float NdotH, float roughness)
+{
+float r2 = roughness * roughness;
+float NdotH2 = NdotH * NdotH;
+float denom = pow((NdotH2 * (r2 - 1.0) + 1.0), dtrExponent) * PI;
+return r2 / denom;
+}`), e.add(o`float geometricOcclusionKelemen(float LoH)
+{
+return 0.25 / (LoH * LoH);
+}`), e.add(o`vec3 brdfSpecularWater(in PBRShadingWater props, float roughness, vec3 F0, float F0Max)
+{
+vec3  F = fresnelReflection(props.VdotH, F0, F0Max);
+float dSun = normalDistributionWater(props.NdotH, roughness);
+float V = geometricOcclusionKelemen(props.LdotH);
+float diffusionSunHaze = mix(roughness + 0.045, roughness + 0.385, 1.0 - props.VdotH);
+float strengthSunHaze  = 1.2;
+float dSunHaze = normalDistributionWater(props.NdotH, diffusionSunHaze)*strengthSunHaze;
+return ((dSun + dSunHaze) * V) * F;
+}
+vec3 tonemapACES(const vec3 x) {
+return (x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14);
+}`);
+}
 export {
-  s as PhysicallyBasedRendering
+  f as PhysicallyBasedRendering,
+  u as PhysicallyBasedRenderingWater
 };

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceReflections.glsl.js

@@ -0,0 +1,123 @@
+import { ReadLinearDepth as n } from "../output/ReadDepth.glsl.js";
+import { Float2PassUniform as c } from "../../shaderModules/Float2PassUniform.js";
+import { FloatPassUniform as p } from "../../shaderModules/FloatPassUniform.js";
+import { glsl as s } from "../../shaderModules/interfaces.js";
+import { Matrix4PassUniform as a } from "../../shaderModules/Matrix4PassUniform.js";
+import { Texture2DPassUniform as f } from "../../shaderModules/Texture2DPassUniform.js";
+function P(i, d) {
+  const o = i.fragment;
+  o.include(n), o.uniforms.add(new c("nearFar", (t, e) => e.camera.nearFar)), o.uniforms.add(new f("depthMap", (t, e) => {
+    var r;
+    return (r = e.linearDepth) == null ? void 0 : r.getTexture();
+  })), o.uniforms.add(new a("proj", (t, e) => e.camera.projectionMatrix)), o.uniforms.add(new p("invResolutionHeight", (t, e) => 1 / e.camera.height)), o.uniforms.add(new a("reprojectionMatrix", (t, e) => e.ssr.reprojectionMatrix)), o.code.add(s`
+  vec2 reprojectionCoordinate(vec3 projectionCoordinate)
+  {
+    vec4 zw = proj * vec4(0.0, 0.0, -projectionCoordinate.z, 1.0);
+    vec4 reprojectedCoord = reprojectionMatrix * vec4(zw.w * (projectionCoordinate.xy * 2.0 - 1.0), zw.z, zw.w);
+    reprojectedCoord.xy /= reprojectedCoord.w;
+    return reprojectedCoord.xy * 0.5 + 0.5;
+  }
+
+  const int maxSteps = ${d.highStepCount ? "150" : "75"};
+
+  vec4 applyProjectionMat(mat4 projectionMat, vec3 x)
+  {
+    vec4 projectedCoord =  projectionMat * vec4(x, 1.0);
+    projectedCoord.xy /= projectedCoord.w;
+    projectedCoord.xy = projectedCoord.xy*0.5 + 0.5;
+    return projectedCoord;
+  }
+
+  vec3 screenSpaceIntersection(vec3 dir, vec3 startPosition, vec3 viewDir, vec3 normal)
+  {
+    vec3 viewPos = startPosition;
+    vec3 viewPosEnd = startPosition;
+
+    // Project the start position to the screen
+    vec4 projectedCoordStart = applyProjectionMat(proj, viewPos);
+    vec3  Q0 = viewPos / projectedCoordStart.w; // homogeneous camera space
+    float k0 = 1.0/ projectedCoordStart.w;
+
+    // advance the position in the direction of the reflection
+    viewPos += dir;
+
+    vec4 projectedCoordVanishingPoint = applyProjectionMat(proj, dir);
+
+    // Project the advanced position to the screen
+    vec4 projectedCoordEnd = applyProjectionMat(proj, viewPos);
+    vec3  Q1 = viewPos / projectedCoordEnd.w; // homogeneous camera space
+    float k1 = 1.0/ projectedCoordEnd.w;
+
+    // calculate the reflection direction in the screen space
+    vec2 projectedCoordDir = (projectedCoordEnd.xy - projectedCoordStart.xy);
+    vec2 projectedCoordDistVanishingPoint = (projectedCoordVanishingPoint.xy - projectedCoordStart.xy);
+
+    float yMod = min(abs(projectedCoordDistVanishingPoint.y), 1.0);
+
+    float projectedCoordDirLength = length(projectedCoordDir);
+    float maxSt = float(maxSteps);
+
+    // normalize the projection direction depending on maximum steps
+    // this determines how blocky the reflection looks
+    vec2 dP = yMod * (projectedCoordDir)/(maxSt * projectedCoordDirLength);
+
+    // Normalize the homogeneous camera space coordinates
+    vec3  dQ = yMod * (Q1 - Q0)/(maxSt * projectedCoordDirLength);
+    float dk = yMod * (k1 - k0)/(maxSt * projectedCoordDirLength);
+
+    // initialize the variables for ray marching
+    vec2 P = projectedCoordStart.xy;
+    vec3 Q = Q0;
+    float k = k0;
+    float rayStartZ = -startPosition.z; // estimated ray start depth value
+    float rayEndZ = -startPosition.z;   // estimated ray end depth value
+    float prevEstimateZ = -startPosition.z;
+    float rayDiffZ = 0.0;
+    float dDepth;
+    float depth;
+    float rayDiffZOld = 0.0;
+
+    // early outs
+    if (dot(normal, dir) < 0.0 || dot(-viewDir, normal) < 0.0)
+      return vec3(P, 0.0);
+
+    for(int i = 0; i < maxSteps-1; i++)
+    {
+      depth = -linearDepthFromTexture(depthMap, P, nearFar); // get linear depth from the depth buffer
+
+      // estimate depth of the marching ray
+      rayStartZ = prevEstimateZ;
+      dDepth = -rayStartZ - depth;
+      rayEndZ = (dQ.z * 0.5 + Q.z)/ ((dk * 0.5 + k));
+      rayDiffZ = rayEndZ- rayStartZ;
+      prevEstimateZ = rayEndZ;
+
+      if(-rayEndZ > nearFar[1] || -rayEndZ < nearFar[0] || P.y < 0.0  || P.y > 1.0 )
+      {
+        return vec3(P, 0.);
+      }
+
+      // If we detect a hit - return the intersection point, two conditions:
+      //  - dDepth > 0.0 - sampled point depth is in front of estimated depth
+      //  - if difference between dDepth and rayDiffZOld is not too large
+      //  - if difference between dDepth and 0.025/abs(k) is not too large
+      //  - if the sampled depth is not behind far plane or in front of near plane
+
+      if((dDepth) < 0.025/abs(k) + abs(rayDiffZ) && dDepth > 0.0 && depth > nearFar[0] && depth < nearFar[1] && abs(P.y - projectedCoordStart.y) > invResolutionHeight)
+      {
+        return vec3(P, depth);
+      }
+
+      // continue with ray marching
+      P = clamp(P + dP, vec2(0.0), vec2(0.999));
+      Q.z += dQ.z;
+      k += dk;
+      rayDiffZOld = rayDiffZ;
+    }
+    return vec3(P, 0.0);
+  }
+  `);
+}
+export {
+  P as ScreenSpaceReflections
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/Water.glsl.js

@@ -0,0 +1,85 @@
+import { FoamColor as d } from "./FoamRendering.glsl.js";
+import { Gamma as c } from "./Gamma.glsl.js";
+import { PhysicallyBasedRenderingWater as s } from "./PhysicallyBasedRendering.glsl.js";
+import { distanceFadeStart as f, distanceFadeEnd as m } from "./ScreenSpaceConstants.js";
+import { ScreenSpaceReflections as v } from "./ScreenSpaceReflections.glsl.js";
+import { CloudsParallaxShading as h } from "../util/CloudsParallaxShading.glsl.js";
+import { FloatPassUniform as n } from "../../shaderModules/FloatPassUniform.js";
+import { glsl as t } from "../../shaderModules/interfaces.js";
+import { Matrix4PassUniform as p } from "../../shaderModules/Matrix4PassUniform.js";
+import { Texture2DPassUniform as u } from "../../shaderModules/Texture2DPassUniform.js";
+function k(a, o) {
+  a.include(s, o), a.include(c), a.include(d), o.hasCloudsReflections && a.include(h, o), o.hasScreenSpaceReflections && a.include(v, o);
+  const e = a.fragment;
+  e.constants.add("fresnelSky", "vec3", [0.02, 1, 15]).add("fresnelMaterial", "vec2", [0.02, 0.1]).add("roughness", "float", 0.015).add("foamIntensityExternal", "float", 1.7).add("ssrIntensity", "float", 0.65).add("ssrHeightFadeStart", "float", f).add("ssrHeightFadeEnd", "float", m).add("waterDiffusion", "float", 0.92).add("waterSeaColorMod", "float", 0.8).add("correctionViewingPowerFactor", "float", 0.4).add("skyZenitColor", "vec3", [0.52, 0.68, 0.9]).add("skyColor", "vec3", [0.67, 0.79, 0.9]).add("cloudFresnelModifier", "vec2", [1.2, 0.01]), e.code.add(t`PBRShadingWater shadingInfo;
+vec3 getSkyGradientColor(in float cosTheta, in vec3 horizon, in vec3 zenit) {
+float exponent = pow((1.0 - cosTheta), fresnelSky[2]);
+return mix(zenit, horizon, exponent);
+}`), e.uniforms.add(new n("lightingSpecularStrength", (i, r) => r.lighting.mainLight.specularStrength), new n("lightingEnvironmentStrength", (i, r) => r.lighting.mainLight.environmentStrength)), e.code.add(t`vec3 getSeaColor(in vec3 n, in vec3 v, in vec3 l, vec3 color, in vec3 lightIntensity, in vec3 localUp, in float shadow, float foamIntensity, vec3 viewPosition, vec3 position) {
+float reflectionHit = 0.0;
+float reflectionHitDiffused = 0.0;
+vec3 seaWaterColor = linearizeGamma(color);
+vec3 h = normalize(l + v);
+shadingInfo.NdotL = clamp(dot(n, l), 0.0, 1.0);
+shadingInfo.NdotV = clamp(dot(n, v), 0.001, 1.0);
+shadingInfo.VdotN = clamp(dot(v, n), 0.001, 1.0);
+shadingInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+shadingInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+shadingInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+float upDotV = max(dot(localUp,v), 0.0);
+vec3 skyHorizon = linearizeGamma(skyColor);
+vec3 skyZenit = linearizeGamma(skyZenitColor);
+vec3 skyColor = getSkyGradientColor(upDotV, skyHorizon, skyZenit );
+float upDotL = max(dot(localUp,l),0.0);
+float daytimeMod = 0.1 + upDotL * 0.9;
+skyColor *= daytimeMod;
+float shadowModifier = clamp(shadow, 0.8, 1.0);
+vec3 fresnelModifier = fresnelReflection(shadingInfo.VdotN, vec3(fresnelSky[0]), fresnelSky[1]);
+vec3 reflSky = lightingEnvironmentStrength * fresnelModifier * skyColor * shadowModifier;
+vec3 reflSea = seaWaterColor * mix(skyColor, upDotL * lightIntensity * LIGHT_NORMALIZATION, 2.0 / 3.0) * shadowModifier;
+vec3 specular = vec3(0.0);
+if(upDotV > 0.0 && upDotL > 0.0) {
+vec3 specularSun = brdfSpecularWater(shadingInfo, roughness, vec3(fresnelMaterial[0]), fresnelMaterial[1]);
+vec3 incidentLight = lightIntensity * LIGHT_NORMALIZATION * shadow;
+specular = lightingSpecularStrength * shadingInfo.NdotL * incidentLight * specularSun;
+}
+vec3 foam = vec3(0.0);
+if(upDotV > 0.0) {
+foam = foamIntensity2FoamColor(foamIntensityExternal, foamIntensity, skyZenitColor, daytimeMod);
+}
+float correctionViewingFactor = pow(max(dot(v, localUp), 0.0), correctionViewingPowerFactor);
+vec3 normalCorrectedClouds = mix(localUp, n, correctionViewingFactor);
+vec3 reflectedWorld = normalize(reflect(-v, normalCorrectedClouds));`), o.hasCloudsReflections && e.code.add(t`vec4 cloudsColor = renderClouds(reflectedWorld, position);
+cloudsColor.a = 1.0 - cloudsColor.a;
+cloudsColor = pow(cloudsColor, vec4(GAMMA));
+cloudsColor *= clamp(fresnelModifier.y * cloudFresnelModifier[0] - cloudFresnelModifier[1], 0.0, 1.0) * clamp((1.0 - totalFadeInOut), 0.0, 1.0);`), o.hasScreenSpaceReflections ? (e.uniforms.add(new p("view", (i, r) => r.camera.viewMatrix), new u("lastFrameColorTexture", (i, r) => {
+    var l;
+    return (l = r.ssr.lastFrameColor) == null ? void 0 : l.getTexture();
+  }), new n("fadeFactorSSR", (i, r) => r.ssr.fadeFactor)), e.code.add(t`vec3 viewDir = normalize(viewPosition);
+vec4 viewNormalVectorCoordinate = view *vec4(n, 0.0);
+vec3 viewNormal = normalize(viewNormalVectorCoordinate.xyz);
+vec4 viewUp = view * vec4(localUp, 0.0);
+vec3 viewNormalCorrectedSSR = mix(viewUp.xyz, viewNormal, correctionViewingFactor);
+vec3 reflected = normalize(reflect(viewDir, viewNormalCorrectedSSR));
+vec3 hitCoordinate = screenSpaceIntersection(reflected, viewPosition, viewDir, viewUp.xyz);
+vec3 reflectedColor = vec3(0.0);
+if (hitCoordinate.z > 0.0)
+{
+vec2 reprojectedCoordinate = reprojectionCoordinate(hitCoordinate);
+vec2 dCoords = smoothstep(0.3, 0.6, abs(vec2(0.5, 0.5) - hitCoordinate.xy));
+float heightMod = smoothstep(ssrHeightFadeEnd, ssrHeightFadeStart, -viewPosition.z);
+reflectionHit = clamp(1.0 - (1.3 * dCoords.y), 0.0, 1.0) * heightMod * fadeFactorSSR;
+reflectionHitDiffused = waterDiffusion * reflectionHit;
+reflectedColor = linearizeGamma(texture(lastFrameColorTexture, reprojectedCoordinate).xyz) *
+reflectionHitDiffused * fresnelModifier.y * ssrIntensity;
+}
+float seaColorMod =  mix(waterSeaColorMod, waterSeaColorMod * 0.5, reflectionHitDiffused);
+vec3 waterRenderedColor = tonemapACES((1.0 - reflectionHitDiffused) * reflSky + reflectedColor +
+reflSea * seaColorMod + specular + foam);`)) : e.code.add(t`vec3 waterRenderedColor = tonemapACES(reflSky + reflSea * waterSeaColorMod + specular + foam);`), o.hasCloudsReflections ? o.hasScreenSpaceReflections ? e.code.add(t`return waterRenderedColor * (1.0 - (1.0 - reflectionHit) * cloudsColor.a) + (1.0 - reflectionHit) * cloudsColor.xyz;
+}`) : e.code.add(t`return waterRenderedColor * (1.0 - cloudsColor.a) + cloudsColor.xyz;
+}`) : e.code.add(t`return waterRenderedColor;
+}`);
+}
+export {
+  k as Water
+};