jtBaseApp/node_modules/.vite/chunk-Q7HVKAHU.js

import {
  c
} from "./chunk-QXZVBSBH.js";
import {
  a,
  a2,
  a3,
  a4,
  c as c2,
  c2 as c3,
  c3 as c4,
  c4 as c5,
  d,
  d2,
  d4 as d3,
  e2 as e,
  e3 as e2,
  e4 as e3,
  e5 as e4,
  e6 as e5,
  f2 as f,
  h3 as h,
  i,
  i3 as i2,
  i4 as i3,
  i5 as i4,
  l,
  m,
  m2,
  m3,
  m4,
  n as n2,
  n2 as n3,
  n3 as n4,
  n4 as n5,
  o as o2,
  o2 as o3,
  o3 as o4,
  o4 as o5,
  o6,
  r3 as r2,
  s,
  s2,
  t,
  t2,
  u
} from "./chunk-OBMTYN3I.js";
import {
  O as O2
} from "./chunk-EPIK5VPD.js";
import {
  O
} from "./chunk-XXBIV3TZ.js";
import {
  o
} from "./chunk-E3HOL2XO.js";
import {
  n
} from "./chunk-H2KDMZTR.js";
import {
  r
} from "./chunk-GZT4BVFP.js";

// node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js
function e6(e7, o7) {
  const n6 = e7.fragment;
  switch (n6.code.add(n2`struct ShadingNormalParameters {
vec3 normalView;
vec3 viewDirection;
} shadingParams;`), o7.doubleSidedMode) {
    case i5.None:
      n6.code.add(n2`vec3 shadingNormal(ShadingNormalParameters params) {
return normalize(params.normalView);
}`);
      break;
    case i5.View:
      n6.code.add(n2`vec3 shadingNormal(ShadingNormalParameters params) {
return dot(params.normalView, params.viewDirection) > 0.0 ? normalize(-params.normalView) : normalize(params.normalView);
}`);
      break;
    case i5.WindingOrder:
      n6.code.add(n2`vec3 shadingNormal(ShadingNormalParameters params) {
return gl_FrontFacing ? normalize(params.normalView) : normalize(-params.normalView);
}`);
      break;
    default:
      n(o7.doubleSidedMode);
    case i5.COUNT:
  }
}
var i5;
!function(a5) {
  a5[a5.None = 0] = "None", a5[a5.View = 1] = "View", a5[a5.WindingOrder = 2] = "WindingOrder", a5[a5.COUNT = 3] = "COUNT";
}(i5 || (i5 = {}));

// node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js
function m5(m6, c6) {
  const i6 = m6.fragment;
  if (c6.hasVertexTangents ? (m6.attributes.add(O.TANGENT, "vec4"), m6.varyings.add("vTangent", "vec4"), c6.doubleSidedMode === i5.WindingOrder ? i6.code.add(n2`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);
}`) : i6.code.add(n2`mat3 computeTangentSpace(vec3 normal) {
float tangentHeadedness = vTangent.w;
vec3 tangent = normalize(vTangent.xyz);
vec3 bitangent = cross(normal, tangent) * tangentHeadedness;
return mat3(tangent, bitangent, normal);
}`)) : (m6.extensions.add("GL_OES_standard_derivatives"), i6.code.add(n2`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);
}`)), c6.textureCoordinateType !== o4.None) {
    m6.include(a, c6);
    const e7 = c6.supportsTextureAtlas;
    i6.uniforms.add(c6.pbrTextureBindType === a2.Pass ? m2("normalTexture", (e8) => e8.textureNormal, e7) : m("normalTexture", (e8) => e8.textureNormal, e7)), i6.code.add(n2`
    vec3 computeTextureNormal(mat3 tangentSpace, vec2 uv) {
      vtc.uv = uv;
      ${c6.supportsTextureAtlas ? "vtc.size = normalTextureSize;" : ""}
      vec3 rawNormal = textureLookup(normalTexture, vtc).rgb * 2.0 - 1.0;
      return tangentSpace * rawNormal;
    }
  `);
  }
}

// node_modules/@arcgis/core/views/3d/webgl-engine/core/shaderLibrary/util/HeaderComment.glsl.js
function r3(r4, u2) {
  const p = n2`
  /*
  *  ${u2.name}
  *  ${u2.output === o2.Color ? "RenderOutput: Color" : u2.output === o2.Depth ? "RenderOutput: Depth" : u2.output === o2.Shadow ? "RenderOutput: Shadow" : u2.output === o2.Normal ? "RenderOutput: Normal" : u2.output === o2.Highlight ? "RenderOutput: Highlight" : ""}
  */
  `;
  c() && (r4.fragment.code.add(p), r4.vertex.code.add(p));
}

// node_modules/@arcgis/core/chunks/DefaultMaterial.glsl.js
function k(k2) {
  const W2 = new i4(), H = W2.vertex.code, q = W2.fragment.code;
  W2.include(r3, { name: "Default Material Shader", output: k2.output });
  const J = d3(W2, k2);
  return W2.include(o5), W2.varyings.add("vpos", "vec3"), W2.include(s, k2), W2.include(m3, k2), W2.include(a3, k2), k2.output !== o2.Color && k2.output !== o2.Alpha || (c3(W2.vertex, k2), W2.include(o3, k2), W2.include(r2, { linearDepth: false, hasModelTransformation: k2.hasModelTransformation }), k2.normalType === i.Attribute && k2.offsetBackfaces && W2.include(e3), W2.include(m5, k2), W2.include(n3, k2), k2.instancedColor && W2.attributes.add(O.INSTANCECOLOR, "vec4"), W2.varyings.add("localvpos", "vec3"), W2.include(d, k2), W2.include(t2, k2), W2.include(i2, k2), W2.include(e4, k2), W2.vertex.uniforms.add(new e5("externalColor", (e7) => e7.externalColor)), W2.varyings.add("vcolorExt", "vec4"), k2.hasMultipassTerrain && W2.varyings.add("depth", "float"), k2.hasModelTransformation && W2.vertex.uniforms.add(new e2("model", (o7) => r(o7.modelTransformation) ? o7.modelTransformation : o)), H.add(n2`
      void main(void) {
        forwardNormalizedVertexColor();
        vcolorExt = externalColor;
        ${k2.instancedColor ? "vcolorExt *= instanceColor;" : ""}
        vcolorExt *= vvColor();
        vcolorExt *= getSymbolColor();
        forwardColorMixMode();

        if (vcolorExt.a < ${n2.float(t)}) {
          gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
        } else {
          vpos = calculateVPos();
          localvpos = vpos - view[3].xyz;
          vpos = subtractOrigin(vpos);
          ${k2.normalType === i.Attribute ? n2`vNormalWorld = dpNormal(vvLocalNormal(normalModel()));` : ""}
          vpos = addVerticalOffset(vpos, localOrigin);
          ${k2.hasVertexTangents ? "vTangent = dpTransformVertexTangent(tangent);" : ""}
          gl_Position = transformPosition(proj, view, ${k2.hasModelTransformation ? "model," : ""} vpos);
          ${k2.normalType === i.Attribute && k2.offsetBackfaces ? "gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);" : ""}
        }

        ${k2.hasMultipassTerrain ? "depth = (view * vec4(vpos, 1.0)).z;" : ""}
        forwardLinearDepth();
        forwardTextureCoordinates();
      }
    `)), k2.output === o2.Alpha && (W2.include(u, k2), W2.include(s2, k2), W2.include(n5, k2), W2.fragment.uniforms.add([new o6("opacity", (e7) => e7.opacity), new o6("layerOpacity", (e7) => e7.layerOpacity)]), k2.hasColorTexture && W2.fragment.uniforms.add(new c2("tex", (e7) => e7.texture)), W2.fragment.include(i3), q.add(n2`
      void main() {
        discardBySlice(vpos);
        ${k2.hasMultipassTerrain ? "terrainDepthTest(gl_FragCoord, depth);" : ""}
        ${k2.hasColorTexture ? n2`
                vec4 texColor = texture2D(tex, vuv0);
                ${k2.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
                discardOrAdjustAlpha(texColor);` : n2`vec4 texColor = vec4(1.0);`}
        ${k2.hasVertexColors ? n2`float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));` : n2`float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
        gl_FragColor = vec4(opacity_);
      }
    `)), k2.output === o2.Color && (W2.include(u, k2), W2.include(m4, k2), W2.include(a4, k2), W2.include(s2, k2), W2.include(k2.instancedDoublePrecision ? h : c5, k2), W2.include(n5, k2), c3(W2.fragment, k2), W2.fragment.uniforms.add([J, new e("ambient", (e7) => e7.ambient), new e("diffuse", (e7) => e7.diffuse), new o6("opacity", (e7) => e7.opacity), new o6("layerOpacity", (e7) => e7.layerOpacity), new o6("lightingGlobalFactor", (e7, r4) => r4.lighting.globalFactor), new e("lightingMainIntensity", (e7, r4) => r4.lighting.mainLight.intensity)]), W2.fragment.constants.add("ambientBoostFactor", "float", c4), k2.hasColorTexture && W2.fragment.uniforms.add(new c2("tex", (e7) => e7.texture)), W2.include(d2, k2), W2.include(n4, k2), W2.fragment.include(i3), W2.include(e6, k2), q.add(n2`
      void main() {
        discardBySlice(vpos);
        ${k2.hasMultipassTerrain ? "terrainDepthTest(gl_FragCoord, depth);" : ""}
        ${k2.hasColorTexture ? n2`
                vec4 texColor = texture2D(tex, vuv0);
                ${k2.textureAlphaPremultiplied ? "texColor.rgb /= texColor.a;" : ""}
                discardOrAdjustAlpha(texColor);` : n2`vec4 texColor = vec4(1.0);`}
        shadingParams.viewDirection = normalize(vpos - cameraPosition);
        ${k2.normalType === i.ScreenDerivative ? n2`
                vec3 normal = screenDerivativeNormal(localvpos);` : n2`
                shadingParams.normalView = vNormalWorld;
                vec3 normal = shadingNormal(shadingParams);`}
        ${k2.pbrMode === l.Normal ? "applyPBRFactors();" : ""}
        float ssao = evaluateAmbientOcclusionInverse();
        ssao *= getBakedOcclusion();

        float additionalAmbientScale = additionalDirectedAmbientLight(vpos + localOrigin);
        ${k2.receiveShadows ? "float shadow = readShadowMap(vpos, linearDepth);" : k2.spherical ? "float shadow = lightingGlobalFactor * (1.0 - additionalAmbientScale);" : "float shadow = 0.0;"}
        vec3 matColor = max(ambient, diffuse);
        ${k2.hasVertexColors ? n2`
                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));` : n2`
                vec3 albedo = mixExternalColor(matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
                float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));`}
        ${k2.hasNormalTexture ? n2`
                mat3 tangentSpace = ${k2.hasVertexTangents ? "computeTangentSpace(normal);" : "computeTangentSpace(normal, vpos, vuv0);"}
                vec3 shadingNormal = computeTextureNormal(tangentSpace, vuv0);` : n2`vec3 shadingNormal = normal;`}
        vec3 normalGround = ${k2.spherical ? n2`normalize(vpos + localOrigin);` : n2`vec3(0.0, 0.0, 1.0);`}

        ${k2.snowCover ? n2`
                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 * lightingMainIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;

        ${k2.pbrMode === l.Normal || k2.pbrMode === l.Schematic ? n2`
                float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * lightingMainIntensity[2];
                ${k2.snowCover ? n2`
                        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);` : n2`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
        gl_FragColor = highlightSlice(vec4(shadedColor, opacity_), vpos);
        ${k2.transparencyPassType === O2.Color ? n2`gl_FragColor = premultiplyAlpha(gl_FragColor);` : ""}
      }
    `)), W2.include(f, k2), W2;
}
var W = Object.freeze(Object.defineProperty({ __proto__: null, build: k }, Symbol.toStringTag, { value: "Module" }));

export {
  i5 as i,
  k,
  W
};
//# sourceMappingURL=chunk-Q7HVKAHU.js.map