@arcgis/core 5.2.0-next.111 → 5.2.0-next.113

package/views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{EvaluateAmbientLighting as i}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as n}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as e}from"./Gamma.glsl.js";import{addMainLightDirection as t,addMainLightIntensity as a,applyShading as o}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as l}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as r}from"./PiUtils.glsl.js";import{ReadGlobalIllumination as c}from"./ReadGlobalIllumination.glsl.js";import{BooleanBindUniform as s}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as d}from"../../shaderModules/FloatBindUniform.js";import{glsl as m,If as u}from"../../shaderModules/glsl.js";import{ambientBoost as g}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as h}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as p}from"../../../shaders/ToneMapping.glsl.js";function f(i){i.constants.add("ambientBoostFactor","float",g)}function v(i){i.uniforms.add(new d("lightingGlobalFactor",i=>i.lighting.globalFactor))}function b(g,b){const{pbrMode:L,spherical:I,hasColorTexture:C,receiveGlobalIllumination:D}=b;g.include(e),g.include(c,b),g.include(n,b),0!==L&&g.include(l,b),g.include(i,b),g.include(r),g.include(p,b);const R=!(2===L&&!C);R&&g.include(h),f(g),v(g),t(g),g.code.add(m`
+import{EvaluateAmbientLighting as i}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as e}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as n}from"./Gamma.glsl.js";import{mainLightDirection as a,mainLightIntensity as t,applyShading as o}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as l}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as r}from"./PiUtils.glsl.js";import{ReadGlobalIllumination as c}from"./ReadGlobalIllumination.glsl.js";import{BooleanBindUniform as d}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as s}from"../../shaderModules/FloatBindUniform.js";import{glsl as m,If as u}from"../../shaderModules/glsl.js";import{ambientBoost as g}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as h}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as p}from"../../../shaders/ToneMapping.glsl.js";function f(i){i.constants.add("ambientBoostFactor","float",g)}function v(i){i.uniforms.add(new s("lightingGlobalFactor",i=>i.lighting.globalFactor))}function b(g,b){const{pbrMode:L,spherical:I,hasColorTexture:C,receiveGlobalIllumination:D}=b;g.include(n),g.include(c,b),g.include(e,b),0!==L&&g.include(l,b),g.include(i,b),g.include(r),g.include(p,b);const S=!(2===L&&!C);S&&g.include(h),f(g),v(g),g.uniforms.add(a).code.add(m`
     float additionalDirectedAmbientLight(float lightAlignment) {
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
@@ -8,58 +8,55 @@ import{EvaluateAmbientLighting as i}from"./EvaluateAmbientLighting.glsl.js";impo
       float lightAlignment = dot(${I?m`normalize(vPosWorld)`:m`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
-  `),a(g),g.code.add(m`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
+  `),g.uniforms.add(t).code.add(m`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
 float additionalAmbientScale = additionalDirectedAmbientLight(vPosWorld);
 return (1.0 - ambientOcclusion) * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor * mainLightIntensity;
-}`);const y=D?"globalIlluminationOcclusion":"ssao",A=D?.75:1,S=D?1.5:1;switch(D&&g.code.add(m`vec3 evaluateGlobalIlluminationOcclusion() {
+}`);const R=D?"globalIlluminationOcclusion":"ssao";switch(g.constants.add("mainLightIrradianceScale","float",D?.75:1),g.constants.add("ambientIrradianceScale","float",D?1.5:1),D&&g.code.add(m`vec3 evaluateGlobalIlluminationOcclusion() {
 return min(1.2 * readGlobalIlluminationOcclusion(), 1.0);
 }
 vec3 evaluateGlobalIlluminationEmission(vec3 albedoLinear) {
 return 2.25 * (0.75 * albedoLinear + 0.25) * readGlobalIlluminationEmission().rgb;
 }`),L){case 0:case 4:case 3:g.include(o),g.code.add(m`
-      vec3 evaluateSceneLighting(vec3 normalWorld, vec3 albedo, float shadow, float ssao, vec3 additionalLight) {
-        ${u(D,m`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
-
-        vec3 mainLighting = ${D?`${m.float(A)} * `:""}applyShading(normalWorld, shadow);
-        vec3 ambientLighting = ${D?`${m.float(S)} * `:""}calculateAmbientIrradiance(normalWorld) * (1.0 - ${y});
-        vec3 albedoLinear = linearizeGamma(albedo);
-
-        vec3 totalLight = mainLighting + ambientLighting + additionalLight;
-        totalLight = min(totalLight, vec3(PI));
-        vec3 outColor = vec3((albedoLinear / PI) * totalLight);
-        ${u(D,m`
-        outColor += evaluateGlobalIlluminationEmission(albedoLinear);`)}
-        return delinearizeGamma(outColor);
-      }
-      `);break;case 1:case 2:{const i=D?.35:.2;g.code.add(m`
+        vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+                                   vec3 viewDirection, vec3 upDirection) {
+          ${u(D,m`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
+
+          vec3 mainLighting = mainLightIrradianceScale * applyShading(normal, shadow);
+          vec3 ambientLighting = ambientIrradianceScale * calculateAmbientIrradiance(normal) * (1.0 - ${R});
+          vec3 albedoLinear = linearizeGamma(albedo);
+
+          vec3 totalLight = mainLighting + ambientLighting + additionalLight;
+          totalLight = min(totalLight, vec3(PI));
+          vec3 linearColor = vec3((albedoLinear / PI) * totalLight);
+          ${u(D,"linearColor += evaluateGlobalIlluminationEmission(albedoLinear);")}
+          return delinearizeGamma(linearColor);
+        }
+      `);break;case 1:case 2:g.constants.add("groundReflectance","float",D?.35:.2),g.code.add(m`
         const float fillLightIntensity = 0.25;
         const float horizonLightDiffusion = 0.4;
-        const float additionalAmbientIrradianceFactor = 0.02;
-        const float groundReflectance = ${m.float(i)};
 
-        vec3 evaluateSceneLightingPBR(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
-                                      vec3 viewDirection, vec3 upDirection, vec3 mrr, float additionalAmbientIrradiance) {
+        vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+                                   vec3 viewDirection, vec3 upDirection) {
           PBRShadingInfo inputs;
-          calculatePBRInputs(inputs, normal, viewDirection, upDirection, albedo, mrr);
-
-            ${u(D,m`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
-      `),b.useFillLights?g.uniforms.add(new s("hasFillLights",i=>i.enableFillLights)):g.constants.add("hasFillLights","bool",!1),g.code.add(m`
+          calculatePBRInputs(inputs, normal, viewDirection, upDirection, albedo);
+          ${u(D,"vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();")}
+      `),b.useFillLights?g.uniforms.add(new d("hasFillLights",i=>i.enableFillLights)):g.constants.add("hasFillLights","bool",!1),g.code.add(m`
         vec3 ambientDir = vec3(5.0 * upDirection[1] - upDirection[0] * upDirection[2], - 5.0 * upDirection[0] - upDirection[2] * upDirection[1], upDirection[1] * upDirection[1] + upDirection[0] * upDirection[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;
 
         // Calculate the irradiance components: sun, fill lights and the sky.
-        vec3 mainLightIrradianceComponent = ${m.float(A)} * inputs.NdotL * (1.0 - shadow) * mainLightIntensity;
+        vec3 mainLightIrradianceComponent = mainLightIrradianceScale * inputs.NdotL * (1.0 - shadow) * mainLightIntensity;
         vec3 fillLightsIrradianceComponent = inputs.NdotAmbDir * mainLightIntensity * fillLightIntensity;
         // calculate ambient irradiance for localView and additionalLight for globalView
-        vec3 ambientLightIrradianceComponent = ${m.float(S)} * calculateAmbientIrradiance(normal) * (1.0 - ${y}) + additionalLight;
+        vec3 ambientLightIrradianceComponent = ambientIrradianceScale * calculateAmbientIrradiance(normal) * (1.0 - ${R}) + additionalLight;
 
         // Assemble the overall irradiance of the sky that illuminates the surface
         inputs.skyIrradianceToSurface = ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
         // Assemble the overall irradiance of the ground that illuminates the surface. for this we use the simple model that changes only the sky irradiance by the groundReflectance
         inputs.groundIrradianceToSurface = groundReflectance * ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
-      `),g.uniforms.add(new d("lightingSpecularStrength",i=>i.lighting.mainLight.specularStrength),new d("lightingEnvironmentStrength",i=>i.lighting.mainLight.environmentStrength)).code.add(m`
+      `),g.uniforms.add(new s("lightingSpecularStrength",i=>i.lighting.mainLight.specularStrength),new s("lightingEnvironmentStrength",i=>i.lighting.mainLight.environmentStrength)).code.add(m`
         vec3 horizonRingDir = inputs.RdotUP * upDirection - inputs.reflectedView;
         vec3 horizonRingH = normalize(horizonRingDir - viewDirection);
         inputs.NdotH_Horizon = dot(normal, horizonRingH);
@@ -68,7 +65,7 @@ return 2.25 * (0.75 * albedoLinear + 0.25) * readGlobalIlluminationEmission().rg
         vec3 horizonLightRadianceComponent = lightingEnvironmentStrength * normalDistribution(inputs.NdotH_Horizon, min(inputs.roughness + horizonLightDiffusion, 1.0)) * mainLightIntensity * fillLightIntensity;
 
         // calculateAmbientRadiance for localView and additionalLight for global view
-        vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance() * (1.0 - ${y}) + additionalLight;
+        vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance() * (1.0 - ${R}) + additionalLight;
         float normalDirectionModifier = mix(1., min(mix(0.1, 2.0, (inputs.NdotUP + 1.) * 0.5), 1.0), clamp(inputs.roughness * 5.0, 0.0 , 1.0));
 
         // Assemble the overall radiance of the sky that illuminates the surface
@@ -79,45 +76,47 @@ return 2.25 * (0.75 * albedoLinear + 0.25) * readGlobalIlluminationEmission().rg
 
         // Calculate average ambient radiance - This is used in the gamut mapping process to determine the black level for compression
         inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + groundReflectance);
-      `),g.code.add(m`
+      `),g.constants.add("additionalAmbientIrradianceFactor","float",.02),g.code.add(m`
         vec3 reflectedColorComponent = evaluateEnvironmentIllumination(inputs);
+        float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
         vec3 additionalMaterialReflectanceComponent = inputs.albedoLinear * additionalAmbientIrradiance;
-        vec3 outColorLinear = reflectedColorComponent + additionalMaterialReflectanceComponent;
+        vec3 linearColor = reflectedColorComponent + additionalMaterialReflectanceComponent;
 
-        ${u(D,m`
-        outColorLinear += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
+        ${u(D,"linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);")}
 
-      ${R?m`vec3 adjustedOutColorLinear = blackLevelSoftCompression(outColorLinear, inputs.averageAmbientRadiance);`:m`vec3 adjustedOutColorLinear = max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance);`}
+      ${S?"linearColor = blackLevelSoftCompression(linearColor, inputs.averageAmbientRadiance);":"linearColor = max(vec3(0.0), linearColor - 0.005 * inputs.averageAmbientRadiance);"}
 
-        return delinearizeGamma(adjustedOutColorLinear);
+        return delinearizeGamma(linearColor);
       }
-    `);break}case 5:case 6:{const i=D?.35:.5,n=D?.75:1,e=D?1.5:1;t(g),a(g),g.code.add(m`
-      const float roughnessTerrain = 0.5;
-      const float specularityTerrain = ${m.float(i)};
+    `);break;case 5:case 6:g.constants.add("terrainSpecularity","float",D?.35:.5),g.uniforms.add(a,t).code.add(m`
+        const float roughnessTerrain = 0.5;
 
-      vec3 evaluatePBRSimplifiedLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight, vec3 viewDirection, vec3 upDirection) {
-        PBRShadingInfo inputs;
-        calculateSimplifiedInputs(inputs, normal, viewDirection, upDirection, albedo);
+        vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+                                   vec3 viewDirection, vec3 upDirection) {
+          PBRShadingInfo inputs;
+          calculateSimplifiedInputs(inputs, normal, viewDirection, upDirection, albedo);
 
-        ${u(D,m`vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();`)}
+          ${u(D,"vec3 globalIlluminationOcclusion = evaluateGlobalIlluminationOcclusion();")}
 
-        vec3 mainLightIrradianceComponent = ${m.float(n)} * (1.0 - shadow) * inputs.NdotL * mainLightIntensity;
-        vec3 ambientLightIrradianceComponent = ${m.float(e)} * calculateAmbientIrradiance(normal) * (1.0 - ${y}) + additionalLight;
-        vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
+          vec3 mainLightIrradianceComponent = mainLightIrradianceScale * (1.0 - shadow) * inputs.NdotL * mainLightIntensity;
+          vec3 ambientLightIrradianceComponent = ambientIrradianceScale * calculateAmbientIrradiance(normal) * (1.0 - ${R}) + additionalLight;
+          vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
 
-        vec3 indirectDiffuse = ((1.0 - inputs.NdotUP) * mainLightIrradianceComponent + (1.0 + inputs.NdotUP ) * ambientSky) * 0.5;
-        vec3 outDiffColor = inputs.albedoLinear * (1.0 - inputs.f0) * indirectDiffuse / PI;
+          vec3 indirectDiffuse = ((1.0 - inputs.NdotUP) * mainLightIrradianceComponent + (1.0 + inputs.NdotUP ) * ambientSky) * 0.5;
+          vec3 diffuseColor = inputs.albedoLinear * (1.0 - inputs.f0) * indirectDiffuse / PI;
 
-        vec3 mainLightRadianceComponent = normalDistribution(inputs.NdotH, roughnessTerrain) * mainLightIntensity;
-        vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, inputs.NdotV);
-        vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
-        vec3 specularComponent = specularityTerrain * specularColor * mainLightRadianceComponent;
+          vec3 mainLightRadianceComponent = normalDistribution(inputs.NdotH, roughnessTerrain) * mainLightIntensity;
+          vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, inputs.NdotV);
+          vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
+          vec3 specularComponent = terrainSpecularity * specularColor * mainLightRadianceComponent;
 
-        vec3 outColorLinear = outDiffColor + specularComponent;
+          vec3 linearColor = diffuseColor + specularComponent;
 
-        ${u(D,m`
-        outColorLinear += evaluateGlobalIlluminationEmission(inputs.albedoLinear);`)}
+          ${u(D,"linearColor += evaluateGlobalIlluminationEmission(inputs.albedoLinear);")}
 
-        return delinearizeGamma(outColorLinear);
-      }
-      `);break}}}export{b as EvaluateSceneLighting,f as addAmbientBoostFactor,v as addLightingGlobalFactor};
+          return delinearizeGamma(linearColor);
+        }
+      `);break;case 7:g.code.add(m`vec3 evaluateSceneLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+vec3 viewDirection, vec3 upDirection) {
+return albedo;
+}`)}}export{b as EvaluateSceneLighting,f as addAmbientBoostFactor,v as addLightingGlobalFactor};

package/views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js

@@ -35,7 +35,7 @@ return worldToScreenPerDistanceRatio / segmentDistanceToCamera;
       }
       return vec2(startPseudoScreen, startPseudoScreen + segmentLengthPseudoScreen);
     }
-  `),v.uniforms.add(new n("stipplePatternTexture",e=>e.stippleTexture),new a("stipplePatternPixelSizeInv",e=>1/S(e))),c.stippleOffColorEnabled&&v.uniforms.add(new r("stippleOffColor",e=>f(e.stippleOffColor))),d.include(t),c.worldSizedImagePattern?(d.varyings.add("vStippleV","float"),d.fragment.include(e),v.code.add(p`vec4 getStippleColor(out bool isClamped) {
+  `),v.uniforms.add(new n("stipplePatternTexture",e=>e.stippleTexture),new a("stipplePatternPixelSizeInv",e=>1/S(e))),c.stippleOffColorEnabled&&v.uniforms.add(new r("stippleOffColor",e=>f(e.stippleOffColor))),d.include(t);const h=c.worldSized&&c.imagePattern,C=!c.worldSized;h?(d.varyings.add("vStippleV","float"),d.fragment.include(e),v.code.add(p`vec4 getStippleColor(out bool isClamped) {
 vec2 aaCorrectedLimits = vStippleDistanceLimits + vec2(1.0, -1.0) / gl_FragCoord.w;
 isClamped = vStippleDistance < aaCorrectedLimits.x || vStippleDistance > aaCorrectedLimits.y;
 float u = vStippleDistance * stipplePatternPixelSizeInv;
@@ -61,13 +61,15 @@ float opacity = mixExternalOpacity(color.a, 1.0, stippleColor.a, mixMode);
 return vec4(col, opacity);
 }`)):v.code.add(p`
     float getStippleSDF(out bool isClamped) {
-      float stippleDistanceClamped = noPerspectiveRead(clamp(vStippleDistance, vStippleDistanceLimits.x, vStippleDistanceLimits.y));
+      float stippleDistance = noPerspectiveRead(${C?"clamp(vStippleDistance, vStippleDistanceLimits.x, vStippleDistanceLimits.y)":"vStippleDistance"});
       float lineSizeInv = noPerspectiveRead(vLineSizeInv);
 
+      ${C?p`
       vec2 aaCorrectedLimits = vStippleDistanceLimits + vec2(1.0, -1.0) / gl_FragCoord.w;
       isClamped = vStippleDistance < aaCorrectedLimits.x || vStippleDistance > aaCorrectedLimits.y;
+      `:p`isClamped = false;`}
 
-      float u = stippleDistanceClamped * stipplePatternPixelSizeInv * lineSizeInv;
+      float u = stippleDistance * stipplePatternPixelSizeInv * lineSizeInv;
       u = fract(u);
 
       float sdf = texture(stipplePatternTexture, vec2(u, 0.5)).r;

package/views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{Float3BindUniform as i}from"../../shaderModules/Float3BindUniform.js";import{glsl as n}from"../../shaderModules/glsl.js";function t(n){n.uniforms.add(new i("mainLightDirection",i=>i.lighting.mainLight.direction))}function o(n){n.uniforms.add(new i("mainLightIntensity",i=>i.lighting.mainLight.intensity))}function a(i){t(i),o(i),i.code.add(n`vec3 applyShading(vec3 shadingNormal, float shadow) {
+import{Float3BindUniform as i}from"../../shaderModules/Float3BindUniform.js";import{glsl as n}from"../../shaderModules/glsl.js";const t=new i("mainLightDirection",i=>i.lighting.mainLight.direction),o=new i("mainLightIntensity",i=>i.lighting.mainLight.intensity);function a(i){i.uniforms.add(t,o),i.code.add(n`vec3 applyShading(vec3 shadingNormal, float shadow) {
 float dotVal = clamp(dot(shadingNormal, mainLightDirection), 0.0, 1.0);
 return mainLightIntensity * ((1.0 - shadow) * dotVal);
-}`)}export{t as addMainLightDirection,o as addMainLightIntensity,a as applyShading};
+}`)}export{a as applyShading,t as mainLightDirection,o as mainLightIntensity};

package/views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js

@@ -1,18 +1,19 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{markerSizePerLineWidth as e}from"../../../../support/engineContent/marker.js";import{addPixelRatio as r}from"../util/View.glsl.js";import{FloatBindUniform as t}from"../../shaderModules/FloatBindUniform.js";import{If as o,glsl as a}from"../../shaderModules/glsl.js";function i(i,n){const d=i.vertex,l=n.hasScreenSizePerspective;r(d),null==d.uniforms.get("markerScale")&&d.constants.add("markerScale","float",1),d.constants.add("markerSizePerLineWidth","float",e).code.add(a`
-  float getLineWidth(${o(l,"vec3 pos")}) {
-     return max(getSize(${o(l,"pos")}), 1.0) * pixelRatio;
+import{markerSizePerLineWidth as e}from"../../../../support/engineContent/marker.js";import{addPixelRatio as r}from"../util/View.glsl.js";import{FloatBindUniform as o}from"../../shaderModules/FloatBindUniform.js";import{If as t,glsl as a}from"../../shaderModules/glsl.js";function i(i,n){const d=i.vertex,l=n.hasScreenSizePerspective,s=n.worldSized;r(d),s&&d.uniforms.add(new o("worldToScreenRatio",e=>1/e.screenToPCSRatio)),null==d.uniforms.get("markerScale")&&d.constants.add("markerScale","float",1),d.constants.add("markerSizePerLineWidth","float",e).code.add(a`
+  float getLineWidth(${t(l,"vec3 pos")}) {
+     float size = max(getSize(${t(l,"pos")}), 1.0);
+     return ${t(s,"size * pixelRatio * worldToScreenRatio","size * pixelRatio")};
   }
 
   float getScreenMarkerSize(float lineWidth) {
     return markerScale * markerSizePerLineWidth * lineWidth;
   }
-  `),2===n.space&&(d.constants.add("maxSegmentLengthFraction","float",.45),d.uniforms.add(new t("perRenderPixelRatio",e=>e.camera.perRenderPixelRatio)),d.code.add(a`
+  `),2===n.space&&(d.constants.add("maxSegmentLengthFraction","float",.45),d.uniforms.add(new o("perRenderPixelRatio",e=>e.camera.perRenderPixelRatio)),d.code.add(a`
   bool areWorldMarkersHidden(vec3 pos, vec3 other) {
     vec3 midPoint = mix(pos, other, 0.5);
     float distanceToCamera = length(midPoint);
     float screenToWorldRatio = perRenderPixelRatio * distanceToCamera * 0.5;
-    float worldMarkerSize = getScreenMarkerSize(getLineWidth(${o(l,"pos")})) * screenToWorldRatio;
+    float worldMarkerSize = getScreenMarkerSize(getLineWidth(${t(l,"pos")})) * screenToWorldRatio;
     float segmentLen = length(pos - other);
     return worldMarkerSize > maxSegmentLengthFraction * segmentLen;
   }
@@ -20,6 +21,6 @@ import{markerSizePerLineWidth as e}from"../../../../support/engineContent/marker
   float getWorldMarkerSize(vec3 pos) {
     float distanceToCamera = length(pos);
     float screenToWorldRatio = perRenderPixelRatio * distanceToCamera * 0.5;
-    return getScreenMarkerSize(getLineWidth(${o(l,"pos")})) * screenToWorldRatio;
+    return getScreenMarkerSize(getLineWidth(${t(l,"pos")})) * screenToWorldRatio;
   }
   `))}export{i as MarkerSizing};

package/views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js

@@ -1,10 +1,10 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{glsl as e}from"../../shaderModules/glsl.js";function r(r,{spherical:n}){r.vertex.code.add(n?"vec3 getLocalUp(in vec3 pos, in vec3 origin) { return normalize(pos + origin); }":"vec3 getLocalUp(in vec3 pos, in vec3 origin) { return vec3(0.0, 0.0, 1.0); }"),n?r.vertex.code.add(e`mat3 getTBNMatrix(in vec3 n) {
+import{glsl as e}from"../../shaderModules/glsl.js";function n(n,{spherical:c}){n.code.add(c?"vec3 getLocalUp(in vec3 pos, in vec3 origin) { return normalize(pos + origin); }\n         vec3 getLocalUp(in vec3 pos) { return normalize(pos); }":"vec3 getLocalUp(in vec3 pos, in vec3 origin) { return vec3(0.0, 0.0, 1.0); }\n         vec3 getLocalUp(in vec3 pos) { return vec3(0.0, 0.0, 1.0); }"),c?n.code.add(e`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);
-}`):r.vertex.code.add(e`mat3 getTBNMatrix(in vec3 n) {
+}`):n.code.add(e`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{r as NormalUtils};
+}`)}export{n as NormalUtils};

package/views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js

@@ -1,11 +1,6 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{glsl as a}from"../../shaderModules/glsl.js";function r(r,e){const m=r.fragment;switch(m.code.add(a`struct ShadingNormalParameters {
-vec3 normalView;
-vec3 viewDirection;
-} shadingParams;`),e.doubleSidedMode){case 0:m.code.add(a`vec3 shadingNormal(ShadingNormalParameters params) {
-return normalize(params.normalView);
-}`);break;case 1:m.code.add(a`vec3 shadingNormal(ShadingNormalParameters params) {
-return dot(params.normalView, params.viewDirection) > 0.0 ? normalize(-params.normalView) : normalize(params.normalView);
-}`);break;case 2:m.code.add(a`vec3 shadingNormal(ShadingNormalParameters params) {
-return gl_FrontFacing ? normalize(params.normalView) : normalize(-params.normalView);
-}`);break;default:e.doubleSidedMode;case 3:}}export{r as Normals};
+import{glsl as e}from"../../shaderModules/glsl.js";function o(o,r){const i=o.fragment;switch(r.doubleSidedMode){case 0:i.code.add("vec3 shadingNormal(vec3 normalView, vec3 viewDirection) { return normalize(normalView); }");break;case 1:i.code.add(e`vec3 shadingNormal(vec3 normalView, vec3 viewDirection) {
+return dot(normalView, viewDirection) > 0.0 ? normalize(-normalView) : normalize(normalView);
+}`);break;case 2:i.code.add(e`vec3 shadingNormal(vec3 normalView, vec3 viewDirection) {
+return gl_FrontFacing ? normalize(normalView) : normalize(-normalView);
+}`);break;default:r.doubleSidedMode;case 3:}}export{o as Normals};

package/views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js

@@ -1,48 +1,17 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{AnalyticalSkyModel as e}from"./AnalyticalSkyModel.glsl.js";import{Gamma as o}from"./Gamma.glsl.js";import{PiUtils as t}from"./PiUtils.glsl.js";import{glsl as n}from"../../shaderModules/glsl.js";function a(a,i){a.include(o),a.include(t),1!==i.pbrMode&&2!==i.pbrMode&&5!==i.pbrMode&&6!==i.pbrMode||(a.code.add(n`float normalDistribution(float NdotH, float roughness)
+import{AnalyticalSkyModel as e}from"./AnalyticalSkyModel.glsl.js";import{Gamma as o}from"./Gamma.glsl.js";import{pbrGlobals as t}from"./pbrGlobals.glsl.js";import{pbrShadingInfo as n}from"./pbrShadingInfo.glsl.js";import{PiUtils as r}from"./PiUtils.glsl.js";import{glsl as a}from"../../shaderModules/glsl.js";function i(i,l){i.include(o),i.include(r),i.include(n),i.include(t),1!==l.pbrMode&&2!==l.pbrMode&&5!==l.pbrMode&&6!==l.pbrMode||(i.code.add(a`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.code.add(n`const vec4 c0 = vec4(-1.0, -0.0275, -0.572,  0.022);
+}`),i.code.add(a`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;
-}`),a.code.add(n`struct PBRShadingInfo
-{
-float NdotV;
-float NdotL;
-float LdotH;
-float NdotUP;
-float RdotUP;
-float NdotAmbDir;
-float NdotH_Horizon;
-float NdotH;
-vec3 skyRadianceToSurface;
-vec3 groundRadianceToSurface;
-vec3 skyIrradianceToSurface;
-vec3 groundIrradianceToSurface;
-vec3 reflectedView;
-float averageAmbientRadiance;
-vec3 albedoLinear;
-vec3 f0;
-vec3 f90;
-vec3 diffuseColor;
-float metalness;
-float roughness;
-};`),a.code.add(n`void calculateCommonInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
-vec3 h = normalize(mainLightDirection - viewDirection);
-inputs.NdotV = clamp(abs(dot(normal, -viewDirection)), 0.001, 1.0);
-inputs.NdotUP = clamp(dot(normal, upDirection), -1.0, 1.0);
-inputs.reflectedView = normalize(reflect(-viewDirection, normal));
-inputs.RdotUP = clamp(dot(inputs.reflectedView, upDirection), -1.0, 1.0);
-inputs.albedoLinear = linearizeGamma(albedo);
-inputs.NdotH = clamp(dot(normal, h), 0.0, 1.0);
-inputs.NdotL = clamp(dot(normal, mainLightDirection), 0.001, 1.0);
-}`)),1!==i.pbrMode&&2!==i.pbrMode||(a.include(e),a.code.add(n`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
+}`)),1!==l.pbrMode&&2!==l.pbrMode||(i.include(e),i.code.add(a`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
 vec3 indirectDiffuse = evaluateDiffuseIlluminationHemisphere(inputs.groundIrradianceToSurface, inputs.skyIrradianceToSurface, inputs.NdotUP);
 vec3 indirectSpecular = evaluateSpecularIlluminationHemisphere(inputs.groundRadianceToSurface, inputs.skyRadianceToSurface, inputs.RdotUP, inputs.roughness);
 vec3 diffuseComponent = inputs.diffuseColor * indirectDiffuse * INV_PI;
@@ -50,20 +19,13 @@ 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.code.add(n`void calculatePBRInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo, vec3 mrr) {
-calculateCommonInputs(inputs, normal, viewDirection, upDirection, albedo);
-inputs.metalness = mrr[0];
-inputs.roughness = clamp(mrr[1] * mrr[1], 0.001, 0.99);
-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);
-}`)),5!==i.pbrMode&&6!==i.pbrMode||a.code.add(n`const vec3 fresnelReflectionSimplified = vec3(0.04);
+}`)),5!==l.pbrMode&&6!==l.pbrMode||i.code.add(a`const vec3 fresnelReflectionSimplified = vec3(0.04);
 void calculateSimplifiedInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
 calculateCommonInputs(inputs, normal, viewDirection, upDirection, albedo);
 float lightness = 0.3 * inputs.albedoLinear[0] + 0.5 * inputs.albedoLinear[1] + 0.2 * inputs.albedoLinear[2];
 inputs.f0 = (0.85 * lightness + 0.15) * fresnelReflectionSimplified;
 inputs.f90 =  vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
-}`)}function i(e,o){e.include(t),e.code.add(n`
+}`)}function l(e,o){e.include(r),e.code.add(a`
     struct PBRShadingWater {
       float NdotL;   // cos angle between normal and light direction
       float NdotV;   // cos angle between normal and view direction
@@ -74,16 +36,16 @@ inputs.f90 =  vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
     };
 
     float dtrExponent = ${o.useCustomDTRExponentForWater?"2.2":"2.0"};
-  `),e.code.add(n`vec3 fresnelReflection(float angle, vec3 f0, float f90) {
+  `),e.code.add(a`vec3 fresnelReflection(float angle, vec3 f0, float f90) {
 return f0 + (f90 - f0) * pow(1.0 - angle, 5.0);
-}`),e.code.add(n`float normalDistributionWater(float NdotH, float roughness) {
+}`),e.code.add(a`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.code.add(n`float geometricOcclusionKelemen(float LoH) {
+}`),e.code.add(a`float geometricOcclusionKelemen(float LoH) {
 return 0.25 / (LoH * LoH);
-}`),e.code.add(n`vec3 brdfSpecularWater(in PBRShadingWater props, float roughness, vec3 F0, float F0Max) {
+}`),e.code.add(a`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);
@@ -91,4 +53,4 @@ float diffusionSunHaze = mix(roughness + 0.045, roughness + 0.385, 1.0 - props.V
 float strengthSunHaze  = 1.2;
 float dSunHaze = normalDistributionWater(props.NdotH, diffusionSunHaze) * strengthSunHaze;
 return ((dSun + dSunHaze) * V) * F;
-}`)}export{a as PhysicallyBasedRendering,i as PhysicallyBasedRenderingWater};
+}`)}export{i as PhysicallyBasedRendering,l as PhysicallyBasedRenderingWater};

package/views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js

@@ -1,26 +1,20 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{VertexTextureCoordinates as e}from"../attributes/VertexTextureCoordinates.glsl.js";import{Float3DrawUniform as o}from"../../shaderModules/Float3DrawUniform.js";import{Float3PassUniform as s}from"../../shaderModules/Float3PassUniform.js";import{glsl as r,If as t}from"../../shaderModules/glsl.js";import{Texture2DDrawUniform as c}from"../../shaderModules/Texture2DDrawUniform.js";import{Texture2DPassUniform as a}from"../../shaderModules/Texture2DPassUniform.js";import{schematicMRRFactors as l}from"../../../materials/pbrUtils.js";import{NoParameters as u}from"../../../../../webgl/NoParameters.js";class i extends u{constructor(e,o){super(),this.textureOcclusion=e,this.textureMetallicRoughness=o,this.mrrFactors=l}}function n(l,u){const i=u.pbrMode,n=l.fragment;switch(i){case 5:case 3:case 4:case 6:return void n.code.add(r`void applyPBRFactors() {}`);case 0:case 7:return void n.code.add(r`void applyPBRFactors() {}
-float getBakedOcclusion() { return 1.0; }`);case 2:return void n.code.add(r`vec3 mrr = vec3(0.0, 0.6, 0.2);
-float occlusion = 1.0;
+import{VertexTextureCoordinates as e}from"../attributes/VertexTextureCoordinates.glsl.js";import{pbrGlobals as o}from"./pbrGlobals.glsl.js";import{Float3DrawUniform as s}from"../../shaderModules/Float3DrawUniform.js";import{Float3PassUniform as r}from"../../shaderModules/Float3PassUniform.js";import{glsl as t,If as c}from"../../shaderModules/glsl.js";import{Texture2DDrawUniform as a}from"../../shaderModules/Texture2DDrawUniform.js";import{Texture2DPassUniform as l}from"../../shaderModules/Texture2DPassUniform.js";import{schematicMRRFactors as u}from"../../../materials/pbrUtils.js";import{NoParameters as i}from"../../../../../webgl/NoParameters.js";class n extends i{constructor(e,o){super(),this.textureOcclusion=e,this.textureMetallicRoughness=o,this.mrrFactors=u}}function d(u,i){const n=i.pbrMode,d=u.fragment;switch(n){case 5:case 3:case 4:case 6:return void d.code.add(t`void applyPBRFactors() {}`);case 0:case 7:return void d.code.add(t`void applyPBRFactors() {}
+float getBakedOcclusion() { return 1.0; }`);case 2:return void d.code.add(t`float occlusion = 1.0;
 void applyPBRFactors() {}
-float getBakedOcclusion() { return 1.0; }`);case 1:{const{hasMetallicRoughnessTexture:i,hasMetallicRoughnessTextureTransform:d,hasOcclusionTexture:m,hasOcclusionTextureTransform:p,bindType:h}=u;(i||m)&&l.include(e,u),n.code.add(r`vec3 mrr;
-float occlusion;`),i&&n.uniforms.add(1===h?new a("texMetallicRoughness",e=>e.textureMetallicRoughness):new c("texMetallicRoughness",e=>e.textureMetallicRoughness)),m&&n.uniforms.add(1===h?new a("texOcclusion",e=>e.textureOcclusion):new c("texOcclusion",e=>e.textureOcclusion)),n.uniforms.add(1===h?new s("mrrFactors",e=>e.mrrFactors):new o("mrrFactors",e=>e.mrrFactors)),n.code.add(r`
-        ${t(i,r`void applyMetallicRoughness(vec2 uv) {
-                vec3 metallicRoughness = textureLookup(texMetallicRoughness, uv).rgb;
-                mrr[0] *= metallicRoughness.b;
-                mrr[1] *= metallicRoughness.g;
-              }`)}
+float getBakedOcclusion() { return 1.0; }`);case 1:{const{hasMetallicRoughnessTexture:n,hasMetallicRoughnessTextureTransform:m,hasOcclusionTexture:p,hasOcclusionTextureTransform:h,bindType:f}=i;(n||p)&&u.include(e,i),d.code.add("float occlusion;"),n&&d.uniforms.add(1===f?new l("texMetallicRoughness",e=>e.textureMetallicRoughness):new a("texMetallicRoughness",e=>e.textureMetallicRoughness)),p&&d.uniforms.add(1===f?new l("texOcclusion",e=>e.textureOcclusion):new a("texOcclusion",e=>e.textureOcclusion)),d.uniforms.add(1===f?new r("mrrFactors",e=>e.mrrFactors):new s("mrrFactors",e=>e.mrrFactors)),d.include(o),n&&d.code.add(t`void applyMetallicRoughness(vec2 uv) {
+vec3 metallicRoughness = textureLookup(texMetallicRoughness, uv).rgb;
+mrr[0] *= metallicRoughness.b;
+mrr[1] *= metallicRoughness.g;
+}`),p&&d.code.add("void applyOcclusion(vec2 uv) { occlusion *= textureLookup(texOcclusion, uv).r; }"),d.code.add(t`
+          float getBakedOcclusion() {
+            return ${p?"occlusion":"1.0"};
+          }
 
-        ${t(m,"void applyOcclusion(vec2 uv) { occlusion *= textureLookup(texOcclusion, uv).r; }")}
+          void applyPBRFactors() {
+            mrr = mrrFactors;
+            occlusion = 1.0;
 
-        float getBakedOcclusion() {
-          return ${m?"occlusion":"1.0"};
-        }
-
-        void applyPBRFactors() {
-          mrr = mrrFactors;
-          occlusion = 1.0;
-
-          ${t(i,`applyMetallicRoughness(${d?"metallicRoughnessUV":"vuv0"});`)}
-          ${t(m,`applyOcclusion(${p?"occlusionUV":"vuv0"});`)}
-        }`)}}}export{i as PBRRenderingParameters,n as PhysicallyBasedRenderingParameters};
+            ${c(n,`applyMetallicRoughness(${m?"metallicRoughnessUV":"vuv0"});`)}
+            ${c(p,`applyOcclusion(${h?"occlusionUV":"vuv0"});`)}
+          }`)}}}export{n as PBRRenderingParameters,d as PhysicallyBasedRenderingParameters};

package/views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js

@@ -1,18 +1,18 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{create as a}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{ForwardLinearDepthToReadShadowMap as o}from"../ForwardLinearDepthToReadShadowMap.glsl.js";import{calculateUVZShadowPass as e,calculateUVZShadowDraw as t,ReadShadowMapOrigin as r}from"./calculateUVZShadow.glsl.js";import{ShadowmapFiltering as d}from"./ShadowmapFiltering.glsl.js";import{FloatBindUniform as i}from"../../shaderModules/FloatBindUniform.js";import{If as n,glsl as s}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as l}from"../../shaderModules/Texture2DBindUniform.js";import{Texture2DShadowBindUniform as h}from"../../shaderModules/Texture2DShadowBindUniform.js";import{NoParameters as c}from"../../../../../webgl/NoParameters.js";class u extends r{}class w extends c{constructor(){super(...arguments),this.origin=a()}}function f(a,o){o.receiveShadows&&a.fragment.include(e),g(a,o)}function m(a,o){o.receiveShadows&&a.fragment.include(t),g(a,o)}function g(a,e){a.fragment.uniforms.add(new i("lightingGlobalFactor",a=>a.lighting.globalFactor));const{hasShadowHighlights:t,receiveShadows:r,spherical:d}=e;a.include(o,e),r&&p(a.fragment,t),a.fragment.code.add(s`
+import{__decorate as o}from"tslib";import{ForwardLinearDepthConfiguration as a}from"../ForwardLinearDepth.glsl.js";import{ForwardLinearDepthToReadShadowMap as e}from"../ForwardLinearDepthToReadShadowMap.glsl.js";import{calculateUVZShadowPass as t,calculateUVZShadowDraw as d,ReadShadowMapOrigin as r}from"./calculateUVZShadow.glsl.js";import{ShadowmapFiltering as i}from"./ShadowmapFiltering.glsl.js";import{FloatBindUniform as s}from"../../shaderModules/FloatBindUniform.js";import{If as h,glsl as n}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as l}from"../../shaderModules/Texture2DBindUniform.js";import{Texture2DShadowBindUniform as c}from"../../shaderModules/Texture2DShadowBindUniform.js";import{parameter as u}from"../../shaderTechnique/ShaderTechniqueConfiguration.js";class w extends r{}class g extends r{}class f extends a{constructor(){super(...arguments),this.hasShadowHighlights=!1}}function m(o,a){a.receiveShadows&&o.fragment.include(t),S(o,a)}function p(o,a){a.receiveShadows&&o.fragment.include(d),S(o,a)}function S(o,a){o.include(e,a);const{hasShadowHighlights:t,receiveShadows:d,spherical:r}=a;d&&v(o.fragment,t),o.fragment.uniforms.add(new s("lightingGlobalFactor",({lighting:o})=>o.globalFactor)).code.add(n`
     float readShadow(float additionalAmbientScale, vec3 vpos) {
-      return ${r?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth))":n(d,"lightingGlobalFactor * (1.0 - additionalAmbientScale)","0.0")};
+      return ${d?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth))":h(r,"lightingGlobalFactor * (1.0 - additionalAmbientScale)","0.0")};
     }
-  `)}function p(a,o){v(a,o),S(a)}function S(a){a.code.add(s`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
+  `)}function v(o,a){x(o,a),M(o)}function M(o){o.code.add(n`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
 vec3 uvzShadow = calculateUVZShadow(_worldPos, _linearDepth, textureSize(shadowMap, 0));
 return readShadowMaps(uvzShadow);
-}`)}function v(a,o){a.include(d),a.uniforms.add(M()),o&&a.uniforms.add(new l("shadowHighlight",({shadowHighlight:a})=>a?.getTexture())),a.code.add(s`
+}`)}function x(o,a){o.include(i),o.uniforms.add(F()),a&&o.uniforms.add(new l("shadowHighlight",({shadowHighlight:o})=>o?.getTexture())),o.code.add(n`
     float readShadowMaps(const in vec3 uvzShadow) {
       if (uvzShadow.z < 0.0) {
         return 0.0;
       }
 
       float shadow1 = readShadowMapUVZ(uvzShadow, shadowMap);
-      ${n(o,"float shadow2 = texelFetch(shadowHighlight, ivec2(gl_FragCoord.xy), 0).r;\n         return shadow1 > shadow2 ? shadow1 : shadow2;","return shadow1;")}
+      ${h(a,"float shadow2 = texelFetch(shadowHighlight, ivec2(gl_FragCoord.xy), 0).r;\n         return shadow1 > shadow2 ? shadow1 : shadow2;","return shadow1;")}
     }
-  `)}function M(){return new h("shadowMap",({shadowMap:a})=>a.getOutput(5)??a.getOutput(7))}export{m as ReadShadowMapDrawFragment,u as ReadShadowMapDrawParameters,f as ReadShadowMapPassFragment,w as ReadShadowMapPassParameters,v as readShadowMapsFragment};
+  `)}function F(){return new c("shadowMap",({shadowMap:o})=>o.getOutput(5)??o.getOutput(7))}o([u()],f.prototype,"hasShadowHighlights",void 0);export{f as ReadShadowMapConfiguration,p as ReadShadowMapDrawFragment,w as ReadShadowMapDrawParameters,m as ReadShadowMapPassFragment,g as ReadShadowMapPassParameters,x as readShadowMapsFragment};

package/views/3d/webgl-engine/core/shaderLibrary/shading/calculateUVZShadow.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{create as a}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{Float4BindUniform as e}from"../../shaderModules/Float4BindUniform.js";import{glsl as o}from"../../shaderModules/glsl.js";import{IntegerBindUniform as s}from"../../shaderModules/IntegerBindUniform.js";import{Matrix4sDrawUniform as i}from"../../shaderModules/Matrix4sDrawUniform.js";import{Matrix4sPassUniform as t}from"../../shaderModules/Matrix4sPassUniform.js";import{NoParameters as r}from"../../../../../webgl/NoParameters.js";class d extends r{constructor(){super(...arguments),this.origin=a()}}function c(a){a.uniforms.add(new t("shadowMapMatrix",(a,e)=>e.shadowMap.getShadowMapMatrices(a.origin),4)),a.include(l)}function n(a){a.uniforms.add(new i("shadowMapMatrix",(a,e)=>e.shadowMap.getShadowMapMatrices(a.origin),4)),a.include(l)}function l(a){a.uniforms.add(new e("cascadeDistances",a=>a.shadowMap.cascadeDistances),new s("numCascades",a=>a.shadowMap.numCascades)),a.code.add(p)}const p=o`const vec3 invalidShadowmapUVZ = vec3(0.0, 0.0, -1.0);
+import{create as a}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{Float4BindUniform as e}from"../../shaderModules/Float4BindUniform.js";import{glsl as o}from"../../shaderModules/glsl.js";import{IntegerBindUniform as s}from"../../shaderModules/IntegerBindUniform.js";import{Matrix4sDrawUniform as i}from"../../shaderModules/Matrix4sDrawUniform.js";import{Matrix4sPassUniform as r}from"../../shaderModules/Matrix4sPassUniform.js";import{NoParameters as t}from"../../../../../webgl/NoParameters.js";class d extends t{constructor(){super(...arguments),this.origin=a()}}function c(a){a.uniforms.add(new r("shadowMapMatrix",({origin:a},e)=>e.shadowMap.getShadowMapMatrices(a),4)),a.include(l)}function n(a){a.uniforms.add(new i("shadowMapMatrix",({origin:a},e)=>e.shadowMap.getShadowMapMatrices(a),4)),a.include(l)}function l(a){a.uniforms.add(new e("cascadeDistances",a=>a.shadowMap.cascadeDistances),new s("numCascades",a=>a.shadowMap.numCascades)).code.add(o`const vec3 invalidShadowmapUVZ = vec3(0.0, 0.0, -1.0);
 vec3 lightSpacePosition(vec3 _vpos, mat4 mat) {
 vec4 lv = mat * vec4(_vpos, 1.0);
 lv.xy /= lv.w;
@@ -10,7 +10,9 @@ float xScale = float(textureSize.y) / float(textureSize.x);
 return vec2((float(i) + lvpos.x) * xScale, lvpos.y);
 }
 vec3 calculateUVZShadow(in vec3 _worldPos, in float _linearDepth, in ivec2 shadowMapSize) {
-int i = _linearDepth < cascadeDistances[1] ? 0 : _linearDepth < cascadeDistances[2] ? 1 : _linearDepth < cascadeDistances[3] ? 2 : 3;
+int i = _linearDepth < cascadeDistances[1] ? 0 :
+_linearDepth < cascadeDistances[2] ? 1 :
+_linearDepth < cascadeDistances[3] ? 2 : 3;
 if (i >= numCascades) {
 return invalidShadowmapUVZ;
 }
@@ -21,4 +23,4 @@ return invalidShadowmapUVZ;
 }
 vec2 uvShadow = cascadeCoordinates(i, shadowMapSize, lvpos);
 return vec3(uvShadow, lvpos.z);
-}`;export{d as ReadShadowMapOrigin,n as calculateUVZShadowDraw,c as calculateUVZShadowPass};
+}`)}export{d as ReadShadowMapOrigin,n as calculateUVZShadowDraw,c as calculateUVZShadowPass};

package/views/3d/webgl-engine/core/shaderLibrary/shading/pbrGlobals.glsl.js

@@ -0,0 +1,19 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import{Gamma as i}from"./Gamma.glsl.js";import{mainLightDirection as e}from"./MainLighting.glsl.js";import{pbrShadingInfo as n}from"./pbrShadingInfo.glsl.js";import{glsl as t}from"../../shaderModules/glsl.js";function o(o){o.include(n),o.include(i),o.uniforms.add(e).code.add(t`void calculateCommonInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
+vec3 h = normalize(mainLightDirection - viewDirection);
+inputs.NdotV = clamp(abs(dot(normal, -viewDirection)), 0.001, 1.0);
+inputs.NdotUP = clamp(dot(normal, upDirection), -1.0, 1.0);
+inputs.reflectedView = normalize(reflect(-viewDirection, normal));
+inputs.RdotUP = clamp(dot(inputs.reflectedView, upDirection), -1.0, 1.0);
+inputs.albedoLinear = linearizeGamma(albedo);
+inputs.NdotH = clamp(dot(normal, h), 0.0, 1.0);
+inputs.NdotL = clamp(dot(normal, mainLightDirection), 0.001, 1.0);
+}`),o.code.add(t`vec3 mrr = vec3(0.0, 0.6, 0.2);
+void calculatePBRInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
+calculateCommonInputs(inputs, normal, viewDirection, upDirection, albedo);
+inputs.metalness = mrr[0];
+inputs.roughness = clamp(mrr[1] * mrr[1], 0.001, 0.99);
+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);
+}`)}export{o as pbrGlobals};

package/views/3d/webgl-engine/core/shaderLibrary/shading/pbrShadingInfo.glsl.js

@@ -0,0 +1,24 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import{glsl as o}from"../../shaderModules/glsl.js";function e(e){e.code.add(o`struct PBRShadingInfo
+{
+float NdotV;
+float NdotL;
+float LdotH;
+float NdotUP;
+float RdotUP;
+float NdotAmbDir;
+float NdotH_Horizon;
+float NdotH;
+vec3 skyRadianceToSurface;
+vec3 groundRadianceToSurface;
+vec3 skyIrradianceToSurface;
+vec3 groundIrradianceToSurface;
+vec3 reflectedView;
+float averageAmbientRadiance;
+vec3 albedoLinear;
+vec3 f0;
+vec3 f90;
+vec3 diffuseColor;
+float metalness;
+float roughness;
+};`)}export{e as pbrShadingInfo};

package/views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";import{hasArea as o,width as r,height as t}from"../../../../../../geometry/support/aaBoundingRect.js";import{isColor as l}from"../ShaderOutput.js";import{addMainLightDirection as i,addMainLightIntensity as a}from"../shading/MainLighting.glsl.js";import{WaterColor as c}from"../shading/WaterColor.glsl.js";import{BlendColorsPremultiplied as n}from"../util/BlendColorsPremultiplied.glsl.js";import{Float4DrawUniform as s}from"../../shaderModules/Float4DrawUniform.js";import{FloatPassUniform as v}from"../../shaderModules/FloatPassUniform.js";import{glsl as d}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as u}from"../../shaderModules/Texture2DPassUniform.js";import{Texture2DUintPassUniform as x}from"../../shaderModules/Texture2DUintPassUniform.js";import{Uniform as m}from"../../../../../webgl/Uniform.js";function p(e,o){const{vertex:r,fragment:t}=e;r.uniforms.add(new s("overlayTexOffset",(e,r)=>T(o.spherical,e,r)),new s("overlayTexScale",(e,r)=>V(o.spherical,e,r))),t.uniforms.add(new s("overlayTexOffset",(e,r)=>T(o.spherical,e,r)),new s("overlayTexScale",(e,r)=>V(o.spherical,e,r))),t.constants.add("overlayOpacity","float",1),t.uniforms.add(new u("ovColorTex",(e,o)=>y(e,o))),O(e,o)}function y(e,o){const r=f(e,o);return null!=r?o.overlay?.getTexture(r):null}function f(e,o){return 0===e.identifier?l(o.output)?!e.occludedGround||o.overlay?.allSourcesOccluders?1:4:3===o.output||4===o.output?1:11===o.output?5:null:2===e.identifier?2:null}function C(e,o){const{vertex:r,fragment:t}=e;r.uniforms.add(new w("overlayTexOffset"),new w("overlayTexScale")),t.uniforms.add(new v("overlayOpacity",e=>e.overlayOpacity)),10!==o.output&&t.uniforms.add(new u("ovColorTex",(e,o)=>o.overlay?.getTexture(e.overlayContent))),O(e,o)}function g(e,o){switch(e){case 0:case 1:case 2:return 9!==o.slot||o.overlay?.allSourcesOccluders?0:4;case 3:case 4:return 0;case 10:return 2;case 5:case 7:case 8:case 9:return null;case 11:return 5}return null}function O(e,o){const{hasWater:r,output:t}=o;r&&e.include(c,o);const{vertex:l,fragment:s,varyings:v}=e;v.add("vtcOverlay","vec4");const u=10===t;l.code.add(d`void setOverlayVTC(in vec2 uv) {
+import{create as e}from"../../../../../../core/libs/gl-matrix-2/factories/vec4f64.js";import{hasArea as o,width as r,height as t}from"../../../../../../geometry/support/aaBoundingRect.js";import{isColor as l}from"../ShaderOutput.js";import{mainLightDirection as i,mainLightIntensity as a}from"../shading/MainLighting.glsl.js";import{WaterColor as c}from"../shading/WaterColor.glsl.js";import{BlendColorsPremultiplied as n}from"../util/BlendColorsPremultiplied.glsl.js";import{Float4DrawUniform as s}from"../../shaderModules/Float4DrawUniform.js";import{FloatPassUniform as v}from"../../shaderModules/FloatPassUniform.js";import{glsl as d}from"../../shaderModules/glsl.js";import{Texture2DPassUniform as u}from"../../shaderModules/Texture2DPassUniform.js";import{Texture2DUintPassUniform as x}from"../../shaderModules/Texture2DUintPassUniform.js";import{Uniform as m}from"../../../../../webgl/Uniform.js";function p(e,o){const{vertex:r,fragment:t}=e;r.uniforms.add(new s("overlayTexOffset",(e,r)=>T(o.spherical,e,r)),new s("overlayTexScale",(e,r)=>V(o.spherical,e,r))),t.uniforms.add(new s("overlayTexOffset",(e,r)=>T(o.spherical,e,r)),new s("overlayTexScale",(e,r)=>V(o.spherical,e,r))),t.constants.add("overlayOpacity","float",1),t.uniforms.add(new u("ovColorTex",(e,o)=>y(e,o))),O(e,o)}function y(e,o){const r=f(e,o);return null!=r?o.overlay?.getTexture(r):null}function f(e,o){return 0===e.identifier?l(o.output)?!e.occludedGround||o.overlay?.allSourcesOccluders?1:4:3===o.output||4===o.output?1:11===o.output?5:null:2===e.identifier?2:null}function C(e,o){const{vertex:r,fragment:t}=e;r.uniforms.add(new w("overlayTexOffset"),new w("overlayTexScale")),t.uniforms.add(new v("overlayOpacity",e=>e.overlayOpacity)),10!==o.output&&t.uniforms.add(new u("ovColorTex",(e,o)=>o.overlay?.getTexture(e.overlayContent))),O(e,o)}function g(e,o){switch(e){case 0:case 1:case 2:return 9!==o.slot||o.overlay?.allSourcesOccluders?0:4;case 3:case 4:return 0;case 10:return 2;case 5:case 7:case 8:case 9:return null;case 11:return 5}return null}function O(e,o){const{hasWater:r,output:t}=o;r&&e.include(c,o);const{vertex:l,fragment:s,varyings:v}=e;v.add("vtcOverlay","vec4");const u=10===t;l.code.add(d`void setOverlayVTC(in vec2 uv) {
 vtcOverlay = vec4(uv, uv) * overlayTexScale + overlayTexOffset;
 }`),s.code.add(d`bool isValid(vec2 uv, vec2 dxdy) {
 return (uv.x >= 0.0 + dxdy.x) && (uv.x <= 1.0 - dxdy.x) && (uv.y >= 0.0 + dxdy.y) && (uv.y <= 1.0 - dxdy.y);
@@ -51,10 +51,10 @@ return mix(color1 * float(isValid1), color0, float(isValid0));
 }
 vec4 getOverlayColorTexel() {
 return getOverlayColorTexel(vtcOverlay);
-}`)),r&&(i(s),a(s),s.code.add(d`vec4 getOverlayWaterColor(vec4 maskInput, vec4 colorInput, vec3 vposEyeDir,
+}`)),r&&s.uniforms.add(i,a).code.add(d`vec4 getOverlayWaterColor(vec4 maskInput, vec4 colorInput, vec3 vposEyeDir,
 float shadow, vec3 localUp, mat3 tbn, vec3 position, vec3 positionWorld) {
 vec3 n = normalize(tbn *  (2.0 * maskInput.rgb - vec3(1.0)));
 vec3 v = vposEyeDir;
 vec3 final = getWaterColor(n, v, mainLightDirection, colorInput.rgb, mainLightIntensity, localUp, 1.0 - shadow, maskInput.w, position, positionWorld);
 return vec4(final, colorInput.w);
-}`))}function h(e,o){return e.overlay?.overlays[o]?.extent}function T(e,l,i){const a=b,c=e&&!l.useENUForGlobalOverlayUV,n=c?0:l.toMapSpace[0],s=c?0:l.toMapSpace[1],v=(e,l)=>{const c=h(i,l);o(c)&&(a[e+0]=(n-c[0])/r(c),a[e+1]=(s-c[1])/t(c))};return v(0,0),v(2,1),a}function V(e,l,i){const a=b,c=e&&!l.useENUForGlobalOverlayUV,n=c?1:l.toMapSpace[2],s=c?1:l.toMapSpace[3],v=(e,l)=>{const c=h(i,l);o(c)&&(a[e+0]=n/r(c),a[e+1]=s/t(c))};return v(0,0),v(2,1),a}const b=e();class w extends m{constructor(e){super(e,"vec4")}}export{p as OverlayIM,C as OverlayTerrain,y as getIMColorTexture,g as getOverlayContentForOutputTerrain};
+}`)}function h(e,o){return e.overlay?.overlays[o]?.extent}function T(e,l,i){const a=b,c=e&&!l.useENUForGlobalOverlayUV,n=c?0:l.toMapSpace[0],s=c?0:l.toMapSpace[1],v=(e,l)=>{const c=h(i,l);o(c)&&(a[e+0]=(n-c[0])/r(c),a[e+1]=(s-c[1])/t(c))};return v(0,0),v(2,1),a}function V(e,l,i){const a=b,c=e&&!l.useENUForGlobalOverlayUV,n=c?1:l.toMapSpace[2],s=c?1:l.toMapSpace[3],v=(e,l)=>{const c=h(i,l);o(c)&&(a[e+0]=n/r(c),a[e+1]=s/t(c))};return v(0,0),v(2,1),a}const b=e();class w extends m{constructor(e){super(e,"vec4")}}export{p as OverlayIM,C as OverlayTerrain,y as getIMColorTexture,g as getOverlayContentForOutputTerrain};