@agrotools1/at-components 0.6.0 → 0.6.3

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

@@ -1,128 +0,0 @@
-import { addVerticalOffset as f } from "../attributes/VerticalOffset.glsl.js";
-import { ScreenSizePerspective as l, addScreenSizePerspectiveAlignment as c } from "../util/ScreenSizePerspective.glsl.js";
-import { addProjViewLocalOrigin as p, addCameraPosition as d, addViewNormal as v, addPixelRatio as m } from "../util/View.glsl.js";
-import { Float4PassUniform as u } from "../../shaderModules/Float4PassUniform.js";
-import { FloatPassUniform as n } from "../../shaderModules/FloatPassUniform.js";
-import { glsl as a } from "../../shaderModules/interfaces.js";
-import { VertexAttribute as r } from "../../../lib/VertexAttribute.js";
-const O = 0.5;
-function y(s, e) {
-  s.include(l), s.attributes.add(r.POSITION, "vec3"), s.attributes.add(r.NORMAL, "vec3"), s.attributes.add(r.CENTEROFFSETANDDISTANCE, "vec4");
-  const t = s.vertex;
-  p(t, e), d(t, e), t.uniforms.add(new u("viewport", (i, o) => o.camera.fullViewport), new n("polygonOffset", (i) => i.shaderPolygonOffset), new n("cameraGroundRelative", (i, o) => o.camera.aboveGround ? 1 : -1)), e.hasVerticalOffset && f(t), t.constants.add("smallOffsetAngle", "float", 0.984807753012208), t.code.add(a`struct ProjectHUDAux {
-vec3 posModel;
-vec3 posView;
-vec3 vnormal;
-float distanceToCamera;
-float absCosAngle;
-};`), t.code.add(a`
-    float applyHUDViewDependentPolygonOffset(float pointGroundDistance, float absCosAngle, inout vec3 posView) {
-      float pointGroundSign = ${e.multipassEnabled ? a.float(0) : a`sign(pointGroundDistance)`};
-      if (pointGroundSign == 0.0) {
-        pointGroundSign = cameraGroundRelative;
-      }
-
-      // cameraGroundRelative is -1 if camera is below ground, 1 if above ground
-      // groundRelative is 1 if both camera and symbol are on the same side of the ground, -1 otherwise
-      float groundRelative = cameraGroundRelative * pointGroundSign;
-
-      // view angle dependent part of polygon offset emulation: we take the absolute value because the sign that is
-      // dropped is instead introduced using the ground-relative position of the symbol and the camera
-      if (polygonOffset > .0) {
-        float cosAlpha = clamp(absCosAngle, 0.01, 1.0);
-        float tanAlpha = sqrt(1.0 - cosAlpha * cosAlpha) / cosAlpha;
-        float factor = (1.0 - tanAlpha / viewport[2]);
-
-        // same side of the terrain
-        if (groundRelative > 0.0) {
-          posView *= factor;
-        }
-        // opposite sides of the terrain
-        else {
-          posView /= factor;
-        }
-      }
-
-      return groundRelative;
-    }
-  `), e.draped && !e.hasVerticalOffset || v(t), e.draped || (t.uniforms.add(new n("perDistancePixelRatio", (i, o) => Math.tan(o.camera.fovY / 2) / (o.camera.fullViewport[2] / 2))), t.code.add(a`
-    void applyHUDVerticalGroundOffset(vec3 normalModel, inout vec3 posModel, inout vec3 posView) {
-      float distanceToCamera = length(posView);
-
-      // Compute offset in world units for a half pixel shift
-      float pixelOffset = distanceToCamera * perDistancePixelRatio * ${a.float(O)};
-
-      // Apply offset along normal in the direction away from the ground surface
-      vec3 modelOffset = normalModel * cameraGroundRelative * pixelOffset;
-
-      // Apply the same offset also on the view space position
-      vec3 viewOffset = (viewNormal * vec4(modelOffset, 1.0)).xyz;
-
-      posModel += modelOffset;
-      posView += viewOffset;
-    }
-  `)), e.screenCenterOffsetUnitsEnabled && m(t), e.hasScreenSizePerspective && c(t), t.code.add(a`
-    vec4 projectPositionHUD(out ProjectHUDAux aux) {
-      vec3 centerOffset = centerOffsetAndDistance.xyz;
-      float pointGroundDistance = centerOffsetAndDistance.w;
-
-      aux.posModel = position;
-      aux.posView = (view * vec4(aux.posModel, 1.0)).xyz;
-      aux.vnormal = normal;
-      ${e.draped ? "" : "applyHUDVerticalGroundOffset(aux.vnormal, aux.posModel, aux.posView);"}
-
-      // Screen sized offset in world space, used for example for line callouts
-      // Note: keep this implementation in sync with the CPU implementation, see
-      //   - MaterialUtil.verticalOffsetAtDistance
-      //   - HUDMaterial.applyVerticalOffsetTransformation
-
-      aux.distanceToCamera = length(aux.posView);
-
-      vec3 viewDirObjSpace = normalize(cameraPosition - aux.posModel);
-      float cosAngle = dot(aux.vnormal, viewDirObjSpace);
-
-      aux.absCosAngle = abs(cosAngle);
-
-      ${e.hasScreenSizePerspective && (e.hasVerticalOffset || e.screenCenterOffsetUnitsEnabled) ? "vec3 perspectiveFactor = screenSizePerspectiveScaleFactor(aux.absCosAngle, aux.distanceToCamera, screenSizePerspectiveAlignment);" : ""}
-
-      ${e.hasVerticalOffset ? e.hasScreenSizePerspective ? "float verticalOffsetScreenHeight = applyScreenSizePerspectiveScaleFactorFloat(verticalOffset.x, perspectiveFactor);" : "float verticalOffsetScreenHeight = verticalOffset.x;" : ""}
-
-      ${e.hasVerticalOffset ? a`
-            float worldOffset = clamp(verticalOffsetScreenHeight * verticalOffset.y * aux.distanceToCamera, verticalOffset.z, verticalOffset.w);
-            vec3 modelOffset = aux.vnormal * worldOffset;
-            aux.posModel += modelOffset;
-            vec3 viewOffset = (viewNormal * vec4(modelOffset, 1.0)).xyz;
-            aux.posView += viewOffset;
-            // Since we elevate the object, we need to take that into account
-            // in the distance to ground
-            pointGroundDistance += worldOffset;` : ""}
-
-      float groundRelative = applyHUDViewDependentPolygonOffset(pointGroundDistance, aux.absCosAngle, aux.posView);
-
-      ${e.screenCenterOffsetUnitsEnabled ? "" : a`
-            // Apply x/y in view space, but z in screen space (i.e. along posView direction)
-            aux.posView += vec3(centerOffset.x, centerOffset.y, 0.0);
-
-            // Same material all have same z != 0.0 condition so should not lead to
-            // branch fragmentation and will save a normalization if it's not needed
-            if (centerOffset.z != 0.0) {
-              aux.posView -= normalize(aux.posView) * centerOffset.z;
-            }
-          `}
-
-      vec4 posProj = proj * vec4(aux.posView, 1.0);
-
-      ${e.screenCenterOffsetUnitsEnabled ? e.hasScreenSizePerspective ? "float centerOffsetY = applyScreenSizePerspectiveScaleFactorFloat(centerOffset.y, perspectiveFactor);" : "float centerOffsetY = centerOffset.y;" : ""}
-
-      ${e.screenCenterOffsetUnitsEnabled ? "posProj.xy += vec2(centerOffset.x, centerOffsetY) * pixelRatio * 2.0 / viewport.zw * posProj.w;" : ""}
-
-      // constant part of polygon offset emulation
-      posProj.z -= groundRelative * polygonOffset * posProj.w;
-      return posProj;
-    }
-  `);
-}
-export {
-  y as HUD,
-  O as HUDVerticalPixelOffset
-};

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

@@ -1,49 +0,0 @@
-import { AlignPixel as p } from "./AlignPixel.glsl.js";
-import { multipassGeometryTest as s } from "../shading/MultipassGeometryTest.glsl.js";
-import { multipassTerrainTest as n } from "../shading/MultipassTerrainTest.glsl.js";
-import { glsl as o } from "../../shaderModules/interfaces.js";
-function m(t, e) {
-  const { vertex: r, fragment: i } = t;
-  r.include(p), e.multipassEnabled && (r.include(s), t.varyings.add("depth", "float")), r.code.add(o`
-  void main(void) {
-    vec4 posProjCenter;
-    if (dot(position, position) > 0.0) {
-      // Render single point to center of the pixel to avoid subpixel filtering to affect the marker color
-      ProjectHUDAux projectAux;
-      vec4 posProj = projectPositionHUD(projectAux);
-      posProjCenter = alignToPixelCenter(posProj, viewport.zw);
-
-      ${e.multipassEnabled ? o`
-        // Don't draw vertices behind geometry
-        if(geometryDepthTest(.5 + .5 * posProjCenter.xy / posProjCenter.w, projectAux.posView.z)){
-          posProjCenter = vec4(1e038, 1e038, 1e038, 1.0);
-        }` : ""}
-
-      ${e.multipassEnabled ? "depth = projectAux.posView.z;" : ""}
-      vec3 vpos = projectAux.posModel;
-      if (rejectBySlice(vpos)) {
-        // Project out of clip space
-        posProjCenter = vec4(1e038, 1e038, 1e038, 1.0);
-      }
-
-    } else {
-      // Project out of clip space
-      posProjCenter = vec4(1e038, 1e038, 1e038, 1.0);
-    }
-
-    gl_Position = posProjCenter;
-    gl_PointSize = 1.0;
-  }
-  `), t.include(n, e), i.code.add(o`
-  void main() {
-    fragColor = vec4(1);
-    ${e.multipassEnabled ? o`
-        if(terrainDepthTest(depth)) {
-          fragColor.g = 0.5;
-        }` : ""}
-  }
-  `);
-}
-export {
-  m as HUDOcclusionPass
-};

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

@@ -1,7 +0,0 @@
-var e;
-(function(d) {
-  d[d.Occluded = 0] = "Occluded", d[d.NotOccluded = 1] = "NotOccluded", d[d.Both = 2] = "Both", d[d.COUNT = 3] = "COUNT";
-})(e || (e = {}));
-export {
-  e as HUDRenderStyle
-};

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

@@ -1,22 +0,0 @@
-import { AlignPixel as t } from "./AlignPixel.glsl.js";
-import { HUDRenderStyle as l } from "./HUDRenderStyle.js";
-import { Float4PassUniform as n } from "../../shaderModules/Float4PassUniform.js";
-import { FloatPassUniform as s } from "../../shaderModules/FloatPassUniform.js";
-import { glsl as c } from "../../shaderModules/interfaces.js";
-import { Texture2DPassUniform as u } from "../../shaderModules/Texture2DPassUniform.js";
-function f(r) {
-  r.vertex.uniforms.add(new s("renderTransparentlyOccludedHUD", (i, e) => e.hudRenderStyle === l.Occluded ? 1 : e.hudRenderStyle === l.NotOccluded ? 0 : 0.75), new n("viewport", (i, e) => e.camera.fullViewport), new u("hudVisibilityTexture", (i, e) => {
-    var o;
-    return (o = e.hudVisibility) == null ? void 0 : o.getTexture();
-  })), r.vertex.include(t), r.vertex.code.add(c`bool testHUDVisibility(vec4 posProj) {
-vec4 posProjCenter = alignToPixelCenter(posProj, viewport.zw);
-vec4 occlusionPixel = texture(hudVisibilityTexture, .5 + .5 * posProjCenter.xy / posProjCenter.w);
-if (renderTransparentlyOccludedHUD > 0.5) {
-return occlusionPixel.r * occlusionPixel.g > 0.0 && occlusionPixel.g * renderTransparentlyOccludedHUD < 1.0;
-}
-return occlusionPixel.r * occlusionPixel.g > 0.0 && occlusionPixel.g == 1.0;
-}`);
-}
-export {
-  f as HUDVisibility
-};

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

@@ -1,28 +0,0 @@
-import { ShaderOutput as a } from "../ShaderOutput.js";
-import { Rgba4FloatEncoding as r } from "../util/RgbaFloat16Encoding.glsl.js";
-import { RgbaFloatEncoding as l } from "../util/RgbaFloatEncoding.glsl.js";
-import { glsl as o } from "../../shaderModules/interfaces.js";
-function n(t, e) {
-  switch (e.output) {
-    case a.Shadow:
-    case a.ShadowHighlight:
-    case a.ShadowExcludeHighlight:
-      t.fragment.include(r), t.fragment.code.add(o`float _calculateFragDepth(const in float depth) {
-const float SLOPE_SCALE = 2.0;
-const float BIAS = 20.0 * .000015259;
-float m = max(abs(dFdx(depth)), abs(dFdy(depth)));
-return depth + SLOPE_SCALE * m + BIAS;
-}
-void outputDepth(float _linearDepth) {
-fragColor = floatToRgba4(_calculateFragDepth(_linearDepth));
-}`);
-      break;
-    case a.LinearDepth:
-      t.fragment.include(l), t.fragment.code.add(o`void outputDepth(float _linearDepth) {
-fragColor = float2rgba(_linearDepth);
-}`);
-  }
-}
-export {
-  n as OutputDepth
-};

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

@@ -1,19 +0,0 @@
-import { fromValues as t } from "../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
-import { glsl as g } from "../../shaderModules/interfaces.js";
-import { Texture2DPassUniform as l } from "../../shaderModules/Texture2DPassUniform.js";
-const a = t(1, 1, 0, 1), d = t(1, 0, 1, 1);
-function u(e) {
-  e.fragment.uniforms.add(new l("depthTexture", (i, o) => o.mainDepth)), e.fragment.constants.add("occludedHighlightFlag", "vec4", a).add("unoccludedHighlightFlag", "vec4", d), e.fragment.code.add(g`void outputHighlight() {
-float sceneDepth = float(texelFetch(depthTexture, ivec2(gl_FragCoord.xy), 0).x);
-if (gl_FragCoord.z > sceneDepth + 5e-7) {
-fragColor = occludedHighlightFlag;
-} else {
-fragColor = unoccludedHighlightFlag;
-}
-}`);
-}
-export {
-  u as OutputHighlight,
-  a as occludedHighlightFlag,
-  d as unoccludedHighlightFlag
-};

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

@@ -1,29 +0,0 @@
-import { RgbaFloatEncoding as a } from "../util/RgbaFloatEncoding.glsl.js";
-import { glsl as r } from "../../shaderModules/interfaces.js";
-function p(e) {
-  e.include(a), e.code.add(r`float linearDepthFromFloat(float depth, vec2 nearFar) {
-return -(depth * (nearFar[1] - nearFar[0]) + nearFar[0]);
-}
-float linearDepthFromRGBA(vec4 depth, vec2 nearFar) {
-return linearDepthFromFloat(rgba2float(depth), nearFar);
-}
-float linearDepthFromTexture(sampler2D depthTexture, vec2 uv, vec2 nearFar) {
-ivec2 iuv = ivec2(uv * vec2(textureSize(depthTexture, 0)));
-return linearDepthFromRGBA(texelFetch(depthTexture, iuv, 0), nearFar);
-}`);
-}
-function o(e) {
-  e.code.add(r`float linearizeDepth(float depth, vec2 nearFar) {
-float depthNdc = depth * 2.0 - 1.0;
-return (2.0 * nearFar[0] * nearFar[1]) / (depthNdc * (nearFar[1] - nearFar[0]) - (nearFar[1] + nearFar[0]));
-}
-float linearDepthFromTexture(sampler2D depthTexture, vec2 uv, vec2 nearFar) {
-ivec2 iuv = ivec2(uv * vec2(textureSize(depthTexture, 0)));
-float depth = texelFetch(depthTexture, iuv, 0).r;
-return linearizeDepth(depth, nearFar);
-}`);
-}
-export {
-  o as ReadDepth,
-  p as ReadLinearDepth
-};

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

@@ -1,21 +0,0 @@
-import { glsl as e } from "../../shaderModules/interfaces.js";
-function n(a) {
-  const t = a.fragment.code;
-  t.add(e`vec3 evaluateDiffuseIlluminationHemisphere(vec3 ambientGround, vec3 ambientSky, float NdotNG)
-{
-return ((1.0 - NdotNG) * ambientGround + (1.0 + NdotNG) * ambientSky) * 0.5;
-}`), t.add(e`float integratedRadiance(float cosTheta2, float roughness)
-{
-return (cosTheta2 - 1.0) / (cosTheta2 * (1.0 - roughness * roughness) - 1.0);
-}`), t.add(e`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;
-}`);
-}
-export {
-  n as AnalyticalSkyModel
-};

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

@@ -1,45 +0,0 @@
-import { IDENTITY as o } from "../../../../../../core/libs/gl-matrix-2/factories/mat3f64.js";
-import { ONES as m } from "../../../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
-import { TextureCoordinateAttributeType as s } from "../attributes/TextureCoordinateAttribute.glsl.js";
-import { VertexTextureCoordinates as d } from "../attributes/VertexTextureCoordinates.glsl.js";
-import { NormalsDoubleSidedMode as i } from "./Normals.glsl.js";
-import { Float2PassUniform as l } from "../../shaderModules/Float2PassUniform.js";
-import { glsl as r } from "../../shaderModules/interfaces.js";
-import { Matrix3PassUniform as T } from "../../shaderModules/Matrix3PassUniform.js";
-import { Texture2DDrawUniform as c } from "../../shaderModules/Texture2DDrawUniform.js";
-import { Texture2DPassUniform as x } from "../../shaderModules/Texture2DPassUniform.js";
-import { BindType as u } from "../../shaderTechnique/BindType.js";
-import { VertexAttribute as g } from "../../../lib/VertexAttribute.js";
-function D(n, t) {
-  const e = n.fragment;
-  t.hasVertexTangents ? (n.attributes.add(g.TANGENT, "vec4"), n.varyings.add("vTangent", "vec4"), t.doubleSidedMode === i.WindingOrder ? e.code.add(r`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);
-}`) : e.code.add(r`mat3 computeTangentSpace(vec3 normal) {
-float tangentHeadedness = vTangent.w;
-vec3 tangent = normalize(vTangent.xyz);
-vec3 bitangent = cross(normal, tangent) * tangentHeadedness;
-return mat3(tangent, bitangent, normal);
-}`)) : e.code.add(r`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 !== s.None && (n.include(d, t), e.uniforms.add(t.pbrTextureBindType === u.Pass ? new x("normalTexture", (a) => a.textureNormal) : new c("normalTexture", (a) => a.textureNormal)), t.hasNormalTextureTransform && (e.uniforms.add(new l("scale", (a) => a.scale ?? m)), e.uniforms.add(new T("normalTextureTransformMatrix", (a) => a.normalTextureTransformMatrix ?? o))), e.code.add(r`vec3 computeTextureNormal(mat3 tangentSpace, vec2 uv) {
-vec3 rawNormal = textureLookup(normalTexture, uv).rgb * 2.0 - 1.0;`), t.hasNormalTextureTransform && e.code.add(r`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;`), e.code.add(r`return tangentSpace * rawNormal;
-}`));
-}
-export {
-  D as ComputeNormalTexture
-};

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

@@ -1,62 +0,0 @@
-import { s as r } from "../../../../../../chunks/vec32.js";
-import { create as d } from "../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
-import { s as g } from "../../../../../../chunks/vec42.js";
-import { create as A } from "../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
-import { PBRMode as s } from "./PhysicallyBasedRenderingParameters.glsl.js";
-import { Float3PassUniform as o } from "../../shaderModules/Float3PassUniform.js";
-import { Float4PassUniform as n } from "../../shaderModules/Float4PassUniform.js";
-import { glsl as m } from "../../shaderModules/interfaces.js";
-function L(b, e) {
-  const l = b.fragment, a = e.lightingSphericalHarmonicsOrder !== void 0 ? e.lightingSphericalHarmonicsOrder : 2;
-  a === 0 ? (l.uniforms.add(new o("lightingAmbientSH0", (t, i) => r(c, i.lighting.sh.r[0], i.lighting.sh.g[0], i.lighting.sh.b[0]))), l.code.add(m`vec3 calculateAmbientIrradiance(vec3 normal, float ambientOcclusion) {
-vec3 ambientLight = 0.282095 * lightingAmbientSH0;
-return ambientLight * (1.0 - ambientOcclusion);
-}`)) : a === 1 ? (l.uniforms.add(new n("lightingAmbientSH_R", (t, i) => g(h, i.lighting.sh.r[0], i.lighting.sh.r[1], i.lighting.sh.r[2], i.lighting.sh.r[3])), new n("lightingAmbientSH_G", (t, i) => g(h, i.lighting.sh.g[0], i.lighting.sh.g[1], i.lighting.sh.g[2], i.lighting.sh.g[3])), new n("lightingAmbientSH_B", (t, i) => g(h, i.lighting.sh.b[0], i.lighting.sh.b[1], i.lighting.sh.b[2], i.lighting.sh.b[3]))), l.code.add(m`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);
-}`)) : a === 2 && (l.uniforms.add(new o("lightingAmbientSH0", (t, i) => r(c, i.lighting.sh.r[0], i.lighting.sh.g[0], i.lighting.sh.b[0])), new n("lightingAmbientSH_R1", (t, i) => g(h, i.lighting.sh.r[1], i.lighting.sh.r[2], i.lighting.sh.r[3], i.lighting.sh.r[4])), new n("lightingAmbientSH_G1", (t, i) => g(h, i.lighting.sh.g[1], i.lighting.sh.g[2], i.lighting.sh.g[3], i.lighting.sh.g[4])), new n("lightingAmbientSH_B1", (t, i) => g(h, i.lighting.sh.b[1], i.lighting.sh.b[2], i.lighting.sh.b[3], i.lighting.sh.b[4])), new n("lightingAmbientSH_R2", (t, i) => g(h, i.lighting.sh.r[5], i.lighting.sh.r[6], i.lighting.sh.r[7], i.lighting.sh.r[8])), new n("lightingAmbientSH_G2", (t, i) => g(h, i.lighting.sh.g[5], i.lighting.sh.g[6], i.lighting.sh.g[7], i.lighting.sh.g[8])), new n("lightingAmbientSH_B2", (t, i) => g(h, i.lighting.sh.b[5], i.lighting.sh.b[6], i.lighting.sh.b[7], i.lighting.sh.b[8]))), l.code.add(m`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);
-}`), e.pbrMode !== s.Normal && e.pbrMode !== s.Schematic || l.code.add(m`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 c = d(), h = A();
-export {
-  L as EvaluateAmbientLighting
-};

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

@@ -1,20 +0,0 @@
-import { glsl as t } from "../../shaderModules/interfaces.js";
-import { Texture2DPassUniform as n } from "../../shaderModules/Texture2DPassUniform.js";
-import { blurSizePixels as i } from "../../../effects/ssao/SSAO.js";
-function v(r, a) {
-  const e = r.fragment;
-  a.receiveAmbientOcclusion ? (e.uniforms.add(new n("ssaoTex", (u, o) => {
-    var s;
-    return (s = o.ssao) == null ? void 0 : s.getTexture();
-  })), e.constants.add("blurSizePixelsInverse", "float", 1 / i), e.code.add(t`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();
-}`)) : e.code.add(t`float evaluateAmbientOcclusionInverse() { return 1.0; }
-float evaluateAmbientOcclusion() { return 0.0; }`);
-}
-export {
-  v as EvaluateAmbientOcclusion
-};

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

@@ -1,134 +0,0 @@
-import { neverReached as d } from "../../../../../../core/compilerUtils.js";
-import { EvaluateAmbientLighting as s } from "./EvaluateAmbientLighting.glsl.js";
-import { EvaluateAmbientOcclusion as m } from "./EvaluateAmbientOcclusion.glsl.js";
-import { addMainLightDirection as u, addMainLightIntensity as h, MainLighting as c } from "./MainLighting.glsl.js";
-import { PhysicallyBasedRendering as g } from "./PhysicallyBasedRendering.glsl.js";
-import { PBRMode as t } from "./PhysicallyBasedRenderingParameters.glsl.js";
-import { PiUtils as p } from "./PiUtils.glsl.js";
-import { BooleanPassUniform as v } from "../../shaderModules/BooleanPassUniform.js";
-import { FloatPassUniform as r } from "../../shaderModules/FloatPassUniform.js";
-import { glsl as n } from "../../shaderModules/interfaces.js";
-import { ambientBoost as f } from "../../../lighting/SceneLighting.js";
-function L(o) {
-  o.constants.add("ambientBoostFactor", "float", f);
-}
-function b(o) {
-  o.uniforms.add(new r("lightingGlobalFactor", (e, i) => i.lighting.globalFactor));
-}
-function y(o, e) {
-  const i = o.fragment;
-  switch (o.include(m, e), e.pbrMode !== t.Disabled && o.include(g, e), o.include(s, e), o.include(p), i.code.add(n`
-    const float GAMMA_SRGB = 2.1;
-    const float INV_GAMMA_SRGB = 0.4761904;
-    ${e.pbrMode === t.Disabled ? "" : "const vec3 GROUND_REFLECTANCE = vec3(0.2);"}
-  `), L(i), b(i), u(i), i.code.add(n`
-    float additionalDirectedAmbientLight(vec3 vPosWorld) {
-      float vndl = dot(${e.spherical ? n`normalize(vPosWorld)` : n`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
-      return smoothstep(0.0, 1.0, clamp(vndl * 2.5, 0.0, 1.0));
-    }
-  `), h(i), i.code.add(n`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
-float additionalAmbientScale = additionalDirectedAmbientLight(vPosWorld);
-return (1.0 - ambientOcclusion) * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor * mainLightIntensity;
-}`), e.pbrMode) {
-    case t.Disabled:
-    case t.WaterOnIntegratedMesh:
-    case t.Water:
-      o.include(c), i.code.add(n`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 t.Normal:
-    case t.Schematic:
-      i.code.add(n`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);`), i.code.add(n`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);`), e.useFillLights ? i.uniforms.add(new v("hasFillLights", (l, a) => a.enableFillLights)) : i.constants.add("hasFillLights", "bool", !1), i.code.add(n`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 ;`), i.uniforms.add(new r("lightingSpecularStrength", (l, a) => a.lighting.mainLight.specularStrength), new r("lightingEnvironmentStrength", (l, a) => a.lighting.mainLight.environmentStrength)), i.code.add(n`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]);`), i.code.add(n`
-        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;
-        ${e.pbrMode !== t.Schematic || e.hasColorTexture ? n`vec3 outColor = pow(blackLevelSoftCompression(outColorLinear, inputs), vec3(INV_GAMMA_SRGB));` : n`vec3 outColor = pow(max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance), vec3(INV_GAMMA_SRGB));`}
-        return outColor;
-      }
-    `);
-      break;
-    case t.Simplified:
-    case t.TerrainWithWater:
-      o.include(c), i.code.add(n`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:
-      d(e.pbrMode);
-    case t.COUNT:
-  }
-}
-export {
-  y as EvaluateSceneLighting,
-  L as addAmbientBoostFactor,
-  b as addLightingGlobalFactor
-};