@arcgis/core 4.23.3 → 4.24.0-next.20220329

package/chunks/RealisticTree.glsl.js

@@ -1,17 +1,17 @@
 /*
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.23/esri/copyright.txt for details.
+See https://js.arcgis.com/4.24/esri/copyright.txt for details.
 */
-import{ViewingMode as e}from"../views/ViewingMode.js";import{ForwardLinearDepth as o}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";import{Offset as r}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{ShaderOutput as a}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutputOptions.js";import{Slice as i}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as l}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstancedDoublePrecision as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{NormalAttribute as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{PositionAttribute as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PositionAttribute.glsl.js";import{SymbolColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/SymbolColor.glsl.js";import{TextureCoordinateAttribute as c}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as g}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VerticalOffset as m}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as v}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{ReadLinearDepth as p}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadLinearDepth.glsl.js";import{EvaluateAmbientOcclusion as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{multipassTerrainTest as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";import{PhysicallyBasedRendering as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as w,PBRMode as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMap as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{VisualVariables as C}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{symbolAlphaCutoff as L,DiscardOrAdjustAlpha as M}from"../views/3d/webgl-engine/core/shaderLibrary/util/AlphaDiscard.glsl.js";import{MixExternalColor as j}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{glsl as O}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as E}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{VertexAttribute as A}from"../views/3d/webgl-engine/lib/VertexAttribute.js";function _(_){const P=new E,S=P.vertex.code,F=P.fragment.code;return P.vertex.uniforms.add("proj","mat4").add("view","mat4").add("cameraPosition","vec3").add("localOrigin","vec3"),P.include(n),P.varyings.add("vpos","vec3"),P.include(C,_),P.include(t,_),P.include(m,_),_.output!==a.Color&&_.output!==a.Alpha||(P.include(d,_),P.include(l,{linearDepth:!1}),_.offsetBackfaces&&P.include(r),_.instancedColor&&P.attributes.add(A.INSTANCECOLOR,"vec4"),P.varyings.add("vNormalWorld","vec3"),P.varyings.add("localvpos","vec3"),_.multipassTerrainEnabled&&P.varyings.add("depth","float"),P.include(c,_),P.include(o,_),P.include(s,_),P.include(g,_),P.vertex.uniforms.add("externalColor","vec4"),P.varyings.add("vcolorExt","vec4"),S.add(O`
+import{ForwardLinearDepth as e}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";import{Offset as r}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{ShaderOutput as o}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutputOptions.js";import{Slice 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{InstancedDoublePrecision as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{NormalAttribute as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{PositionAttribute as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PositionAttribute.glsl.js";import{SymbolColor as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/SymbolColor.glsl.js";import{TextureCoordinateAttribute as d}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/TextureCoordinateAttribute.glsl.js";import{VertexColor as c}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VerticalOffset as g}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VerticalOffset.glsl.js";import{DefaultMaterialAuxiliaryPasses as m}from"../views/3d/webgl-engine/core/shaderLibrary/default/DefaultMaterialAuxiliaryPasses.glsl.js";import{EvaluateAmbientOcclusion as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{multipassTerrainTest as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";import{PhysicallyBasedRendering as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as b,PBRMode as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMap as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{VisualVariables as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{symbolAlphaCutoff as y,DiscardOrAdjustAlpha as C}from"../views/3d/webgl-engine/core/shaderLibrary/util/AlphaDiscard.glsl.js";import{MixExternalColor as M}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{addProjViewLocalOrigin as L,addCameraPosition as j}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3Uniform as O}from"../views/3d/webgl-engine/core/shaderModules/Float3Uniform.js";import{Float4Uniform as A}from"../views/3d/webgl-engine/core/shaderModules/Float4Uniform.js";import{FloatUniform as _}from"../views/3d/webgl-engine/core/shaderModules/FloatUniform.js";import{glsl as E}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{Matrix4Uniform as F}from"../views/3d/webgl-engine/core/shaderModules/Matrix4Uniform.js";import{ShaderBuilder as S}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{Texture2DUniform as P}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUniform.js";import{TransparencyPassType as T}from"../views/3d/webgl-engine/lib/basicInterfaces.js";import{VertexAttribute as $}from"../views/3d/webgl-engine/lib/VertexAttribute.js";function N(N){const D=new S,V=D.vertex.code,B=D.fragment.code,I=L(D,N);return D.include(s),D.varyings.add("vpos","vec3"),D.include(x,N),D.include(l,N),D.include(g,N),N.output!==o.Color&&N.output!==o.Alpha||(j(D.vertex.uniforms,N),D.include(t,N),D.include(a),N.offsetBackfaces&&D.include(r),N.instancedColor&&D.attributes.add($.INSTANCECOLOR,"vec4"),D.varyings.add("vNormalWorld","vec3"),D.varyings.add("localvpos","vec3"),N.hasMultipassTerrain&&D.varyings.add("depth","float"),D.include(d,N),D.include(e,N),D.include(n,N),D.include(c,N),D.vertex.uniforms.add(new A("externalColor")),D.varyings.add("vcolorExt","vec4"),V.add(E`
         void main(void) {
           forwardNormalizedVertexColor();
           vcolorExt = externalColor;
-          ${_.instancedColor?"vcolorExt *= instanceColor;":""}
+          ${N.instancedColor?"vcolorExt *= instanceColor;":""}
           vcolorExt *= vvColor();
           vcolorExt *= getSymbolColor();
           forwardColorMixMode();
 
-          if (vcolorExt.a < ${O.float(L)}) {
+          if (vcolorExt.a < ${E.float(y)}) {
             gl_Position = vec4(1e38, 1e38, 1e38, 1.0);
           }
           else {
@@ -21,51 +21,51 @@ import{ViewingMode as e}from"../views/ViewingMode.js";import{ForwardLinearDepth
             vNormalWorld = dpNormal(vvLocalNormal(normalModel()));
             vpos = addVerticalOffset(vpos, localOrigin);
             gl_Position = transformPosition(proj, view, vpos);
-            ${_.offsetBackfaces?"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);":""}
+            ${N.offsetBackfaces?"gl_Position = offsetBackfacingClipPosition(gl_Position, vpos, vNormalWorld, cameraPosition);":""}
           }
-          ${_.multipassTerrainEnabled?O`depth = (view * vec4(vpos, 1.0)).z;`:""}
+          ${N.hasMultipassTerrain?E`depth = (view * vec4(vpos, 1.0)).z;`:""}
           forwardLinearDepth();
           forwardTextureCoordinates();
         }
-      `)),_.output===a.Alpha&&(P.include(i,_),P.include(M,_),_.multipassTerrainEnabled&&(P.fragment.include(p),P.include(f,_)),P.fragment.uniforms.add("cameraPosition","vec3").add("localOrigin","vec3").add("opacity","float").add("layerOpacity","float"),P.fragment.uniforms.add("view","mat4"),_.hasColorTexture&&P.fragment.uniforms.add("tex","sampler2D"),P.fragment.include(j),F.add(O`
+      `)),N.output===o.Alpha&&(D.include(i,N),D.include(C,N),D.include(u,N),D.fragment.uniforms.add(new _("opacity")),D.fragment.uniforms.add(new _("layerOpacity")),D.fragment.uniforms.add(new F("view")),N.hasColorTexture&&D.fragment.uniforms.add(new P("tex")),D.fragment.include(M),B.add(E`
       void main() {
         discardBySlice(vpos);
-        ${_.multipassTerrainEnabled?O`terrainDepthTest(gl_FragCoord, depth);`:""}
-        ${_.hasColorTexture?O`
+        ${N.hasMultipassTerrain?E`terrainDepthTest(gl_FragCoord, depth);`:""}
+        ${N.hasColorTexture?E`
         vec4 texColor = texture2D(tex, vuv0);
-        ${_.textureAlphaPremultiplied?"texColor.rgb /= texColor.a;":""}
-        discardOrAdjustAlpha(texColor);`:O`vec4 texColor = vec4(1.0);`}
-        ${_.attributeColor?O`
-        float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));`:O`
+        ${N.textureAlphaPremultiplied?"texColor.rgb /= texColor.a;":""}
+        discardOrAdjustAlpha(texColor);`:E`vec4 texColor = vec4(1.0);`}
+        ${N.hasVertexColors?E`
+        float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));`:E`
         float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));
         `}
 
         gl_FragColor = vec4(opacity_);
       }
-    `)),_.output===a.Color&&(P.include(i,_),P.include(u,_),P.include(b,_),P.include(M,_),_.receiveShadows&&P.include(y,_),_.multipassTerrainEnabled&&(P.fragment.include(p),P.include(f,_)),P.fragment.uniforms.add("cameraPosition","vec3").add("localOrigin","vec3").add("ambient","vec3").add("diffuse","vec3").add("opacity","float").add("layerOpacity","float"),P.fragment.uniforms.add("view","mat4"),_.hasColorTexture&&P.fragment.uniforms.add("tex","sampler2D"),P.include(w,_),P.include(h,_),P.fragment.include(j),F.add(O`
+    `)),N.output===o.Color&&(D.include(i,N),D.include(p,N),D.include(v,N),D.include(C,N),D.include(w,N),D.include(u,N),j(D.fragment.uniforms,N),D.fragment.uniforms.add(I),D.fragment.uniforms.add(new O("ambient")),D.fragment.uniforms.add(new O("diffuse")),D.fragment.uniforms.add(new _("opacity")),D.fragment.uniforms.add(new _("layerOpacity")),D.fragment.uniforms.add(new F("view")),N.hasColorTexture&&D.fragment.uniforms.add(new P("tex")),D.include(b,N),D.include(f,N),D.fragment.include(M),B.add(E`
       void main() {
         discardBySlice(vpos);
-        ${_.multipassTerrainEnabled?O`terrainDepthTest(gl_FragCoord, depth);`:""}
-        ${_.hasColorTexture?O`
+        ${N.hasMultipassTerrain?E`terrainDepthTest(gl_FragCoord, depth);`:""}
+        ${N.hasColorTexture?E`
         vec4 texColor = texture2D(tex, vuv0);
-        ${_.textureAlphaPremultiplied?"texColor.rgb /= texColor.a;":""}
-        discardOrAdjustAlpha(texColor);`:O`vec4 texColor = vec4(1.0);`}
+        ${N.textureAlphaPremultiplied?"texColor.rgb /= texColor.a;":""}
+        discardOrAdjustAlpha(texColor);`:E`vec4 texColor = vec4(1.0);`}
         vec3 viewDirection = normalize(vpos - cameraPosition);
-        ${_.pbrMode===x.Normal?"applyPBRFactors();":""}
+        ${N.pbrMode===h.Normal?"applyPBRFactors();":""}
         float ssao = evaluateAmbientOcclusionInverse();
         ssao *= getBakedOcclusion();
 
         float additionalAmbientScale = additionalDirectedAmbientLight(vpos + localOrigin);
         vec3 additionalLight = ssao * lightingMainIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
-        ${_.receiveShadows?"float shadow = readShadowMap(vpos, linearDepth);":_.viewingMode===e.Global?"float shadow = lightingGlobalFactor * (1.0 - additionalAmbientScale);":"float shadow = 0.0;"}
+        ${N.receiveShadows?"float shadow = readShadowMap(vpos, linearDepth);":N.spherical?"float shadow = lightingGlobalFactor * (1.0 - additionalAmbientScale);":"float shadow = 0.0;"}
         vec3 matColor = max(ambient, diffuse);
-        ${_.attributeColor?O`
+        ${N.hasVertexColors?E`
         vec3 albedo_ = mixExternalColor(vColor.rgb * matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
-        float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));`:O`
+        float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, int(colorMixMode));`:E`
         vec3 albedo_ = mixExternalColor(matColor, texColor.rgb, vcolorExt.rgb, int(colorMixMode));
         float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, int(colorMixMode));
         `}
-        ${O`
+        ${E`
         vec3 shadedNormal = normalize(vNormalWorld);
         albedo_ *= 1.2;
         vec3 viewForward = vec3(view[0][2], view[1][2], view[2][2]);
@@ -74,11 +74,11 @@ import{ViewingMode as e}from"../views/ViewingMode.js";import{ForwardLinearDepth
         float treeRadialFalloff = vColor.r;
         float backLightFactor = 0.5 * treeRadialFalloff * alignmentLightView * transmittance * (1.0 - shadow);
         additionalLight += backLightFactor * lightingMainIntensity;`}
-        ${_.pbrMode===x.Normal||_.pbrMode===x.Schematic?_.viewingMode===e.Global?O`vec3 normalGround = normalize(vpos + localOrigin);`:O`vec3 normalGround = vec3(0.0, 0.0, 1.0);`:O``}
-        ${_.pbrMode===x.Normal||_.pbrMode===x.Schematic?O`
+        ${N.pbrMode===h.Normal||N.pbrMode===h.Schematic?N.spherical?E`vec3 normalGround = normalize(vpos + localOrigin);`:E`vec3 normalGround = vec3(0.0, 0.0, 1.0);`:E``}
+        ${N.pbrMode===h.Normal||N.pbrMode===h.Schematic?E`
             float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * lightingMainIntensity[2];
             vec3 shadedColor = evaluateSceneLightingPBR(shadedNormal, albedo_, shadow, 1.0 - ssao, additionalLight, viewDirection, normalGround, mrr, emission, additionalAmbientIrradiance);`:"vec3 shadedColor = evaluateSceneLighting(shadedNormal, albedo_, shadow, 1.0 - ssao, additionalLight);"}
         gl_FragColor = highlightSlice(vec4(shadedColor, opacity_), vpos);
-        ${_.oitEnabled?"gl_FragColor = premultiplyAlpha(gl_FragColor);":""}
+        ${N.transparencyPassType===T.Color?"gl_FragColor = premultiplyAlpha(gl_FragColor);":""}
       }
-    `)),P.include(v,_),P}const P=Object.freeze({__proto__:null,build:_});export{P as R,_ as b};
+    `)),D.include(m,N),D}const D=Object.freeze(Object.defineProperty({__proto__:null,build:N},Symbol.toStringTag,{value:"Module"}));export{D as R,N as b};

package/chunks/RibbonLine.glsl.js

@@ -1,8 +1,8 @@
 /*
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.23/esri/copyright.txt for details.
+See https://js.arcgis.com/4.24/esri/copyright.txt for details.
 */
-import{ShaderOutput as e}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutputOptions.js";import{Slice as t}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{OutputDepth as n}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{ReadLinearDepth as r}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadLinearDepth.glsl.js";import{LineStipple as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js";import{multipassTerrainTest as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";import{PiUtils as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{symbolAlphaCutoff as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/AlphaDiscard.glsl.js";import{ColorConversion as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{glsl as p}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as c}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{VertexAttribute as v}from"../views/3d/webgl-engine/lib/VertexAttribute.js";const g=1;var m;function f(f){const h=new c,u=f.capType!==m.BUTT,D=f.capType===m.ROUND,x=f.stippleEnabled&&D,S=f.falloffEnabled||x,b=f.innerColorEnabled||D,L=f.stippleEnabled&&f.stippleScaleWithLineWidth||D,y=f.stippleEnabled&&f.stippleScaleWithLineWidth,C=f.stippleEnabled||D;return h.include(s),h.include(i,f),h.include(o,{...f,stippleRequiresStretchMeasure:!0}),f.output===e.Depth&&h.include(n,f),h.vertex.uniforms.add("proj","mat4").add("view","mat4").add("nearFar","vec2").add("pixelRatio","float").add("miterLimit","float").add("screenSize","vec2").add("inverseProjectionMatrix","mat4"),h.vertex.constants.add("LARGE_HALF_FLOAT","float",65500),h.attributes.add(v.POSITION,"vec3"),h.attributes.add(v.SUBDIVISIONFACTOR,"float"),h.attributes.add(v.UV0,"vec2"),h.attributes.add(v.AUXPOS1,"vec3"),h.attributes.add(v.AUXPOS2,"vec3"),h.varyings.add("vColor","vec4"),h.varyings.add("vpos","vec3"),h.varyings.add("linearDepth","float"),f.multipassTerrainEnabled&&h.varyings.add("depth","float"),L&&h.varyings.add("vLineWidth","float"),y&&h.varyings.add("vLineSizeInv","float"),b&&h.varyings.add("vLineDistance","float"),S&&h.varyings.add("vLineDistanceNorm","float"),f.falloffEnabled&&h.fragment.uniforms.add("falloff","float"),f.innerColorEnabled&&(h.fragment.uniforms.add("innerColor","vec4"),h.fragment.uniforms.add("innerWidth","float")),D&&(h.varyings.add("vSegmentSDF","float"),h.varyings.add("vReverseSegmentSDF","float")),h.vertex.code.add(p`#define PERPENDICULAR(v) vec2(v.y, -v.x);
+import{unwrapOr as e}from"../core/maybe.js";import{ShaderOutput as i}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutputOptions.js";import{Slice as t}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{RibbonVertexPosition as o}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{OutputDepth as n}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputDepth.glsl.js";import{LineStipple as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js";import{multipassTerrainTest as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MultipassTerrainTest.glsl.js";import{PiUtils as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{symbolAlphaCutoff as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/AlphaDiscard.glsl.js";import{ColorConversion as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as p}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2Uniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float2Uniform.js";import{Float4Uniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float4Uniform.js";import{FloatUniform as m}from"../views/3d/webgl-engine/core/shaderModules/FloatUniform.js";import{glsl as v}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{Matrix4Uniform as f}from"../views/3d/webgl-engine/core/shaderModules/Matrix4Uniform.js";import{ShaderBuilder as h}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{BindType as u}from"../views/3d/webgl-engine/core/shaderTechnique/BindType.js";import{TransparencyPassType as D}from"../views/3d/webgl-engine/lib/basicInterfaces.js";import{VertexAttribute as S}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{CapType as x}from"../views/3d/webgl-engine/shaders/RibbonLineTechniqueConfiguration.js";const b=1;function L(L){const w=new h;w.include(a),w.include(o,L),w.include(r,L),L.output===i.Depth&&w.include(n,L),p(w,L);const{vertex:y,fragment:C}=w;y.uniforms.add(new f("inverseProjectionMatrix",u.Pass,((e,i)=>i.camera.inverseProjectionMatrix))),y.uniforms.add(new c("nearFar",u.Pass,((e,i)=>i.camera.nearFar))),y.uniforms.add(new m("miterLimit",u.Pass,(e=>"miter"!==e.join?0:e.miterLimit))),y.uniforms.add(new g("viewport",u.Pass,((e,i)=>i.camera.fullViewport))),y.constants.add("LARGE_HALF_FLOAT","float",65500),w.attributes.add(S.POSITION,"vec3"),w.attributes.add(S.SUBDIVISIONFACTOR,"float"),w.attributes.add(S.UV0,"vec2"),w.attributes.add(S.AUXPOS1,"vec3"),w.attributes.add(S.AUXPOS2,"vec3"),w.varyings.add("vColor","vec4"),w.varyings.add("vpos","vec3"),w.varyings.add("linearDepth","float"),L.hasMultipassTerrain&&w.varyings.add("depth","float");const j=L.capType===x.ROUND,R=L.stippleEnabled&&L.stippleScaleWithLineWidth||j;R&&w.varyings.add("vLineWidth","float");const P=L.stippleEnabled&&L.stippleScaleWithLineWidth;P&&w.varyings.add("vLineSizeInv","float");const F=L.innerColorEnabled||j;F&&w.varyings.add("vLineDistance","float");const A=L.stippleEnabled&&j,T=L.falloffEnabled||A;T&&w.varyings.add("vLineDistanceNorm","float"),j&&(w.varyings.add("vSegmentSDF","float"),w.varyings.add("vReverseSegmentSDF","float")),y.code.add(v`#define PERPENDICULAR(v) vec2(v.y, -v.x);
 float interp(float ncp, vec4 a, vec4 b) {
 return (-ncp - a.z) / (b.z - a.z);
 }
@@ -11,11 +11,11 @@ float s = sin(a);
 float c = cos(a);
 mat2 m = mat2(c, -s, s, c);
 return m * v;
-}`),h.vertex.code.add(p`vec4 projectAndScale(vec4 pos) {
+}`),y.code.add(v`vec4 projectAndScale(vec4 pos) {
 vec4 posNdc = proj * pos;
-posNdc.xy *= screenSize / posNdc.w;
+posNdc.xy *= viewport.zw / posNdc.w;
 return posNdc;
-}`),h.vertex.code.add(p`
+}`),y.code.add(v`
     void clipAndTransform(inout vec4 pos, inout vec4 prev, inout vec4 next, in bool isStartVertex) {
       float vnp = nearFar[0] * 0.99;
 
@@ -50,14 +50,14 @@ return posNdc;
         }
       }
 
-      ${f.multipassTerrainEnabled?"depth = pos.z;":""}
+      ${L.hasMultipassTerrain?"depth = pos.z;":""}
       linearDepth = (-pos.z - nearFar[0]) / (nearFar[1] - nearFar[0]);
 
       pos = projectAndScale(pos);
       next = projectAndScale(next);
       prev = projectAndScale(prev);
     }
-  `),h.vertex.code.add(p`
+  `),y.uniforms.add(new m("pixelRatio",u.Pass,((e,i)=>i.camera.pixelRatio))),y.code.add(v`
   void main(void) {
     // unpack values from uv0.y
     bool isStartVertex = abs(abs(uv0.y)-3.0) == 1.0;
@@ -77,8 +77,8 @@ return posNdc;
       float lineSize = getSize();
       float lineWidth = lineSize * pixelRatio;
 
-      ${L?p`vLineWidth = lineWidth;`:""}
-      ${y?p`vLineSizeInv = 1.0 / lineSize;`:""}
+      ${R?v`vLineWidth = lineWidth;`:""}
+      ${P?v`vLineSizeInv = 1.0 / lineSize;`:""}
 
       // convert sub-pixel coverage to alpha
       if (lineWidth < 1.0) {
@@ -102,12 +102,12 @@ return posNdc;
 
       float leftLen = length(left);
       float rightLen = length(right);
-  `),C&&h.vertex.code.add(p`
+  `);(L.stippleEnabled||j)&&y.code.add(v`
       float isEndVertex = float(!isStartVertex);
       vec2 segmentOrigin = mix(pos.xy, prev.xy, isEndVertex);
       vec2 segment = mix(right, left, isEndVertex);
-      ${D?p`vec2 segmentEnd = mix(next.xy, pos.xy, isEndVertex);`:""}
-    `),h.vertex.code.add(p`left = (leftLen > 0.001) ? left/leftLen : vec2(0.0, 0.0);
+      ${j?v`vec2 segmentEnd = mix(next.xy, pos.xy, isEndVertex);`:""}
+    `),y.code.add(v`left = (leftLen > 0.001) ? left/leftLen : vec2(0.0, 0.0);
 right = (rightLen > 0.001) ? right/rightLen : vec2(0.0, 0.0);
 vec2 capDisplacementDir = vec2(0, 0);
 vec2 joinDisplacementDir = vec2(0, 0);
@@ -123,18 +123,18 @@ if (!isOutside) {
 displacementLen = min(displacementLen, min(leftLen, rightLen)/abs(nDotSeg));
 }
 }
-if (isOutside && (displacementLen > miterLimit * lineWidth)) {`),f.roundJoins?h.vertex.code.add(p`
+if (isOutside && (displacementLen > miterLimit * lineWidth)) {`),L.roundJoins?y.code.add(v`
         vec2 startDir = leftLen < 0.001 ? right : left;
         startDir = PERPENDICULAR(startDir);
 
         vec2 endDir = rightLen < 0.001 ? left : right;
         endDir = PERPENDICULAR(endDir);
 
-        float factor = ${f.stippleEnabled?p`min(1.0, subdivisionFactor * ${p.float((g+2)/(g+1))})`:p`subdivisionFactor`};
+        float factor = ${L.stippleEnabled?v`min(1.0, subdivisionFactor * ${v.float((b+2)/(b+1))})`:v`subdivisionFactor`};
 
         float rotationAngle = acos(clamp(dot(startDir, endDir), -1.0, 1.0));
         joinDisplacementDir = rotate(startDir, -sign(uv0.y) * factor * rotationAngle);
-      `):h.vertex.code.add(p`if (leftLen < 0.001) {
+      `):y.code.add(v`if (leftLen < 0.001) {
 joinDisplacementDir = right;
 }
 else if (rightLen < 0.001) {
@@ -143,7 +143,7 @@ joinDisplacementDir = left;
 else {
 joinDisplacementDir = (isStartVertex || subdivisionFactor > 0.0) ? right : left;
 }
-joinDisplacementDir = PERPENDICULAR(joinDisplacementDir);`),h.vertex.code.add(p`
+joinDisplacementDir = PERPENDICULAR(joinDisplacementDir);`);const E=L.capType!==x.BUTT;return y.code.add(v`
         displacementLen = lineWidth;
       }
     } else {
@@ -151,29 +151,29 @@ joinDisplacementDir = PERPENDICULAR(joinDisplacementDir);`),h.vertex.code.add(p`
       joinDisplacementDir = isStartVertex ? right : left;
       joinDisplacementDir = PERPENDICULAR(joinDisplacementDir);
 
-      ${u?p`capDisplacementDir = isStartVertex ? -right : left;`:""}
+      ${E?v`capDisplacementDir = isStartVertex ? -right : left;`:""}
     }
-  `),h.vertex.code.add(p`
+  `),y.code.add(v`
     // Displacement (in pixels) caused by join/or cap
     vec2 dpos = joinDisplacementDir * sign(uv0.y) * displacementLen + capDisplacementDir * displacementLen;
 
-    ${S||b?p`float lineDistNorm = sign(uv0.y) * pos.w;`:""}
+    ${T||F?v`float lineDistNorm = sign(uv0.y) * pos.w;`:""}
 
-    ${b?p`vLineDistance = lineWidth * lineDistNorm;`:""}
-    ${S?p`vLineDistanceNorm = lineDistNorm;`:""}
+    ${F?v`vLineDistance = lineWidth * lineDistNorm;`:""}
+    ${T?v`vLineDistanceNorm = lineDistNorm;`:""}
 
     pos.xy += dpos;
-  `),D&&h.vertex.code.add(p`vec2 segmentDir = normalize(segment);
+  `),j&&y.code.add(v`vec2 segmentDir = normalize(segment);
 vSegmentSDF = (isJoin && isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentOrigin, segmentDir) * pos.w) ;
-vReverseSegmentSDF = (isJoin && !isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentEnd, -segmentDir) * pos.w);`),f.stippleEnabled&&(f.draped||h.vertex.code.add(p`vec3 segmentCenter = mix((auxpos2 + position) * 0.5, (position + auxpos1) * 0.5, isEndVertex);
-float worldToScreenRatio = computeWorldToScreenRatio(segmentCenter);`),h.vertex.code.add(p`float segmentLengthScreenDouble = length(segment);
+vReverseSegmentSDF = (isJoin && !isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentEnd, -segmentDir) * pos.w);`),L.stippleEnabled&&(L.draped?y.uniforms.add(new m("worldToScreenRatio",u.Pass,((e,i)=>1/i.screenToPCSRatio))):y.code.add(v`vec3 segmentCenter = mix((auxpos2 + position) * 0.5, (position + auxpos1) * 0.5, isEndVertex);
+float worldToScreenRatio = computeWorldToScreenRatio(segmentCenter);`),y.code.add(v`float segmentLengthScreenDouble = length(segment);
 float segmentLengthScreen = segmentLengthScreenDouble * 0.5;
 float discreteWorldToScreenRatio = discretizeWorldToScreenRatio(worldToScreenRatio);
 float segmentLengthRender = length(mix(auxpos2 - position, position - auxpos1, isEndVertex));
-vStipplePatternStretch = worldToScreenRatio / discreteWorldToScreenRatio;`),f.draped?h.vertex.code.add(p`float segmentLengthPseudoScreen = segmentLengthScreen / pixelRatio * discreteWorldToScreenRatio / worldToScreenRatio;
-float startPseudoScreen = uv0.x * discreteWorldToScreenRatio - mix(0.0, segmentLengthPseudoScreen, isEndVertex);`):h.vertex.code.add(p`float startPseudoScreen = mix(uv0.x, uv0.x - segmentLengthRender, isEndVertex) * discreteWorldToScreenRatio;
-float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRatio;`),h.vertex.code.add(p`
-      float patternLength = ${f.stippleScaleWithLineWidth?"lineSize * ":""} stipplePatternPixelSize;
+vStipplePatternStretch = worldToScreenRatio / discreteWorldToScreenRatio;`),L.draped?y.code.add(v`float segmentLengthPseudoScreen = segmentLengthScreen / pixelRatio * discreteWorldToScreenRatio / worldToScreenRatio;
+float startPseudoScreen = uv0.x * discreteWorldToScreenRatio - mix(0.0, segmentLengthPseudoScreen, isEndVertex);`):y.code.add(v`float startPseudoScreen = mix(uv0.x, uv0.x - segmentLengthRender, isEndVertex) * discreteWorldToScreenRatio;
+float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRatio;`),y.code.add(v`
+      float patternLength = ${L.stippleScaleWithLineWidth?"lineSize * ":""} stipplePatternPixelSize;
 
       // Compute the coordinates at both start and end of the line segment, because we need both to clamp to in the fragment shader
       vStippleDistanceLimits = computeStippleDistanceLimits(startPseudoScreen, segmentLengthPseudoScreen, segmentLengthScreen, patternLength);
@@ -201,25 +201,25 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
                                  isStartVertex ?
                                   vec2(-1e038, vStippleDistanceLimits.y) :
                                   vec2(vStippleDistanceLimits.x, 1e038);
-    `)),h.vertex.code.add(p`
+    `)),y.code.add(v`
       // Convert back into NDC
-      pos.xy = (pos.xy / screenSize) * pos.w;
+      pos.xy = (pos.xy / viewport.zw) * pos.w;
 
       vColor = getColor();
       vColor.a *= coverage;
 
-      ${f.wireframe&&!f.draped?"pos.z -= 0.001 * pos.w;":""}
+      ${L.wireframe&&!L.draped?"pos.z -= 0.001 * pos.w;":""}
 
       // transform final position to camera space for slicing
       vpos = (inverseProjectionMatrix * pos).xyz;
       gl_Position = pos;
     }
   }
-  `),f.multipassTerrainEnabled&&(h.fragment.include(r),h.include(a,f)),h.include(t,f),h.fragment.uniforms.add("intrinsicColor","vec4"),h.fragment.include(d),h.fragment.code.add(p`
+  `),w.include(s,L),w.include(t,L),C.include(d),C.code.add(v`
   void main() {
     discardBySlice(vpos);
-    ${f.multipassTerrainEnabled?"terrainDepthTest(gl_FragCoord, depth);":""}
-  `),f.wireframe?h.fragment.code.add(p`vec4 finalColor = vec4(1.0, 0.0, 1.0, 1.0);`):(D&&h.fragment.code.add(p`
+    ${L.hasMultipassTerrain?"terrainDepthTest(gl_FragCoord, depth);":""}
+  `),L.wireframe?C.code.add(v`vec4 finalColor = vec4(1.0, 0.0, 1.0, 1.0);`):(j&&C.code.add(v`
       float sdf = min(vSegmentSDF, vReverseSegmentSDF);
       vec2 fragmentPosition = vec2(
         min(sdf, 0.0),
@@ -230,10 +230,10 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
       float fragmentCapSDF = (fragmentRadius - vLineWidth) * 0.5; // Divide by 2 to transform from double pixel scale
       float capCoverage = clamp(0.5 - fragmentCapSDF, 0.0, 1.0);
 
-      if (capCoverage < ${p.float(l)}) {
+      if (capCoverage < ${v.float(l)}) {
         discard;
       }
-    `),x?h.fragment.code.add(p`
+    `),A?C.code.add(v`
       vec2 stipplePosition = vec2(
         min(getStippleSDF() * 2.0 - 1.0, 0.0),
         vLineDistanceNorm * gl_FragCoord.w
@@ -241,20 +241,20 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
       float stippleRadius = length(stipplePosition * vLineWidth);
       float stippleCapSDF = (stippleRadius - vLineWidth) * 0.5; // Divide by 2 to transform from double pixel scale
       float stippleCoverage = clamp(0.5 - stippleCapSDF, 0.0, 1.0);
-      float stippleAlpha = step(${p.float(l)}, stippleCoverage);
-      `):h.fragment.code.add(p`float stippleAlpha = getStippleAlpha();`),h.fragment.code.add(p`discardByStippleAlpha(stippleAlpha, stippleAlphaColorDiscard);
-vec4 color = intrinsicColor * vColor;`),f.innerColorEnabled&&h.fragment.code.add(p`float distToInner = abs(vLineDistance * gl_FragCoord.w) - innerWidth;
+      float stippleAlpha = step(${v.float(l)}, stippleCoverage);
+      `):C.code.add(v`float stippleAlpha = getStippleAlpha();`),C.uniforms.add(new g("intrinsicColor",u.Pass,(e=>e.color))),C.code.add(v`discardByStippleAlpha(stippleAlpha, stippleAlphaColorDiscard);
+vec4 color = intrinsicColor * vColor;`),L.innerColorEnabled&&(C.uniforms.add(new g("innerColor",u.Pass,(i=>e(i.innerColor,i.color)))),C.uniforms.add(new m("innerWidth",u.Pass,((e,i)=>e.innerWidth*i.camera.pixelRatio))),C.code.add(v`float distToInner = abs(vLineDistance * gl_FragCoord.w) - innerWidth;
 float innerAA = clamp(0.5 - distToInner, 0.0, 1.0);
 float innerAlpha = innerColor.a + color.a * (1.0 - innerColor.a);
-color = mix(color, vec4(innerColor.rgb, innerAlpha), innerAA);`),h.fragment.code.add(p`vec4 finalColor = blendStipple(color, stippleAlpha);`),f.falloffEnabled&&h.fragment.code.add(p`finalColor.a *= pow(max(0.0, 1.0 - abs(vLineDistanceNorm * gl_FragCoord.w)), falloff);`)),h.fragment.code.add(p`
-    if (finalColor.a < ${p.float(l)}) {
+color = mix(color, vec4(innerColor.rgb, innerAlpha), innerAA);`)),C.code.add(v`vec4 finalColor = blendStipple(color, stippleAlpha);`),L.falloffEnabled&&(C.uniforms.add(new m("falloff",u.Pass,(e=>e.falloff))),C.code.add(v`finalColor.a *= pow(max(0.0, 1.0 - abs(vLineDistanceNorm * gl_FragCoord.w)), falloff);`))),C.code.add(v`
+    if (finalColor.a < ${v.float(l)}) {
       discard;
     }
 
-    ${f.output===e.Alpha?p`gl_FragColor = vec4(finalColor.a);`:""}
-    ${f.output===e.Color?p`gl_FragColor = highlightSlice(finalColor, vpos);`:""}
-    ${f.output===e.Color&&f.oitEnabled?"gl_FragColor = premultiplyAlpha(gl_FragColor);":""}
-    ${f.output===e.Highlight?p`gl_FragColor = vec4(1.0);`:""}
-    ${f.output===e.Depth?p`outputDepth(linearDepth);`:""}
+    ${L.output===i.Alpha?v`gl_FragColor = vec4(finalColor.a);`:""}
+    ${L.output===i.Color?v`gl_FragColor = highlightSlice(finalColor, vpos);`:""}
+    ${L.output===i.Color&&L.transparencyPassType===D.Color?"gl_FragColor = premultiplyAlpha(gl_FragColor);":""}
+    ${L.output===i.Highlight?v`gl_FragColor = vec4(1.0);`:""}
+    ${L.output===i.Depth?v`outputDepth(linearDepth);`:""}
   }
-  `),h}!function(e){e[e.BUTT=0]="BUTT",e[e.SQUARE=1]="SQUARE",e[e.ROUND=2]="ROUND",e[e.COUNT=3]="COUNT"}(m||(m={}));const h=Object.freeze({__proto__:null,NUM_ROUND_JOIN_SUBDIVISIONS:g,get CapType(){return m},build:f});export{m as C,g as N,h as R,f as b};
+  `),w}const w=Object.freeze(Object.defineProperty({__proto__:null,NUM_ROUND_JOIN_SUBDIVISIONS:b,build:L},Symbol.toStringTag,{value:"Module"}));export{b as N,w as R,L as b};

package/chunks/SMAA.glsl.js

@@ -1,8 +1,8 @@
 /*
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.23/esri/copyright.txt for details.
+See https://js.arcgis.com/4.24/esri/copyright.txt for details.
 */
-import{glsl as e}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as o}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{VertexAttribute as t}from"../views/3d/webgl-engine/lib/VertexAttribute.js";var r;function d(d){const s=new o;return d.output===r.EdgeDetector&&(s.attributes.add(t.POSITION,"vec2"),s.vertex.uniforms.add("resolution","vec4"),s.varyings.add("fTexCoord","vec2"),s.varyings.add("fOffset[3]","vec4"),s.vertex.code.add(e`void SMAAEdgeDetectionVS( vec2 texcoord ) {
+import{Float4Uniform as e}from"../views/3d/webgl-engine/core/shaderModules/Float4Uniform.js";import{glsl as o}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as t}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{Texture2DUniform as r}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUniform.js";import{SMAAOutput as s}from"../views/3d/webgl-engine/lib/SMAATechniqueConfiguration.js";import{VertexAttribute as d}from"../views/3d/webgl-engine/lib/VertexAttribute.js";const a={threshold:.05,localConstrastAdaption:2,maxSearchSteps:8,maxDistanceAreaTex:16};function x(x){const c=new t;return x.output===s.EdgeDetector&&(c.attributes.add(d.POSITION,"vec2"),c.vertex.uniforms.add(new e("resolution")),c.varyings.add("fTexCoord","vec2"),c.varyings.add("fOffset[3]","vec4"),c.vertex.code.add(o`void SMAAEdgeDetectionVS( vec2 texcoord ) {
 fOffset[0] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );
 fOffset[1] = texcoord.xyxy + resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );
 fOffset[2] = texcoord.xyxy + resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );
@@ -11,9 +11,9 @@ void main() {
 fTexCoord = (position + 1.0 ) * 0.5;
 gl_Position = vec4(position, 0, 1);
 SMAAEdgeDetectionVS( fTexCoord );
-}`),s.fragment.uniforms.add("tColor","sampler2D"),s.fragment.code.add(e`
+}`),c.fragment.uniforms.add(new r("tColor")),c.fragment.code.add(o`
       vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {
-        vec2 threshold = vec2( ${e.float(d.threshold)} );
+        vec2 threshold = vec2( ${o.float(a.threshold)} );
 
         // Calculate color deltas:
         vec4 delta;
@@ -59,7 +59,7 @@ SMAAEdgeDetectionVS( fTexCoord );
         maxDelta = max( max( maxDelta, delta.z ), delta.w );
 
         // Local contrast adaptation in action:
-        edges.xy *= step( maxDelta, float(${e.float(d.localConstrastAdaption)}) * delta.xy );
+        edges.xy *= step( maxDelta, float(${o.float(a.localConstrastAdaption)}) * delta.xy );
 
         return vec4( edges, 0.0, 0.0 );
       }
@@ -67,12 +67,12 @@ SMAAEdgeDetectionVS( fTexCoord );
       void main() {
         gl_FragColor = SMAAColorEdgeDetectionPS( fTexCoord, fOffset, tColor );
       }
-    `)),d.output===r.BlendWeight&&(s.attributes.add(t.POSITION,"vec2"),s.vertex.uniforms.add("resolution","vec4"),s.varyings.add("fTexCoord","vec2"),s.varyings.add("fOffset[3]","vec4"),s.varyings.add("fPixCoord","vec2"),s.vertex.code.add(e`
+    `)),x.output===s.BlendWeight&&(c.attributes.add(d.POSITION,"vec2"),c.vertex.uniforms.add(new e("resolution")),c.varyings.add("fTexCoord","vec2"),c.varyings.add("fOffset[3]","vec4"),c.varyings.add("fPixCoord","vec2"),c.vertex.code.add(o`
       void SMAABlendingWeightCalculationVS( vec2 texcoord ) {
         fPixCoord = texcoord * resolution.zw;
         fOffset[0] = texcoord.xyxy + resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );
         fOffset[1] = texcoord.xyxy + resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );
-        fOffset[2] = vec4( fOffset[0].xz, fOffset[1].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( ${e.int(d.maxSearchSteps)} );
+        fOffset[2] = vec4( fOffset[0].xz, fOffset[1].yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * resolution.xxyy * float( ${o.int(a.maxSearchSteps)} );
       }
 
       void main() {
@@ -80,7 +80,7 @@ SMAAEdgeDetectionVS( fTexCoord );
         gl_Position = vec4(position, 0, 1);
         SMAABlendingWeightCalculationVS( fTexCoord );
       }
-    `),s.fragment.uniforms.add("tEdges","sampler2D").add("tArea","sampler2D").add("tSearch","sampler2D").add("tColor","sampler2D").add("resolution","vec4"),s.fragment.code.add(e`
+    `),c.fragment.uniforms.add(new r("tEdges")),c.fragment.uniforms.add(new r("tArea")),c.fragment.uniforms.add(new r("tSearch")),c.fragment.uniforms.add(new r("tColor")),c.fragment.uniforms.add(new e("resolution")),c.fragment.code.add(o`
       #define SMAA_AREATEX_PIXEL_SIZE ( 1.0 / vec2( 160.0, 560.0 ) )
       #define SMAA_AREATEX_SUBTEX_SIZE ( 1.0 / 7.0 )
 
@@ -99,7 +99,7 @@ SMAAEdgeDetectionVS( fTexCoord );
 
       float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
         vec2 e = vec2( 0.0, 1.0 );
-        for ( int i = 0; i < ${e.int(d.maxSearchSteps)}; i ++ ) {
+        for ( int i = 0; i < ${o.int(a.maxSearchSteps)}; i ++ ) {
           e = texture2D( edgesTex, texcoord, 0.0 ).rg;
           texcoord -= vec2( 2.0, 0.0 ) * resolution.xy;
           if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;
@@ -113,7 +113,7 @@ SMAAEdgeDetectionVS( fTexCoord );
 
       float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
         vec2 e = vec2( 0.0, 1.0 );
-        for ( int i = 0; i < ${e.int(d.maxSearchSteps)}; i ++ ) {
+        for ( int i = 0; i < ${o.int(a.maxSearchSteps)}; i ++ ) {
           e = texture2D( edgesTex, texcoord, 0.0 ).rg;
           texcoord += vec2( 2.0, 0.0 ) * resolution.xy;
           if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;
@@ -127,7 +127,7 @@ SMAAEdgeDetectionVS( fTexCoord );
 
       float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
         vec2 e = vec2( 1.0, 0.0 );
-        for ( int i = 0; i < ${e.int(d.maxSearchSteps)}; i ++ ) {
+        for ( int i = 0; i < ${o.int(a.maxSearchSteps)}; i ++ ) {
           e = texture2D( edgesTex, texcoord, 0.0 ).rg;
           texcoord += vec2( 0.0, 2.0 ) * resolution.xy;
           if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;
@@ -141,7 +141,7 @@ SMAAEdgeDetectionVS( fTexCoord );
 
       float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
         vec2 e = vec2( 1.0, 0.0 );
-        for ( int i = 0; i < ${e.int(d.maxSearchSteps)}; i ++ ) {
+        for ( int i = 0; i < ${o.int(a.maxSearchSteps)}; i ++ ) {
           e = texture2D( edgesTex, texcoord, 0.0 ).rg;
           texcoord -= vec2( 0.0, 2.0 ) * resolution.xy;
           if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;
@@ -154,7 +154,7 @@ SMAAEdgeDetectionVS( fTexCoord );
       }
 
       vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {
-        vec2 texcoord = float( ${e.int(d.maxDistanceAreaTex)} ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
+        vec2 texcoord = float( ${o.int(a.maxDistanceAreaTex)} ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
         texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );
         texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
         return texture2D( areaTex, texcoord, 0.0 ).rg;
@@ -205,7 +205,7 @@ SMAAEdgeDetectionVS( fTexCoord );
       void main() {
         gl_FragColor = SMAABlendingWeightCalculationPS( fTexCoord, fPixCoord, fOffset, tEdges, tArea, tSearch, ivec4( 0.0 ) );
       }
-    `)),d.output===r.Blur&&(s.attributes.add(t.POSITION,"vec2"),s.vertex.uniforms.add("resolution","vec4"),s.varyings.add("fTexCoord","vec2"),s.varyings.add("fOffset[2]","vec4"),s.vertex.code.add(e`void SMAANeighborhoodBlendingVS( vec2 texcoord ) {
+    `)),x.output===s.Blur&&(c.attributes.add(d.POSITION,"vec2"),c.vertex.uniforms.add(new e("resolution")),c.varyings.add("fTexCoord","vec2"),c.varyings.add("fOffset[2]","vec4"),c.vertex.code.add(o`void SMAANeighborhoodBlendingVS( vec2 texcoord ) {
 fOffset[0] = texcoord.xyxy + resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );
 fOffset[1] = texcoord.xyxy + resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );
 }
@@ -213,7 +213,7 @@ void main() {
 fTexCoord = (position + 1.0 ) * 0.5;
 gl_Position = vec4(position, 0, 1);
 SMAANeighborhoodBlendingVS(fTexCoord);
-}`),s.fragment.uniforms.add("tBlendWeights","sampler2D"),s.fragment.uniforms.add("tColor","sampler2D"),s.fragment.uniforms.add("resolution","vec4"),s.fragment.code.add(e`vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
+}`),c.fragment.uniforms.add(new r("tBlendWeights")),c.fragment.uniforms.add(new r("tColor")),c.fragment.uniforms.add(new e("resolution")),c.fragment.code.add(o`vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
 vec4 a;
 a.xz = texture2D( blendTex, texcoord ).xz;
 a.y = texture2D( blendTex, offset[ 1 ].zw ).g;
@@ -239,4 +239,4 @@ return mixed;
 }
 void main() {
 gl_FragColor = SMAANeighborhoodBlendingPS( fTexCoord, fOffset, tColor, tBlendWeights );
-}`)),s}!function(e){e[e.EdgeDetector=0]="EdgeDetector",e[e.BlendWeight=1]="BlendWeight",e[e.Blur=2]="Blur",e[e.COUNT=3]="COUNT"}(r||(r={}));const s=Object.freeze({__proto__:null,get SMAAOutput(){return r},build:d});export{r as S,s as a,d as b};
+}`)),c}const c=Object.freeze(Object.defineProperty({__proto__:null,build:x},Symbol.toStringTag,{value:"Module"}));export{c as S,x as b};

package/chunks/SSAO.glsl.js

@@ -1,19 +1,19 @@
 /*
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.23/esri/copyright.txt for details.
+See https://js.arcgis.com/4.24/esri/copyright.txt for details.
 */
-import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.js";import{ReadLinearDepth as r}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadLinearDepth.glsl.js";import{CameraSpace as a}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{glsl as t}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as o}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";var n;function l(l){const s=new o;return s.include(e),l.output===n.Blur&&(s.fragment.include(r),s.fragment.uniforms.add("normalMap","sampler2D").add("depthMap","sampler2D").add("tex","sampler2D").add("blurSize","vec2").add("projScale","float").add("nearFar","vec2"),s.fragment.code.add(t`
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.js";import{ReadLinearDepth as r}from"../views/3d/webgl-engine/core/shaderLibrary/output/ReadLinearDepth.glsl.js";import{CameraSpace as o}from"../views/3d/webgl-engine/core/shaderLibrary/util/CameraSpace.glsl.js";import{Float2Uniform as a}from"../views/3d/webgl-engine/core/shaderModules/Float2Uniform.js";import{FloatUniform as t}from"../views/3d/webgl-engine/core/shaderModules/FloatUniform.js";import{glsl as n}from"../views/3d/webgl-engine/core/shaderModules/interfaces.js";import{ShaderBuilder as i}from"../views/3d/webgl-engine/core/shaderModules/ShaderBuilder.js";import{Texture2DUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Texture2DUniform.js";import{BindType as l}from"../views/3d/webgl-engine/core/shaderTechnique/BindType.js";import{SSAOOutput as c}from"../views/3d/webgl-engine/lib/SSAOTechniqueConfiguration.js";const d={samples:16,filterRadius:4};function f(f){const u=new i,p=u.fragment;if(u.include(e),f.output===c.Blur){const e=(d.filterRadius+1)/2,o=1/(2*e*e);p.include(r),p.uniforms.add(new s("normalMap")),p.uniforms.add(new s("depthMap")),p.uniforms.add(new s("tex")),p.uniforms.add(new a("blurSize")),p.uniforms.add(new t("projScale")),p.uniforms.add(new a("nearFar",l.Pass,((e,r)=>r.camera.nearFar))),p.code.add(n`
       void blurFunction(vec2 uv, float r, float center_d, float sharpness, inout float wTotal, inout float bTotal) {
         float c = texture2D(tex, uv).r;
         float d = linearDepthFromTexture(depthMap, uv, nearFar);
 
         float ddiff = d - center_d;
 
-        float w = exp(-r * r * ${t.float(l.blurFalloff)} - ddiff * ddiff * sharpness);
+        float w = exp(-r * r * ${n.float(o)} - ddiff * ddiff * sharpness);
         wTotal += w;
         bTotal += w * c;
       }
-    `),s.fragment.code.add(t`
+    `),p.code.add(n`
       void main(void) {
         float b = 0.0;
         float w_total = 0.0;
@@ -21,7 +21,7 @@ import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/Scr
         float center_d = linearDepthFromTexture(depthMap, uv, nearFar);
 
         float sharpness = -0.05 * projScale/center_d;
-        for (int r = -${t.int(l.filterRadius)}; r <= ${t.int(l.filterRadius)}; ++r) {
+        for (int r = -${n.int(d.filterRadius)}; r <= ${n.int(d.filterRadius)}; ++r) {
           float rf = float(r);
           vec2 uvOffset = uv + rf * blurSize;
           blurFunction(uvOffset, rf, center_d, sharpness, w_total, b);
@@ -29,7 +29,7 @@ import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/Scr
 
         gl_FragColor = vec4(b / w_total);
       }
-    `)),l.output===n.SSAO&&(s.fragment.include(r),s.include(a),s.fragment.uniforms.add("normalMap","sampler2D").add("depthMap","sampler2D").add("intensity","float").add("projScale","float").add("radius","float").add("nearFar","vec2").add("screenDimensions","vec2").add("rnmScale","vec2").add("rnm","sampler2D"),s.fragment.code.add(t`vec3 sphere[16];
+    `)}return f.output===c.SSAO&&(p.include(r),u.include(o),p.uniforms.add(new s("normalMap")),p.uniforms.add(new s("depthMap")),p.uniforms.add(new s("rnm")),p.uniforms.add(new t("intensity")),p.uniforms.add(new t("projScale")),p.uniforms.add(new t("radius")),p.uniforms.add(new a("nearFar",l.Pass,((e,r)=>r.camera.nearFar))),p.uniforms.add(new a("screenSize")),p.uniforms.add(new a("rnmScale")),p.code.add(n`vec3 sphere[16];
 void fillSphere() {
 sphere[0] = vec3(0.186937, 0.0, 0.0);
 sphere[1] = vec3(0.700542, 0.0, 0.0);
@@ -51,12 +51,12 @@ sphere[15] = vec3(0.417709, -0.386701, 0.442449);
 float fallOffFunction(float vv, float vn, float bias) {
 float f = max(radius * radius - vv, 0.0);
 return f * f * f * max(vn-bias, 0.0);
-}`),s.fragment.code.add(t`float aoValueFromPositionsAndNormal(vec3 C, vec3 n_C, vec3 Q) {
+}`),p.code.add(n`float aoValueFromPositionsAndNormal(vec3 C, vec3 n_C, vec3 Q) {
 vec3 v = Q - C;
 float vv = dot(v, v);
 float vn = dot(normalize(v), n_C);
 return fallOffFunction(vv, vn, 0.1);
-}`),s.fragment.code.add(t`
+}`),p.code.add(n`
       void main(void) {
         fillSphere();
         vec3 fres = normalize((texture2D(rnm, uv * rnmScale).xyz * 2.0) - vec3(1.0));
@@ -81,7 +81,7 @@ return fallOffFunction(vv, vn, 0.1);
         // bug or deviation from CE somewhere else?
         float ps = projScale/(2.0 * currentPixelPos.z * zScale.x + zScale.y);
 
-        for(int i = 0; i < ${t.int(l.samples)}; ++i) {
+        for(int i = 0; i < ${n.int(d.samples)}; ++i) {
           vec2 unitOffset = reflect(sphere[i], fres).xy;
           vec2 offset = vec2(-unitOffset * radius * ps);
 
@@ -89,8 +89,8 @@ return fallOffFunction(vv, vn, 0.1);
           if ( abs(offset.x)<2.0 || abs(offset.y)<2.0) continue;
 
           vec2 tc = vec2(gl_FragCoord.xy + offset);
-          if (tc.x < 0.0 || tc.y < 0.0 || tc.x > screenDimensions.x || tc.y > screenDimensions.y) continue;
-          vec2 tcTap = tc/screenDimensions;
+          if (tc.x < 0.0 || tc.y < 0.0 || tc.x > screenSize.x || tc.y > screenSize.y) continue;
+          vec2 tcTap = tc / screenSize;
           float occluderFragmentDepth = linearDepthFromTexture(depthMap, tcTap, nearFar);
 
           if (isTerrain) {
@@ -106,10 +106,10 @@ return fallOffFunction(vv, vn, 0.1);
         }
 
         // output the result
-        float A = max(1.0-sum*intensity/float(${t.int(l.samples)}),0.0);
+        float A = max(1.0-sum*intensity/float(${n.int(d.samples)}),0.0);
 
         // Anti-tone map to reduce contrast and drag dark region farther: (x^0.2 + 1.2 * x^4)/2.2
         A = (pow(A, 0.2) + 1.2 * A*A*A*A) / 2.2;
         gl_FragColor = vec4(A);
       }
-    `)),s}!function(e){e[e.SSAO=0]="SSAO",e[e.Blur=1]="Blur",e[e.COUNT=2]="COUNT"}(n||(n={}));const s=Object.freeze({__proto__:null,get SSAOOutput(){return n},build:l});export{n as S,s as a,l as b};
+    `)),u}const u=Object.freeze(Object.defineProperty({__proto__:null,build:f},Symbol.toStringTag,{value:"Module"}));export{u as S,f as b};