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

package/chunks/ChapmanAtmosphere.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{Gamma as e}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{addMainLightDirection as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{BooleanPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/BooleanPassUniform.js";import{Float2PassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as d}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{getHeightParameters as c}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanApproximation.glsl.js";import{ChapmanRaymarching as g}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanRaymarching.glsl.js";import{ScreenSpacePassAtmosphere as u}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{SphereIntersect as h}from"../views/3d/webgl-engine/shaders/SphereIntersect.glsl.js";import{ToneMapping as p}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";function w(){const w=new f;w.include(u);const{fragment:y}=w;return r(y),y.include(e),y.include(h),y.include(p),y.include(g,!1),y.uniforms.add(new a("reduced",({reduced:e})=>e),new l("heightParameters",5,(e,r)=>c(r,e)),new o("radii",e=>e.radii),new i("cameraPosition",e=>e.camera.eye),new s("innerFadeDistance",e=>e.innerFadeDistance),new n("undergroundColor",e=>e.undergroundColor),new s("altitudeFade",e=>e.altitudeFade)).code.add(d`vec4 applyUndergroundAtmosphere(vec3 rayDir, vec3 lightDirection, vec4 fragColor) {
+import{Gamma as e}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{mainLightDirection as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{BooleanPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/BooleanPassUniform.js";import{Float2PassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3BindUniform as i}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as d}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{getHeightParameters as c}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanApproximation.glsl.js";import{ChapmanRaymarching as g}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanRaymarching.glsl.js";import{ScreenSpacePassAtmosphere as u}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{SphereIntersect as h}from"../views/3d/webgl-engine/shaders/SphereIntersect.glsl.js";import{ToneMapping as p}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";function w(){const w=new f;w.include(u);const{fragment:y}=w;return y.include(e),y.include(h),y.include(p),y.include(g,!1),y.uniforms.add(r,new a("reduced",({reduced:e})=>e),new l("heightParameters",5,(e,r)=>c(r,e)),new o("radii",e=>e.radii),new i("cameraPosition",e=>e.camera.eye),new s("innerFadeDistance",e=>e.innerFadeDistance),new n("undergroundColor",e=>e.undergroundColor),new s("altitudeFade",e=>e.altitudeFade)).code.add(d`vec4 applyUndergroundAtmosphere(vec3 rayDir, vec3 lightDirection, vec4 fragColor) {
 float rayPlanetDistance = heightParameters[3];
 vec2 rayPlanetIntersect = sphereIntersect(cameraPosition, rayDir, rayPlanetDistance);
 if (!((rayPlanetIntersect.x <= rayPlanetIntersect.y) && rayPlanetIntersect.y > 0.0)) {

package/chunks/Component.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{ForwardLinearDepthToWriteShadowMap as o}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as r,isShadow as a}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePass as l}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{TextureCoordinateAttribute as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VertexPosition as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js";import{DepthConversion as d}from"../views/3d/webgl-engine/core/shaderLibrary/output/DepthConversion.glsl.js";import{outputDepth as c}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as v}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{OutputHighlightOverlay as g}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlightOverlay.js";import{computeFragmentNormals as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeFragmentNormals.glsl.js";import{ComputeMaterialColor as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeMaterialColor.glsl.js";import{ComputeNormalTextureDraw as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as h,addLightingGlobalFactor as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as y,addMainLightDirection as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{PhysicallyBasedRenderingParameters as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadBaseColorTexture as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{ReadShadowMapPassFragment as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{OverlayIM as O}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as L}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as U}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{FloatDrawUniform as S}from"../views/3d/webgl-engine/core/shaderModules/FloatDrawUniform.js";import{If as M,glsl as j}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as N}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{SnowCover as V}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{alphaCutoff as $}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as T}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as W,sphereDepthInterpolate as D}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as P}from"../views/webgl/ShaderBuilder.js";function R(R){const A=new P,{vertex:F,fragment:z}=A;A.include(s,R),A.include(n,R),A.include(i,R),A.include(t,R),A.include(e,R),A.include(L,R),z.include(l,R),A.include(b,R);const{output:B,pbrMode:E,hasNormalTexture:I,snowCover:_,receiveShadows:H,shadeNormals:G,spherical:k,sphericalSR:q,overlayEnabled:J,componentDataType:K,vertexDiscardMode:Q,renderOccluded:X,isGroundSlice:Y,groundTransparencyMode:Z}=R,ee=r(B),oe=1===E||2===E,re=2===Z,ae=re&&(3===B||4===B);oe&&(A.include(C,R),I&&A.include(p,R));const le=a(B),te=11===B,ie=10===B,ne=4===B,se=le&&1===K,de=W(R),ce=(J||ae)&&k,ve=1===q;(ee||ne)&&(A.include(u,R),z.include($)),(J||ae)&&(z.include(h,R),A.include(O,R),ce?(A.varyings.add("vPositionForDraping","vec3"),z.uniforms.add(new U("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV),new S("overlayMapScaleU",e=>e.toMapSpace[2]),new S("overlayReferenceU",e=>e.toMapSpace[0])),z.constants.add("overlayWorldWidth","float",ve?2*Math.PI*de:360),ve?(z.constants.add("pRadius","float",de),z.constants.add("halfSemiMajorAxis","float",.5*de)):z.constants.add("rad2deg1","float",180/Math.PI),z.constants.add("invRadius","float",1/de).code.add(j`
+import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Material/ComponentData.glsl.js";import{ForwardLinearDepthToWriteShadowMap as o}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{isColor as r,isShadow as a}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePass as l}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{TextureCoordinateAttribute as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VertexNormal as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VertexPosition as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexPosition.glsl.js";import{DepthConversion as d}from"../views/3d/webgl-engine/core/shaderLibrary/output/DepthConversion.glsl.js";import{outputDepth as c}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as v}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{OutputHighlightOverlay as m}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlightOverlay.js";import{computeFragmentNormals as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeFragmentNormals.glsl.js";import{ComputeMaterialColor as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeMaterialColor.glsl.js";import{ComputeNormalTextureDraw as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateSceneLighting as h,addLightingGlobalFactor as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{mainLightIntensity as y,mainLightDirection as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{NormalUtils as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{pbrGlobals as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/pbrGlobals.glsl.js";import{PhysicallyBasedRenderingParameters as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadBaseColorTexture as O}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadBaseColorTexture.glsl.js";import{ReadShadowMapPassFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{OverlayIM as U}from"../views/3d/webgl-engine/core/shaderLibrary/terrain/Overlay.glsl.js";import{DiscardOrAdjustAlphaDraw as S}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{BooleanDrawUniform as M}from"../views/3d/webgl-engine/core/shaderModules/BooleanDrawUniform.js";import{FloatDrawUniform as N}from"../views/3d/webgl-engine/core/shaderModules/FloatDrawUniform.js";import{If as j,glsl as V}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as W}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{SnowCover as $}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{alphaCutoff as D}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as T}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getPlanetRadius as P,sphereDepthInterpolate as R}from"../views/3d/webgl-engine/shaders/SphereDepthInterpolate.glsl.js";import{ShaderBuilder as A}from"../views/webgl/ShaderBuilder.js";function F(F){const z=new A,{vertex:B,fragment:E}=z;z.include(s,F),z.include(n,F),z.include(i,F),z.include(t,F),z.include(e,F),z.include(S,F),E.include(l,F),z.include(O,F);const{output:_,pbrMode:H,hasNormalTexture:I,snowCover:G,receiveShadows:k,shadeNormals:q,spherical:J,sphericalSR:K,overlayEnabled:Q,componentDataType:X,vertexDiscardMode:Y,renderOccluded:Z,isGroundSlice:ee,groundTransparencyMode:oe}=F,re=r(_),ae=1===H||2===H,le=2===oe,te=le&&(3===_||4===_);ae&&(z.include(x,F),I&&z.include(u,F));const ie=a(_),ne=11===_,se=10===_,de=4===_,ce=ie&&1===X,ve=P(F),me=(Q||te)&&J,ge=1===K;(re||de)&&(z.include(p,F),E.include(D)),(Q||te)&&(E.include(h,F),z.include(U,F),me?(z.varyings.add("vPositionForDraping","vec3"),E.uniforms.add(new M("useENUForGlobalOverlayUV",e=>e.useENUForGlobalOverlayUV),new N("overlayMapScaleU",e=>e.toMapSpace[2]),new N("overlayReferenceU",e=>e.toMapSpace[0])),E.constants.add("overlayWorldWidth","float",ge?2*Math.PI*ve:360),ge?(E.constants.add("pRadius","float",ve),E.constants.add("halfSemiMajorAxis","float",.5*ve)):E.constants.add("rad2deg1","float",180/Math.PI),E.constants.add("invRadius","float",1/ve).code.add(V`
           vec2 projectOverlay(vec3 pos) { return pos.xy / (1.0 + invRadius * pos.z); }
 
           vec2 selectOverlayUVNorm(vec2 normUV, float offsetUNorm) {
@@ -31,12 +31,12 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
             float sinLat = wPos.z / oRadius;
             vec2 posMap;
 
-            ${M(ve,j`
+            ${j(ge,V`
                 posMap = vec2(
                   oLonRad * pRadius,
                   halfSemiMajorAxis * log((1.0 + sinLat) / (1.0 - sinLat))
                 );
-              `,j`
+              `,V`
                 float oLatRad = asin(clamp(sinLat,-1.0,1.0));
                 posMap = vec2(rad2deg1 * oLonRad, rad2deg1 * oLatRad);
               `)}
@@ -49,12 +49,12 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
               ? selectLocalOverlayUVs(projectOverlay(vPositionForDraping))
               : selectMapOverlayUVs(overlayMapUVFromWorldPosition());
           }
-        `)):F.code.add("vec2 projectOverlay(vec3 pos) { return pos.xy; }"));const ge=J&&ee&&4===E;ge&&(A.varyings.add("tbnTangent","vec3"),A.varyings.add("tbnBiTangent","vec3"),A.varyings.add("groundNormal","vec3"));const me=0===Q,ue=2===Q;if(A.include(x,R),A.include(o,R),F.include($),F.main.add(j`
+        `)):B.code.add("vec2 projectOverlay(vec3 pos) { return pos.xy; }"));const pe=Q&&re&&4===H;pe&&(z.varyings.add("tbnTangent","vec3"),z.varyings.add("tbnBiTangent","vec3"),z.varyings.add("upNormal","vec3"));const ue=0===Y,he=2===Y;if(z.include(L,F),z.include(o,F),B.include(D),B.main.add(V`
     bool castShadows;
     vec4 externalColor = forwardExternalColor(castShadows);
-    ${M(se,"if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }")}
-    ${M(!me,`if (externalColor.a ${ue?">":"<="} opacityCutoff) {\n         gl_Position = vec4(vec3(1e38), 1.0); return;\n       }`)}
-    ${M(te,"externalColor.a = 1.0;")}
+    ${j(ce,"if(!castShadows) { gl_Position = vec4(vec3(1e38), 1.0); return; }")}
+    ${j(!ue,`if (externalColor.a ${he?">":"<="} opacityCutoff) {\n         gl_Position = vec4(vec3(1e38), 1.0); return;\n       }`)}
+    ${j(ne,"externalColor.a = 1.0;")}
 
     forwardPosition(readElevationOffset());
     forwardNormal();
@@ -64,26 +64,26 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
     forwardLinearDepthToWriteShadowMap();
     forwardEmissiveStrength();
     forwardObjectAndLayerIdColor();
-    ${M(ge,k?j`
-            groundNormal = normalize(positionWorld());
-            tbnTangent = normalize(cross(vec3(0.0, 0.0, 1.0), groundNormal));
-            tbnBiTangent = normalize(cross(groundNormal, tbnTangent));`:j`
-            groundNormal = vec3(0.0, 0.0, 1.0);
+    ${j(pe,J?V`
+            upNormal = normalize(positionWorld());
+            tbnTangent = normalize(cross(vec3(0.0, 0.0, 1.0), upNormal));
+            tbnBiTangent = normalize(cross(upNormal, tbnTangent));`:V`
+            upNormal = vec3(0.0, 0.0, 1.0);
             tbnTangent = vec3(1.0, 0.0, 0.0);
             tbnBiTangent = vec3(0.0, 1.0, 0.0);`)}
-    ${M(J||ae,M(k,"vPositionForDraping = positionForDraping();\n         vtcOverlay = vec4(0.0);","setOverlayVTC(projectOverlay(positionForDraping()));"))}
+    ${j(Q||te,j(J,"vPositionForDraping = positionForDraping();\n         vtcOverlay = vec4(0.0);","setOverlayVTC(projectOverlay(positionForDraping()));"))}
 
     if (externalColor.a < alphaCutoff) {
       // Discard this vertex
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
       return;
     }
-  `),ee)return A.include(m,R),A.include(T,R),z.include(h,R),z.include(V,R),z.code.add(j`
+  `),re)return z.include(g,F),z.include(T,F),E.include(h,F),E.include($,F),E.include(b,F),E.code.add(V`
       float evaluateShadow() {
-        return ${H?"readShadowMap(vPositionWorldCameraRelative, linearDepth)":"0.0"};
+        return ${k?"readShadowMap(vPositionWorldCameraRelative, linearDepth)":"0.0"};
       }
-    `).main.add(j`
-      ${M(!Y,"discardBySlice(vPositionWorldCameraRelative);")}
+    `).main.add(V`
+      ${j(!ee,"discardBySlice(vPositionWorldCameraRelative);")}
 
       vec4 textureColor = readBaseColorTexture();
       discardOrAdjustAlpha(textureColor);
@@ -91,15 +91,15 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       // When rendering the occluded overlay, we still need to read the base color texture because we need to use the
       // same discard logic. However after that to render only the draped overlay, we simply set the base texture color
       // to zero.
-      ${M(X,j`textureColor = vec4(0);`)}
+      ${j(Z,V`textureColor = vec4(0);`)}
 
-      ${M(J,j`
-        vec4 overlayUVs = ${ce?"componentOverlayUVs()":"vtcOverlay"};
+      ${j(Q,V`
+        vec4 overlayUVs = ${me?"componentOverlayUVs()":"vtcOverlay"};
 
         vec4 overlayColor = getCombinedOverlayColor(overlayUVs);
 
         /* Early discard to only emit when we have overlay */
-        ${M(X,j`if (overlayColor.a < alphaCutoff) { discard; }`)}
+        ${j(Z,V`if (overlayColor.a < alphaCutoff) { discard; }`)}
         `)}
 
       vec4 externalColor;
@@ -107,79 +107,80 @@ import{ComponentData as e}from"../views/3d/webgl-engine/collections/Component/Ma
       readExternalColor(externalColor, externalColorMixMode);
 
       vec4 materialColor = computeMaterialColor(textureColor, externalColor, externalColorMixMode);
-      ${M(re,"materialColor = vec4(0.0);")}
-    `),oe?(y(z),k&&w(z),z.main.add(j`
+      ${j(le,"materialColor = vec4(0.0);")}
+    `),ae?(J&&w(E),E.include(C),E.uniforms.add(y).main.add(V`
         applyPBRFactors();
-        ${M(1===E,j`if (externalColorMixMode == 3) {
-              mrr = vec3(0.0, 0.6, 0.2);
-            }`)}
-        float additionalIrradiance = 0.02 * mainLightIntensity[2];
-        ${M(I,"mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);")}
+        ${j(1===H,"if (externalColorMixMode == 3) mrr = vec3(0.0, 0.6, 0.2);")}
+        ${j(I,"mat3 tangentSpace = computeTangentSpace(fragmentFaceNormal, vPositionWorldCameraRelative, vuv0);")}
+
+        vec3 viewDirection = normalize(vPositionWorldCameraRelative);
+        vec3 upNormal = getLocalUp(positionWorld());
         vec3 shadingNormal = ${I?"computeTextureNormal(tangentSpace, vuv0)":"fragmentShadingNormal"};
-        vec3 groundNormal = ${k?j`normalize(positionWorld())`:j`vec3(0.0, 0.0, 1.0)`};
 
-        vec3 viewDir = normalize(vPositionWorldCameraRelative);
         float ssao = 1.0 - occlusion * evaluateAmbientOcclusionInverse();
-        ${M(_,j`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
+        ${j(G,V`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
                  materialColor.rgb = mix(materialColor.rgb, vec3(1.1), snow);
                  ssao = mix(ssao, 0.5 * ssao, snow);
                  shadingNormal = mix(shadingNormal, fragmentFaceNormal, snow);`)}
-        ${M(J,"materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);")}
+        ${j(Q,"materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);")}
 
         vec3 additionalLight = evaluateAdditionalLighting(ssao, positionWorld());
-        ${M(k,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
-        ${k?j`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`:"float shadow = evaluateShadow();"}
-        vec4 shadedColor = vec4(evaluateSceneLightingPBR(shadingNormal, materialColor.rgb, shadow, ssao, additionalLight, viewDir, groundNormal, mrr, additionalIrradiance), materialColor.a);
-        `)):(f(z),k&&w(z),ge&&z.uniforms.add(new N("ovNormalTex",e=>e.overlay?.getTexture(3))),z.main.add(j`
-        ${M(k,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
-        float shadow = ${H?k?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())":"evaluateShadow()":k?"lightingGlobalFactor * (1.0 - additionalAmbientScale)":"0.0"};
-
-        ${M(H&&1!==G,j`
+        ${j(J,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
+        ${J?V`float shadow = max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow());`:"float shadow = evaluateShadow();"}
+        vec4 shadedColor = vec4(evaluateSceneLighting(shadingNormal, materialColor.rgb, shadow, ssao, additionalLight, viewDirection, upNormal), materialColor.a);
+      `)):(J&&w(E),pe&&E.uniforms.add(new W("ovNormalTex",e=>e.overlay?.getTexture(3))),E.uniforms.add(f).main.add(V`
+        ${j(J,"float additionalAmbientScale = additionalDirectedAmbientLight(positionWorld());")}
+        float shadow = ${k?J?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), evaluateShadow())":"evaluateShadow()":J?"lightingGlobalFactor * (1.0 - additionalAmbientScale)":"0.0"};
+
+        ${j(k&&1!==q,V`
             float dotFL = dot(fragmentFaceNormal, mainLightDirection);
             if( dotFL <= 0.0) shadow = 1.0;
         `)}
-        ${M(_,j`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
+        ${j(G,V`float snow = getSnow(fragmentFaceNormal, normalize(positionWorld()));
                materialColor.rgb = mix(materialColor.rgb, vec3(1), snow);`)}
 
+        vec3 viewDirection = normalize(vPositionWorldCameraRelative);
+        vec3 upNormal = getLocalUp(positionWorld());
+
         // At global scale we create some additional ambient light based on the main light to simulate global illumination
         float ssao = evaluateAmbientOcclusion();
         vec3 additionalLight = evaluateAdditionalLighting(ssao, positionWorld());
 
-        ${M(J,"materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);")}
+        ${j(Q,"materialColor = compositeOverlayUnpremultiplied(materialColor, overlayColor);")}
 
-        vec4 shadedColor = vec4(evaluateSceneLighting(fragmentShadingNormal, materialColor.rgb, shadow, ssao, additionalLight), materialColor.a);
-        ${M(ge,j`vec4 overlayWaterMask = getOverlayColor(ovNormalTex, overlayUVs);
+        vec4 shadedColor = vec4(evaluateSceneLighting(fragmentShadingNormal, materialColor.rgb, shadow, ssao, additionalLight, viewDirection, upNormal), materialColor.a);
+        ${j(pe,V`vec4 overlayWaterMask = getOverlayColor(ovNormalTex, overlayUVs);
                  float waterNormalLength = length(overlayWaterMask);
                  if (waterNormalLength > 0.95) {
-                   mat3 tbnMatrix = mat3(tbnTangent, tbnBiTangent, groundNormal);
-                   vec4 waterColorLinear = getOverlayWaterColor(overlayWaterMask, overlayColor, -normalize(vPositionWorldCameraRelative), shadow, groundNormal, tbnMatrix, vPosition_view, positionWorld());
+                   mat3 tbnMatrix = mat3(tbnTangent, tbnBiTangent, upNormal);
+                   vec4 waterColorLinear = getOverlayWaterColor(overlayWaterMask, overlayColor, -normalize(vPositionWorldCameraRelative), shadow, upNormal, tbnMatrix, vPosition_view, positionWorld());
                    vec4 waterColorNonLinear = delinearizeGamma(vec4(waterColorLinear.xyz, 1.0));
                    // un-gamma the ground color to mix in linear space
                    shadedColor = mix(shadedColor, waterColorNonLinear, waterColorLinear.w);
                  }`)}
-      `)),z.main.add(`\n      ${M(Y,"if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;")}\n\n      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${M(_,", snow")});\n    `),R.sphereDepthInterpolate&&(A.include(D,R),A.fragment.include(d),z.main.add(j`vec3 worldRay = normalize(vPositionWorldCameraRelative);
+      `)),E.main.add(`\n      ${j(ee,"if(rejectBySlice(vPositionWorldCameraRelative)) shadedColor.a *= groundSliceOpacity;")}\n\n      outputColorHighlightOLID(applySlice(shadedColor, vPositionWorldCameraRelative), materialColor.rgb ${j(G,", snow")});\n    `),F.sphereDepthInterpolate&&(z.include(R,F),z.fragment.include(d),E.main.add(V`vec3 worldRay = normalize(vPositionWorldCameraRelative);
 vec3 viewRay = normalize(vPosition_view);
-gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linearizeDepth(gl_FragCoord.z)));`)),A;const pe=le||8===B;return pe&&A.include(c,R),ne&&A.include(m,R),J&&A.include(g,R),A.include(v,R),z.main.add(j`
-    ${M(!Y,"discardBySlice(vPositionWorldCameraRelative);")}
+gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linearizeDepth(gl_FragCoord.z)));`)),z;const we=ie||8===_;return we&&z.include(c,F),de&&z.include(g,F),Q&&z.include(m,F),z.include(v,F),E.main.add(V`
+    ${j(!ee,"discardBySlice(vPositionWorldCameraRelative);")}
 
     vec4 textureColor = readBaseColorTexture();
     discardOrAdjustAlpha(textureColor);
 
-    ${M(ae,j`
-      vec4 overlayUVs = ${ce?"componentOverlayUVs()":"vtcOverlay"};
+    ${j(te,V`
+      vec4 overlayUVs = ${me?"componentOverlayUVs()":"vtcOverlay"};
       if (getCombinedOverlayColor(overlayUVs).a < alphaCutoff) {
         discard;
       }
       `)}
 
-    ${M(pe,"outputDepth(linearDepth);")}
-    ${M(ne,j`
+    ${j(we,"outputDepth(linearDepth);")}
+    ${j(de,V`
         vec4 externalColor;
         int externalColorMixMode;
         readExternalColor(externalColor, externalColorMixMode);
 
         vec4 materialColor = computeMaterialColor(textureColor, externalColor, externalColorMixMode);
-        ${M(Y,j`
+        ${j(ee,V`
             if (rejectBySlice(vPositionWorldCameraRelative)) {
               materialColor.a *= groundSliceOpacity;
             }
@@ -187,5 +188,5 @@ gl_FragDepth = delinearizeDepth(sphereDepthInterpolate(worldRay, viewRay, linear
 
         fragColor = vec4(vec3(0.5) + 0.5 * fragmentFaceNormalView, materialColor.a);
       `)}
-    ${M(te,J?ce?"fragColor = getOverlayColorTexel(componentOverlayUVs());":"fragColor = getOverlayColorTexel();":"outputObjectAndLayerIdColor();")}
-    ${M(ie,M(J,ce?j`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded(componentOverlayUVs()));`:j`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,j`calculateOcclusionAndOutputHighlight();`))}`),A}const A=Object.freeze(Object.defineProperty({__proto__:null,build:R},Symbol.toStringTag,{value:"Module"}));export{A as C,R as b};
+    ${j(ne,Q?me?"fragColor = getOverlayColorTexel(componentOverlayUVs());":"fragColor = getOverlayColorTexel();":"outputObjectAndLayerIdColor();")}
+    ${j(se,j(Q,me?V`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded(componentOverlayUVs()));`:V`calculateOcclusionAndOutputHighlight(getAllOverlayHighlightValuesEncoded());`,V`calculateOcclusionAndOutputHighlight();`))}`),z}const z=Object.freeze(Object.defineProperty({__proto__:null,build:F},Symbol.toStringTag,{value:"Module"}));export{z as C,F as b};

package/chunks/DefaultMaterial.glsl.js

@@ -1,15 +1,15 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstancedDoublePrecision as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{NormalAttribute as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{TextureCoordinateAttribute as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexNormal as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VerticalOffset as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as d}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{DefaultMaterialExternalColor as g}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialExternalColor.glsl.js";import{ComputeNormalTexturePass as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateAmbientOcclusion as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as u,addAmbientBoostFactor as v,addLightingGlobalFactor as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{PhysicallyBasedRendering as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as y,ReadShadowMapDrawFragment as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{colorTextureUV as L,normalTextureUV as j,emissiveTextureUV as C,occlusionTextureUV as P,metallicRoughnessTextureUV as S}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TextureTransformUV.glsl.js";import{VisualVariables as T}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as O}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{addProjViewLocalOrigin as N,addCameraPosition as V}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as A}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{If as M,glsl as D}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as $}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as B}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as I}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as U}from"../views/webgl/ShaderBuilder.js";function _(_){const R=new U,{attributes:E,vertex:W,fragment:F,varyings:z}=R,{output:G,normalType:k,offsetBackfaces:H,spherical:q,snowCover:J,pbrMode:K,textureAlphaPremultiplied:Q,instancedDoublePrecision:X,hasVertexColors:Y,hasVertexTangents:Z,hasColorTexture:ee,hasNormalTexture:re,hasNormalTextureTransform:oe,hasColorTextureTransform:ie}=_;if(N(W,_),E.add("position","vec3"),W.inputs.add("position",()=>"position"),z.add("vpos","vec3",{invariant:!0}),R.include(T,_),R.include(a,_),R.include(t,_),R.include(L,_),!r(G))return R.include(d,_),R;R.include(j,_),R.include(C,_),R.include(P,_),R.include(S,_),V(W,_),R.include(l,_),R.include(i);const ae=0===k||1===k;return ae&&H&&R.include(e),R.include(c,_),R.include(n,_),z.add("vPositionLocal","vec3"),R.include(s,_),R.include(g,_),R.include(X?y:x,_),W.main.add(D`
+import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as o}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstancedDoublePrecision as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{NormalAttribute as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{TextureCoordinateAttribute as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexNormal as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexNormal.glsl.js";import{VerticalOffset as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as d}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{DefaultMaterialExternalColor as g}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialExternalColor.glsl.js";import{ComputeNormalTexturePass as c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ComputeNormalTexture.glsl.js";import{EvaluateAmbientOcclusion as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as u,addAmbientBoostFactor as v,addLightingGlobalFactor as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{mainLightIntensity as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRendering as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as x,ReadShadowMapDrawFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{colorTextureUV as j,normalTextureUV as C,emissiveTextureUV as N,occlusionTextureUV as T,metallicRoughnessTextureUV as O}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TextureTransformUV.glsl.js";import{VisualVariables as P}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as S}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{addProjViewLocalOrigin as V,addCameraPosition as D}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as M}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{If as A,glsl as $}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as U}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as B}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as _}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as R}from"../views/webgl/ShaderBuilder.js";function E(E){const I=new R,{attributes:W,vertex:F,fragment:k,varyings:z}=I,{output:H,normalType:G,offsetBackfaces:q,snowCover:J,pbrMode:K,textureAlphaPremultiplied:Q,instancedDoublePrecision:X,hasVertexColors:Y,hasVertexTangents:Z,hasColorTexture:ee,hasNormalTexture:re,hasNormalTextureTransform:oe,hasColorTextureTransform:ie}=E;if(V(F,E),W.add("position","vec3"),F.inputs.add("position",()=>"position"),z.add("vpos","vec3",{invariant:!0}),I.include(P,E),I.include(a,E),I.include(t,E),I.include(j,E),!r(H))return I.include(d,E),I;I.include(C,E),I.include(N,E),I.include(T,E),I.include(O,E),D(F,E),I.include(l,E),I.include(i);const ae=0===G||1===G;return ae&&q&&I.include(e),I.include(c,E),I.include(n,E),z.add("vPositionLocal","vec3"),I.include(s,E),I.include(g,E),I.include(X?x:L,E),F.main.add($`
     forwardDefaultMaterialExternalColor();
 
     vpos = getVertexInLocalOriginSpace();
     vPositionLocal = vpos - view[3].xyz;
     vpos = subtractOrigin(vpos);
-    ${M(ae,"vNormalWorld = dpNormal(vvLocalNormal(normalModel()));")}
+    ${A(ae,"vNormalWorld = dpNormal(vvLocalNormal(normalModel()));")}
     vpos = addVerticalOffset(vpos, localOrigin);
-    ${M(Z,"vTangent = dpTransformVertexTangent(tangent);")}
+    ${A(Z,"vTangent = dpTransformVertexTangent(tangent);")}
     gl_Position = transformPosition(proj, view, vpos);
-    ${M(ae&&H,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);")}
+    ${A(ae&&q,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);")}
 
     forwardTextureCoordinates();
     forwardColorUV();
@@ -22,26 +22,25 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
       gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
     }
     forwardLinearDepthToReadShadowMap();
-  `),F.include(u,_),F.include(m,_),R.include(O,_),F.include(o,_),R.include(I,_),V(F,_),F.uniforms.add(W.uniforms.get("localOrigin"),new A("ambient",e=>e.ambient),new A("diffuse",e=>e.diffuse)),ee&&F.uniforms.add(new $("tex",e=>e.texture)),R.include(f,_),F.include(p,_),R.include(h,_),F.include(B,_),v(F),b(F),w(F),F.main.add(D`
+  `),k.include(u,E),k.include(m,E),I.include(S,E),k.include(o,E),I.include(_,E),D(k,E),k.uniforms.add(F.uniforms.get("localOrigin"),new M("ambient",e=>e.ambient),new M("diffuse",e=>e.diffuse)),ee&&k.uniforms.add(new U("tex",e=>e.texture)),I.include(y,E),k.include(h,E),I.include(b,E),k.include(B,E),k.include(f,E),v(k),w(k),k.uniforms.add(p).main.add($`
     discardBySlice(vpos);
-    ${ee?D`
+    ${ee?$`
             vec4 texColor = texture(tex, ${ie?"colorUV":"vuv0"});
-            ${M(Q,"texColor.rgb /= texColor.a;")}
-            discardOrAdjustAlpha(texColor);`:D`vec4 texColor = vec4(1.0);`}
-    shadingParams.viewDirection = normalize(vpos - cameraPosition);
-    ${2===k?D`vec3 normal = screenDerivativeNormal(vPositionLocal);`:D`shadingParams.normalView = vNormalWorld;
-                vec3 normal = shadingNormal(shadingParams);`}
+            ${A(Q,"texColor.rgb /= texColor.a;")}
+            discardOrAdjustAlpha(texColor);`:"vec4 texColor = vec4(1.0);"}
+    vec3 viewDirection = normalize(vpos - cameraPosition);
+    vec3 posWorld = vpos + localOrigin;
+    vec3 upNormal = getLocalUp(posWorld);
+    ${2===G?"vec3 normal = screenDerivativeNormal(vPositionLocal);":"vec3 normal = shadingNormal(vNormalWorld, viewDirection);"}
     applyPBRFactors();
     float ssao = evaluateAmbientOcclusionInverse() * getBakedOcclusion();
 
-    vec3 posWorld = vpos + localOrigin;
-
     float additionalAmbientScale = additionalDirectedAmbientLight(posWorld);
     float shadow = readShadow(additionalAmbientScale, vpos);
 
     vec3 matColor = max(ambient, diffuse);
     vec3 albedo = mixExternalColor(
-      ${M(Y,"vColor.rgb *")} matColor,
+      ${A(Y,"vColor.rgb *")} matColor,
       texColor.rgb,
       vExternalColor.rgb,
       colorMixMode
@@ -49,20 +48,17 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
     float opacity_ = getDefaultMaterialOpacity(texColor.a);
 
     ${re?`mat3 tangentSpace = computeTangentSpace(${Z?"normal":"normal, vpos, vuv0"});\n           vec3 shadingNormal = computeTextureNormal(tangentSpace, ${oe?"normalUV":"vuv0"});`:"vec3 shadingNormal = normal;"}
-    vec3 normalGround = ${q?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
 
-    ${M(J,D`
-          float snow = getSnow(normal, normalGround);
+    ${A(J,$`
+          float snow = getSnow(normal, upNormal);
           albedo = mix(albedo, vec3(1), snow);
           shadingNormal = mix(shadingNormal, normal, snow);
           ssao = mix(ssao, 1.0, snow);`)}
 
     vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
+    ${A((1===K||2===K)&&J,"applySnowToMRR(snow);")}
 
-    ${1===K||2===K?D`
-            float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
-            ${M(J,"mrr = applySnowToMRR(mrr, snow);")}
-            vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);`:7===K?D`vec3 shadedColor = albedo;`:D`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
+    vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, viewDirection, upNormal);
     vec4 finalColor = vec4(shadedColor, opacity_);
-    outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${M(J,", snow")});
-  `),R}const R=Object.freeze(Object.defineProperty({__proto__:null,build:_},Symbol.toStringTag,{value:"Module"}));export{R as D,_ as b};
+    outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${A(J,", snow")});
+  `),I}const I=Object.freeze(Object.defineProperty({__proto__:null,build:E},Symbol.toStringTag,{value:"Module"}));export{I as D,E as b};

package/chunks/GaussianSplat.glsl.js

@@ -1,15 +1,17 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{EvaluateSceneLighting as e,addAmbientBoostFactor as a,addLightingGlobalFactor as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{ReadShadowMapPassFragment as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{RgbNormalizedDepthEncoding as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{Float3BindUniform as r}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{glsl as s,If as l}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as d}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{GaussianSplatPerspectivePass as g,GaussianSplatFading as c,gaussianSplatPerspectiveVertex as h}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{getGaussianSplatAlphaCutoffValue as p}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";function u(u){const{receiveShadows:f,spherical:v}=u,b=new m;b.varyings.add("vColor","vec4"),b.include(g,u),u.fadingEnabled&&b.vertex.include(c),b.vertex.uniforms.add(new r("cameraPosition",e=>e.camera.eye)),f?(b.fragment.uniforms.add(new r("cameraPosition",e=>e.camera.eye)),b.fragment.include(e,u)):b.vertex.include(e,u),b.include(i,u),a(f?b.fragment:b.vertex),n(f?b.fragment:b.vertex),f&&b.include(o,u),b.outputs.add("fragColor","vec4",0),b.outputs.add("fragDepthColor","vec4",1);const w=p(u.alphaCutoff),C=s`float groundLightAlignment = dot(groundNormal, mainLightDirection);
+import{EvaluateSceneLighting as e,addAmbientBoostFactor as a,addLightingGlobalFactor as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{NormalUtils as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{ReadShadowMapPassFragment as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{RgbNormalizedDepthEncoding as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbNormalizedDepthEncoding.glsl.js";import{Float3BindUniform as r}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{glsl as s,If as l}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{gaussianSplatFirstHitAlpha as d}from"../views/3d/webgl-engine/shaders/GaussianSplatDepthPolicy.js";import{GaussianSplatPerspectivePass as c,GaussianSplatFading as g,gaussianSplatPerspectiveVertex as h}from"../views/3d/webgl-engine/shaders/GaussianSplatPass.glsl.js";import{getGaussianSplatAlphaCutoffValue as p}from"../views/3d/webgl-engine/shaders/GaussianSplatTechniqueConfiguration.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";function u(u){const{receiveShadows:f,spherical:v}=u,b=new m,{varyings:w,vertex:C,fragment:y,outputs:L}=b;w.add("vColor","vec4"),b.include(c,u),u.fadingEnabled&&C.include(g),C.uniforms.add(new r("cameraPosition",e=>e.camera.eye)),f?(y.uniforms.add(new r("cameraPosition",e=>e.camera.eye)),y.include(e,u)):C.include(e,u),C.include(n,u),a(f?y:C),i(f?y:C),f&&b.include(o,u),L.add("fragColor","vec4",0),L.add("fragDepthColor","vec4",1);const S=p(u.alphaCutoff),D=s`float groundLightAlignment = dot(upNormal, mainLightDirection);
 float additionalAmbientScale = additionalDirectedAmbientLight(groundLightAlignment);
-vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,y=s`
-    vec3 groundNormal = ${v?s`normalize(cameraRelativePosition + cameraPosition)`:s`vec3(0.0, 0.0, 1.0)`};
-    ${C}
+vec3 additionalLight = mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;`,P=s`
+    vec3 viewDirection = normalize(fragmentPositionCameraRelative - cameraPosition);
+    vec3 upNormal = getLocalUp(fragmentPositionCameraRelative, cameraPosition);
+    ${D}
     float shadow = ${v?s`lightingGlobalFactor * (1.0 - additionalAmbientScale)`:s`0.0`};
-    vColor.rgb = evaluateSceneLighting(groundNormal, vColor.rgb, shadow, 0.0, additionalLight);
-  `,S=s`
-    vec3 groundNormal = ${v?s`normalize(fragmentPositionCameraRelative + cameraPosition)`:s`vec3(0.0, 0.0, 1.0)`};
-    ${C}
+    vColor.rgb = evaluateSceneLighting(upNormal, vColor.rgb, shadow, 0.0, additionalLight, viewDirection, upNormal);
+  `,j=s`
+    vec3 viewDirection = normalize(fragmentPositionCameraRelative - cameraPosition);
+    vec3 upNormal = getLocalUp(fragmentPositionCameraRelative, cameraPosition);
+    ${D}
     float shadow = readShadow(additionalAmbientScale, fragmentPositionCameraRelative);
-    shadedColor = evaluateSceneLighting(groundNormal, vColor.rgb, shadow, 0.0, additionalLight);
-  `;return b.vertex.main.add(`\n    uint gaussianIndex = fetchOrderedGaussianIndex(uint(gl_InstanceID));\n    uvec4 packedGaussian = fetchPackedGaussian(gaussianIndex);\n\n    // Unpack color first so very transparent splats can discard before fetching the page header.\n    vColor = unpackColor(packedGaussian);\n    float opacity = vColor.a;\n\n    // Apply per-page fading before the early alpha rejection.\n    ${l(u.fadingEnabled,s`opacity = applyGaussianSplatFading(opacity, gaussianIndex);
-vColor.a = opacity;`)}\n\n    ${h(u,w)}\n    vColor.a = opacity;\n\n    // Handle environment lighting per vertex when no shadow map is active.\n    // When shadows are received, defer lighting to the fragment shader for crisp shadow borders.\n    ${l(f,"forwardLinearDepth(-viewPos.z);",y)}\n  `),b.fragment.include(t),b.fragment.main.add(`\n    float gaussianFalloff = exp(gaussianExponent);\n\n    // Cap at 0.99 to avoid blending issues, such as seams between overlapping Gaussians.\n    float alpha = min(.99f, vColor.a * gaussianFalloff);\n\n    vec3 shadedColor = vColor.rgb;\n    ${l(f,S)}\n    fragColor = vec4(shadedColor * alpha, alpha);\n\n    // We simulate first hit based depth using the shared opacity threshold.\n    // This works because we render in front-to-back order,\n    // i.e. the first hit that counts completely saturates the alpha channel\n    // and further splats do not contribute.\n    float depthHit = step(${s.float(d)}, alpha);\n    vec3 encodedDepth = vec3(0.0);\n    if (depthHit > 0.0) {\n      encodedDepth = encodeNormalizedDepthToRGB(gaussianSplatDepth());\n    }\n    fragDepthColor = vec4(encodedDepth, depthHit);\n  `),b}const f=Object.freeze(Object.defineProperty({__proto__:null,build:u},Symbol.toStringTag,{value:"Module"}));export{f as G,u as b};
+    shadedColor = evaluateSceneLighting(upNormal, vColor.rgb, shadow, 0.0, additionalLight, viewDirection, upNormal);
+  `;return C.main.add(`\n    uint gaussianIndex = fetchOrderedGaussianIndex(uint(gl_InstanceID));\n    uvec4 packedGaussian = fetchPackedGaussian(gaussianIndex);\n\n    // Unpack color first so very transparent splats can discard before fetching the page header.\n    vColor = unpackColor(packedGaussian);\n    float opacity = vColor.a;\n\n    // Apply per-page fading before the early alpha rejection.\n    ${l(u.fadingEnabled,s`opacity = applyGaussianSplatFading(opacity, gaussianIndex);
+vColor.a = opacity;`)}\n\n    ${h(u,S)}\n    vColor.a = opacity;\n\n    // Handle environment lighting per vertex when no shadow map is active.\n    // When shadows are received, defer lighting to the fragment shader for crisp shadow borders.\n    ${l(f,"forwardLinearDepth(-viewPos.z);",P)}\n  `),y.include(t),y.include(n,u),y.main.add(`\n    float gaussianFalloff = exp(gaussianExponent);\n\n    // Cap at 0.99 to avoid blending issues, such as seams between overlapping Gaussians.\n    float alpha = min(.99f, vColor.a * gaussianFalloff);\n\n    vec3 shadedColor = vColor.rgb;\n    ${l(f,j)}\n    fragColor = vec4(shadedColor * alpha, alpha);\n\n    // We simulate first hit based depth using the shared opacity threshold.\n    // This works because we render in front-to-back order,\n    // i.e. the first hit that counts completely saturates the alpha channel\n    // and further splats do not contribute.\n    float depthHit = step(${s.float(d)}, alpha);\n    vec3 encodedDepth = vec3(0.0);\n    if (depthHit > 0.0) {\n      encodedDepth = encodeNormalizedDepthToRGB(gaussianSplatDepth());\n    }\n    fragDepthColor = vec4(encodedDepth, depthHit);\n  `),b}const f=Object.freeze(Object.defineProperty({__proto__:null,build:u},Symbol.toStringTag,{value:"Module"}));export{f as G,u as b};

package/chunks/GlobalIllumination.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepthLastFrame as a}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepthLastFrame.glsl.js";import{Gamma as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{addMainLightDirection as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{ScreenSpaceRayMarching as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceRayMarching.glsl.js";import{CameraSpace as o}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{FloatBindUniform as r}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as c,If as s}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{GlobalIlluminationColorQuantization as u}from"../views/3d/webgl-engine/effects/globalIllumination/GlobalIlluminationColorQuantization.glsl.js";import{floatBlendReductionFactor as p}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ColorAttachment1 as g,SizedPixelFormat as f}from"../views/webgl/enums.js";import{NoParameters as y}from"../views/webgl/NoParameters.js";import{ShaderBuilder as x}from"../views/webgl/ShaderBuilder.js";const v=.01,M=.008,b=5e-4,w=.5,S=.02,B=.1,W=.008,F=.3,I=.008,D=150,C=.095,j=.008,R=60,O=2,z=.0039,G=.25,P=.012,T=6,E=.15,Q=25,L=.15,H=.5,V=1,k=1,U=16;class N extends y{constructor(){super(...arguments),this.projScale=1,this.scaleGlobalIllumination=1,this.accumulatedFrames=0,this.temporalSampleFrame=0,this.rayMarchMinReach=L,this.rayMarchMaxReach=H,this.rayMarchWorldReach=Q,this.rayMarchMinReachEmissionWeight=V,this.rayMarchMaxReachEmissionWeight=k,this.rayMarchMaxSteps=U,this.colorBleedWeight=E,this.highQualityIdleColorBlendStart=F}}function _(y){const F=new x,E=F.fragment;F.include(e),F.include(o),i(E),E.include(a),E.include(t),E.include(u),F.include(l,y),E.uniforms.add(new m("normalMap",e=>e.normalTexture),new m("depthMap",e=>e.depthTexture),new d("lastFrameColorTexture",e=>e.reprojection.lastFrameColor?.getTexture()),new d("lastFrameDepthTexture",e=>e.reprojection.lastFrameDepth?.attachment),new d("lastFrameGlobalIlluminationTexture",e=>e.globalIllumination?.getTexture()),new d("lastFrameGlobalIlluminationWeightTexture",e=>e.globalIllumination?.getTexture(g)),new h("reprojectionProjectionMatrix",e=>e.reprojection.lastFrameCamera.projectionMatrix),new h("reprojectionViewMatrix",e=>e.reprojection.viewMatrix),new h("view",e=>e.camera.viewMatrix),new n("accumulatedFrames",e=>e.accumulatedFrames),new n("temporalSampleFrame",e=>e.temporalSampleFrame),new n("scaleGlobalIllumination",e=>e.scaleGlobalIllumination)),E.uniforms.add(new n("rayMarchMinReach",e=>e.rayMarchMinReach),new n("rayMarchMaxReach",e=>e.rayMarchMaxReach),new n("rayMarchWorldReach",e=>e.rayMarchWorldReach),new n("rayMarchMinReachEmissionWeight",e=>e.rayMarchMinReachEmissionWeight),new n("rayMarchMaxReachEmissionWeight",e=>e.rayMarchMaxReachEmissionWeight),new n("rayMarchMaxSteps",e=>e.rayMarchMaxSteps),new n("colorBleedWeight",e=>e.colorBleedWeight),new n("highQualityIdleColorBlendStart",e=>e.highQualityIdleColorBlendStart));const{hasEmission:Q,hasColor:L}=y;return Q&&E.uniforms.add(new r("inputScale",e=>e.reprojection.lastFrameEmission?.attachment.descriptor.internalFormat===f.RGBA8?p:1),new d("lastFrameEmissionTexture",e=>e.reprojection.lastFrameEmission?.attachment)),E.constants.add("highQualityIdleColorBlendEnd","float",I),E.constants.add("highQualityIdleColorBlendFrames","float",D),E.constants.add("highQualityIdleOcclusionBlendEnd","float",j),E.constants.add("highQualityIdleOcclusionBlendExponent","float",O),E.constants.add("highQualityIdleOcclusionBlendFrames","float",R),E.constants.add("highQualityIdleOcclusionBlendStart","float",C),E.constants.add("fullColorBleedBlendWeight","float",P),E.constants.add("accumulationDitherScale","float",z),E.constants.add("lowQualityColorBlendWeight","float",b),E.constants.add("lowQualityColorDitherScale","float",G),E.constants.add("lowQualityOcclusionBlendWeight","float",M),E.constants.add("reprojectionMismatchThreshold","float",v),E.constants.add("stableHistoryColorBlendWeight","float",W),E.constants.add("strongHistoryOcclusionThreshold","float",S),E.constants.add("weakHistoryOcclusionBlendWeight","float",B),E.constants.add("weakHistoryOcclusionThreshold","float",w),E.constants.add("storedColorBlendWeightScale","float",T),E.code.add(c`float computeIdleColorBlendWeight(float accumulatedFrames) {
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{ReadDepthLastFrame as a}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepthLastFrame.glsl.js";import{Gamma as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{mainLightDirection as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{ScreenSpaceRayMarching as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceRayMarching.glsl.js";import{CameraSpace as o}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{FloatBindUniform as r}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as c,If as s}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{Texture2DPassUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{GlobalIlluminationColorQuantization as u}from"../views/3d/webgl-engine/effects/globalIllumination/GlobalIlluminationColorQuantization.glsl.js";import{floatBlendReductionFactor as p}from"../views/3d/webgl-engine/shaders/floatBlendScale.glsl.js";import{ColorAttachment1 as g,SizedPixelFormat as f}from"../views/webgl/enums.js";import{NoParameters as y}from"../views/webgl/NoParameters.js";import{ShaderBuilder as x}from"../views/webgl/ShaderBuilder.js";const v=.01,M=.008,b=5e-4,w=.5,S=.02,B=.1,W=.008,F=.3,I=.008,D=150,C=.095,j=.008,R=60,O=2,z=.0039,G=.25,P=.012,T=6,E=.15,Q=25,L=.15,H=.5,V=1,k=1,U=16;class N extends y{constructor(){super(...arguments),this.projScale=1,this.scaleGlobalIllumination=1,this.accumulatedFrames=0,this.temporalSampleFrame=0,this.rayMarchMinReach=L,this.rayMarchMaxReach=H,this.rayMarchWorldReach=Q,this.rayMarchMinReachEmissionWeight=V,this.rayMarchMaxReachEmissionWeight=k,this.rayMarchMaxSteps=U,this.colorBleedWeight=E,this.highQualityIdleColorBlendStart=F}}function _(y){const F=new x,E=F.fragment;F.include(e),F.include(o),E.include(a),E.include(t),E.include(u),F.include(l,y),E.uniforms.add(i,new m("normalMap",e=>e.normalTexture),new m("depthMap",e=>e.depthTexture),new d("lastFrameColorTexture",e=>e.reprojection.lastFrameColor?.getTexture()),new d("lastFrameDepthTexture",e=>e.reprojection.lastFrameDepth?.attachment),new d("lastFrameGlobalIlluminationTexture",e=>e.globalIllumination?.getTexture()),new d("lastFrameGlobalIlluminationWeightTexture",e=>e.globalIllumination?.getTexture(g)),new h("reprojectionProjectionMatrix",e=>e.reprojection.lastFrameCamera.projectionMatrix),new h("reprojectionViewMatrix",e=>e.reprojection.viewMatrix),new h("view",e=>e.camera.viewMatrix),new n("accumulatedFrames",e=>e.accumulatedFrames),new n("temporalSampleFrame",e=>e.temporalSampleFrame),new n("scaleGlobalIllumination",e=>e.scaleGlobalIllumination)),E.uniforms.add(new n("rayMarchMinReach",e=>e.rayMarchMinReach),new n("rayMarchMaxReach",e=>e.rayMarchMaxReach),new n("rayMarchWorldReach",e=>e.rayMarchWorldReach),new n("rayMarchMinReachEmissionWeight",e=>e.rayMarchMinReachEmissionWeight),new n("rayMarchMaxReachEmissionWeight",e=>e.rayMarchMaxReachEmissionWeight),new n("rayMarchMaxSteps",e=>e.rayMarchMaxSteps),new n("colorBleedWeight",e=>e.colorBleedWeight),new n("highQualityIdleColorBlendStart",e=>e.highQualityIdleColorBlendStart));const{hasEmission:Q,hasColor:L}=y;return Q&&E.uniforms.add(new r("inputScale",e=>e.reprojection.lastFrameEmission?.attachment.descriptor.internalFormat===f.RGBA8?p:1),new d("lastFrameEmissionTexture",e=>e.reprojection.lastFrameEmission?.attachment)),E.constants.add("highQualityIdleColorBlendEnd","float",I),E.constants.add("highQualityIdleColorBlendFrames","float",D),E.constants.add("highQualityIdleOcclusionBlendEnd","float",j),E.constants.add("highQualityIdleOcclusionBlendExponent","float",O),E.constants.add("highQualityIdleOcclusionBlendFrames","float",R),E.constants.add("highQualityIdleOcclusionBlendStart","float",C),E.constants.add("fullColorBleedBlendWeight","float",P),E.constants.add("accumulationDitherScale","float",z),E.constants.add("lowQualityColorBlendWeight","float",b),E.constants.add("lowQualityColorDitherScale","float",G),E.constants.add("lowQualityOcclusionBlendWeight","float",M),E.constants.add("reprojectionMismatchThreshold","float",v),E.constants.add("stableHistoryColorBlendWeight","float",W),E.constants.add("strongHistoryOcclusionThreshold","float",S),E.constants.add("weakHistoryOcclusionBlendWeight","float",B),E.constants.add("weakHistoryOcclusionThreshold","float",w),E.constants.add("storedColorBlendWeightScale","float",T),E.code.add(c`float computeIdleColorBlendWeight(float accumulatedFrames) {
 float idleColorBlendProgress = clamp(accumulatedFrames / highQualityIdleColorBlendFrames, 0.0, 1.0);
 return mix(highQualityIdleColorBlendStart, highQualityIdleColorBlendEnd, pow(idleColorBlendProgress, 1./5.)
 );

package/chunks/Haze.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{ReadDepth as e}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{Gamma as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{addMainLightDirection as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{FloatPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as o,If as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{getHeightParameters as d}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanApproximation.glsl.js";import{ChapmanRaymarching as l}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanRaymarching.glsl.js";import{ScreenSpacePassAtmosphere as p}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{SphereIntersect as m}from"../views/3d/webgl-engine/shaders/SphereIntersect.glsl.js";import{ToneMapping as h}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as c}from"../views/webgl/ShaderBuilder.js";function g(g){const f=new c,{fragment:u}=f;f.include(p),t(u),u.include(r),u.include(e),u.include(m),u.include(h),u.include(l,!0),u.uniforms.add(new s("depthTexture",e=>e.mainDepth));const{reduced:v}=g;return v&&u.code.add(o`float getDepth(vec2 uv){
+import{ReadDepth as e}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadDepth.glsl.js";import{Gamma as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Gamma.glsl.js";import{mainLightDirection as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{FloatPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{FloatsPassUniform as i}from"../views/3d/webgl-engine/core/shaderModules/FloatsPassUniform.js";import{glsl as o,If as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DBindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Texture2DBindUniform.js";import{getHeightParameters as d}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanApproximation.glsl.js";import{ChapmanRaymarching as l}from"../views/3d/webgl-engine/effects/atmosphere/ChapmanRaymarching.glsl.js";import{ScreenSpacePassAtmosphere as p}from"../views/3d/webgl-engine/shaders/ScreenSpacePassAtmosphere.glsl.js";import{SphereIntersect as m}from"../views/3d/webgl-engine/shaders/SphereIntersect.glsl.js";import{ToneMapping as h}from"../views/3d/webgl-engine/shaders/ToneMapping.glsl.js";import{ShaderBuilder as c}from"../views/webgl/ShaderBuilder.js";function g(g){const f=new c,{fragment:u}=f;f.include(p),u.include(r),u.include(e),u.include(m),u.include(h),u.include(l,!0),u.uniforms.add(t,new s("depthTexture",e=>e.mainDepth));const{reduced:v}=g;return v&&u.code.add(o`float getDepth(vec2 uv){
 return linearDepthFromTexture(depthTexture, uv);
 }
 float textureBilinear(vec2 uv) {

package/chunks/Path.glsl.js

@@ -1,57 +1,54 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import{addNearFar as e}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{Offset as o}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as a}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{PathVertexPosition as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";import{outputDepth as n}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as l}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{EvaluateAmbientOcclusion as t}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as s,addAmbientBoostFactor as c,addLightingGlobalFactor as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDrawFragment as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{ColorConversion as w}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as f,addCameraPosition as h,addViewNormal as y}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as L}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as j,If as P}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as V}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as C}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as S}from"../views/webgl/ShaderBuilder.js";function O(O){const A=new S,{vertex:I,fragment:B,varyings:_}=A;f(I,O),_.add("vpos","vec3",{invariant:!0}),A.include(d,O);const{output:D,spherical:M,pbrMode:F,snowCover:k,offsetBackfaces:z}=O,E=11===D;switch((r(D)||E)&&(E?(A.varyings.add("objectAndLayerIdColorVarying","vec4"),A.vertex.code.add(j`void forwardObjectAndLayerIdColor() {
+import{addNearFar as e}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepthToWriteShadowMap.glsl.js";import{Offset as o}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as i}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as a}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{PathVertexPosition as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";import{outputDepth as l}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{OutputHighlight as t}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{EvaluateAmbientOcclusion as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as s,addAmbientBoostFactor as c,addLightingGlobalFactor as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{mainLightIntensity as m}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDrawFragment as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{ColorConversion as b}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as f,addCameraPosition as h,addViewNormal as y}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as j}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as L,If as V}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as P}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{outputColorHighlightOLID as C}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as O}from"../views/webgl/ShaderBuilder.js";function S(S){const A=new O,{vertex:I,fragment:_,varyings:B}=A;f(I,S),B.add("vpos","vec3",{invariant:!0}),A.include(d,S);const{output:D,pbrMode:M,snowCover:N,offsetBackfaces:F}=S,k=11===D;switch((r(D)||k)&&(k?(A.varyings.add("objectAndLayerIdColorVarying","vec4"),A.vertex.code.add(L`void forwardObjectAndLayerIdColor() {
 objectAndLayerIdColorVarying = getOlidColor();
-}`),A.fragment.code.add(j`void outputObjectAndLayerIdColor() {
+}`),A.fragment.code.add(L`void outputObjectAndLayerIdColor() {
 fragColor = objectAndLayerIdColorVarying;
-}`)):(A.vertex.code.add(j`void forwardObjectAndLayerIdColor() {}`),A.fragment.code.add(j`void outputObjectAndLayerIdColor() {}`)),A.include(i),A.include(b,O),z&&(h(I,O),A.include(o)),_.add("vnormal","vec3"),_.add("vcolor","vec4"),I.main.add(j`
+}`)):(A.vertex.code.add(L`void forwardObjectAndLayerIdColor() {}`),A.fragment.code.add(L`void outputObjectAndLayerIdColor() {}`)),A.include(a),A.include(w,S),F&&(h(I,S),A.include(o)),B.add("vnormal","vec3"),B.add("vcolor","vec4"),I.main.add(L`
       ExtrudedVertex extrudedVertex = evaluateVertex();
       vpos = calculateVPos(extrudedVertex);
       vnormal = normalize(localNormal(extrudedVertex));
       gl_Position = transformPosition(proj, view, vpos);
-      ${P(z,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vnormal, cameraPosition);")}
+      ${V(F,"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vnormal, cameraPosition);")}
 
       forwardObjectAndLayerIdColor();
       vcolor = getColor();
-      forwardLinearDepthToReadShadowMap();`)),D){case 0:case 1:case 2:A.include(p,O),B.include(s,O),B.include(t,O),A.include(v,O),B.include(a,O),A.include(C,O),h(B,O),c(B),m(B),B.uniforms.add(I.uniforms.get("localOrigin"),new x("ambient",e=>e.ambient),new x("diffuse",e=>e.diffuse),new L("opacity",e=>e.opacity)),B.include(w),B.include(V,O),g(B),B.main.add(j`
+      forwardLinearDepthToReadShadowMap();`)),D){case 0:case 1:case 2:A.include(p,S),_.include(s,S),_.include(n,S),A.include(v,S),_.include(u,S),_.include(i,S),A.include(C,S),h(_,S),c(_),g(_),_.uniforms.add(I.uniforms.get("localOrigin"),new x("ambient",e=>e.ambient),new x("diffuse",e=>e.diffuse),new j("opacity",e=>e.opacity)),_.include(b),_.include(P,S),_.uniforms.add(m).main.add(L`
         discardBySlice(vpos);
 
-        shadingParams.viewDirection = normalize(vpos - cameraPosition);
-        shadingParams.normalView = vnormal;
-        vec3 normal = shadingNormal(shadingParams);
+        vec3 viewDirection = normalize(vpos - cameraPosition);
+        vec3 normal = shadingNormal(vnormal, viewDirection);
         float ssao = evaluateAmbientOcclusionInverse();
-
-        vec3 posWorld = vpos + localOrigin;
-        vec3 normalGround = ${M?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
+        vec3 upNormal = getLocalUp(vpos, localOrigin);
 
         vec3 albedo = vcolor.rgb * max(ambient, diffuse); // combine the old material parameters into a single one
         float combinedOpacity = vcolor.a * opacity;
 
-        ${P(k,j`float snow = getSnow(normal, normalGround);
+        ${V(N,L`float snow = getSnow(normal, upNormal);
                  albedo = mix(albedo, vec3(1), snow);
                  ssao = mix(ssao, 1.0, snow);`)}
 
+        vec3 posWorld = vpos + localOrigin;
         float additionalAmbientScale = additionalDirectedAmbientLight(posWorld);
         vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
         float shadow = readShadow(additionalAmbientScale, vpos);
 
-        ${P(2===F,`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];\n           ${P(k,"mrr = applySnowToMRR(mrr, snow);")}`)}
-
-        vec3 shadedColor = ${2===F?"evaluateSceneLightingPBR(normal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, additionalAmbientIrradiance);":"evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);"}
+        ${V(2===M&&N,"applySnowToMRR(snow);")}
+        vec3 shadedColor = evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight, viewDirection, upNormal);
         vec4 finalColor = vec4(shadedColor, combinedOpacity);
-        outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${P(k,", snow")});`);break;case 3:A.include(i),I.main.add(j`ExtrudedVertex extrudedVertex = evaluateVertex();
+        outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${V(N,", snow")});`);break;case 3:A.include(a),I.main.add(L`ExtrudedVertex extrudedVertex = evaluateVertex();
 vpos = calculateVPos(extrudedVertex);
-gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(a,O),B.main.add(j`discardBySlice(vpos);`);break;case 5:case 6:case 7:case 8:A.include(i),e(A),_.add("depth","float"),I.main.add(j`ExtrudedVertex extrudedVertex = evaluateVertex();
+gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(i,S),_.main.add(L`discardBySlice(vpos);`);break;case 5:case 6:case 7:case 8:A.include(a),e(A),B.add("depth","float"),I.main.add(L`ExtrudedVertex extrudedVertex = evaluateVertex();
 vpos = calculateVPos(extrudedVertex);
-gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),B.include(a,O),A.include(n,O),B.main.add(j`discardBySlice(vpos);
-outputDepth(depth);`);break;case 11:A.fragment.include(a,O),B.main.add(j`discardBySlice(vpos);
-outputObjectAndLayerIdColor();`);break;case 4:A.include(i),A.include(u,O),y(I),_.add("vnormal","vec3"),_.add("vcolor","vec4"),I.main.add(j`ExtrudedVertex extrudedVertex = evaluateVertex();
+gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),_.include(i,S),A.include(l,S),_.main.add(L`discardBySlice(vpos);
+outputDepth(depth);`);break;case 11:A.fragment.include(i,S),_.main.add(L`discardBySlice(vpos);
+outputObjectAndLayerIdColor();`);break;case 4:A.include(a),I.include(u,S),y(I),B.add("vnormal","vec3"),B.add("vcolor","vec4"),I.main.add(L`ExtrudedVertex extrudedVertex = evaluateVertex();
 vpos = calculateVPos(extrudedVertex);
 vnormal = normalize((viewNormal * vec4(localNormal(extrudedVertex), 1.0)).xyz);
 vcolor = getColor();
-gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(a,O),B.uniforms.add(new L("opacity",e=>e.opacity)),B.main.add(j`discardBySlice(vpos);
+gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(i,S),_.uniforms.add(new j("opacity",e=>e.opacity)),_.main.add(L`discardBySlice(vpos);
 vec3 normal = normalize(vnormal);
 if (gl_FrontFacing == false) normal = -normal;
-fragColor = vec4(vec3(0.5) + 0.5 * normal, vcolor.a * opacity);`);break;case 10:A.include(i),A.include(u,O),_.add("vnormal","vec3"),I.main.add(j`ExtrudedVertex extrudedVertex = evaluateVertex();
+fragColor = vec4(vec3(0.5) + 0.5 * normal, vcolor.a * opacity);`);break;case 10:A.include(a),I.include(u,S),B.add("vnormal","vec3"),I.main.add(L`ExtrudedVertex extrudedVertex = evaluateVertex();
 vpos = calculateVPos(extrudedVertex);
-gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(a,O),A.include(l,O),B.main.add(j`discardBySlice(vpos);
-calculateOcclusionAndOutputHighlight();`)}return A}const A=Object.freeze(Object.defineProperty({__proto__:null,build:O},Symbol.toStringTag,{value:"Module"}));export{A as P,O as b};
+gl_Position = transformPosition(proj, view, vpos);`),A.fragment.include(i,S),A.include(t,S),_.main.add(L`discardBySlice(vpos);
+calculateOcclusionAndOutputHighlight();`)}return A}const A=Object.freeze(Object.defineProperty({__proto__:null,build:S},Symbol.toStringTag,{value:"Module"}));export{A as P,S as b};