@arcgis/core 4.34.0-next.26 → 4.34.0-next.27

package/chunks/MeasurementArrow.glsl.js

@@ -2,13 +2,13 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{addProjViewLocalOrigin as e}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{VertexAttribute as i}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{ShaderBuilder as n}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as s}from"../webscene/support/AlphaCutoff.js";function d(d){const a=new n,{vertex:l,fragment:c}=a;e(l,d),l.uniforms.add(new o("width",e=>e.width)),a.attributes.add(i.POSITION,"vec3"),a.attributes.add(i.NORMAL,"vec3"),a.attributes.add(i.UV0,"vec2"),a.attributes.add(i.LENGTH,"float"),a.varyings.add("vtc","vec2"),a.varyings.add("vlength","float"),a.varyings.add("vradius","float"),l.main.add(r`vec3 bitangent = normal;
+import{addProjViewLocalOrigin as e}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as r}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{ShaderBuilder as i}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as n}from"../webscene/support/AlphaCutoff.js";function s(s){const a=new i,{vertex:d,fragment:l}=a;e(d,s),d.uniforms.add(new o("width",e=>e.width)),a.attributes.add("position","vec3"),a.attributes.add("normal","vec3"),a.attributes.add("uv0","vec2"),a.attributes.add("length","float"),a.varyings.add("vtc","vec2"),a.varyings.add("vlength","float"),a.varyings.add("vradius","float"),d.main.add(r`vec3 bitangent = normal;
 vtc = uv0;
 vlength = length;
 vradius = 0.5 * width;
 vec4 pos = view * vec4(position + vradius * bitangent * uv0.y, 1.0);
-gl_Position = proj * pos;`),c.uniforms.add(new o("outlineSize",e=>e.outlineSize),new t("outlineColor",e=>e.outlineColor),new o("stripeLength",e=>e.stripeLength),new t("stripeEvenColor",e=>e.stripeEvenColor),new t("stripeOddColor",e=>e.stripeOddColor));const v=1/Math.sqrt(2);return c.code.add(r`
-    const float INV_SQRT2 = ${r.float(v)};
+gl_Position = proj * pos;`),l.uniforms.add(new o("outlineSize",e=>e.outlineSize),new t("outlineColor",e=>e.outlineColor),new o("stripeLength",e=>e.stripeLength),new t("stripeEvenColor",e=>e.stripeEvenColor),new t("stripeOddColor",e=>e.stripeOddColor));const c=1/Math.sqrt(2);return l.code.add(r`
+    const float INV_SQRT2 = ${r.float(c)};
 
     vec4 arrowColor(vec2 tc, float len) {
       float d = INV_SQRT2 * (tc.x - abs(tc.y));
@@ -22,10 +22,10 @@ gl_Position = proj * pos;`),c.uniforms.add(new o("outlineSize",e=>e.outlineSize)
         return outlineColor;
       }
       return fract(0.5 / stripeLength * tc.x * vradius) >= 0.5 ? stripeOddColor : stripeEvenColor;
-    }`),c.main.add(r`
+    }`),l.main.add(r`
     vec2 ntc = vec2(vtc.x / vradius, vtc.y);
     vec4 color = arrowColor(ntc, vlength / vradius);
-    if (color.a < ${r.float(s)}) {
+    if (color.a < ${r.float(n)}) {
       discard;
     }
-    fragColor = color;`),a}const a=Object.freeze(Object.defineProperty({__proto__:null,build:d},Symbol.toStringTag,{value:"Module"}));export{a as M,d as b};
+    fragColor = color;`),a}const a=Object.freeze(Object.defineProperty({__proto__:null,build:s},Symbol.toStringTag,{value:"Module"}));export{a as M,s as b};

package/chunks/NativeLine.glsl.js

@@ -2,19 +2,19 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{ShaderOutput as e,isColorOrColorEmission 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{VertexColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{OutputHighlight as t}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{addProjViewLocalOrigin as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as n}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as d}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{VertexAttribute as c}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as m}from"../webscene/support/AlphaCutoff.js";function u(u){const p=new g,{vertex:w,fragment:f,varyings:b}=p;return p.include(i,u),p.include(s,u),l(w,u),p.attributes.add(c.POSITION,"vec3"),b.add("vpos","vec3",{invariant:!0}),w.main.add(d`vpos = position;
+import{isColorOrColorEmission as e}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 r}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{VertexColor as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{OutputHighlight as s}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{addProjViewLocalOrigin as t}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as n}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{ShaderBuilder as d}from"../views/webgl/ShaderBuilder.js";import{alphaCutoff as c}from"../webscene/support/AlphaCutoff.js";function g(g){const m=new d,{vertex:p,fragment:u,varyings:f}=m;return m.include(r,g),m.include(i,g),t(p,g),m.attributes.add("position","vec3"),f.add("vpos","vec3",{invariant:!0}),p.main.add(n`vpos = position;
 forwardNormalizedVertexColor();
-gl_Position = transformPosition(proj, view, vpos);`),p.include(t,u),p.fragment.include(o,u),f.uniforms.add(new n("alphaCoverage",(e,r)=>Math.min(1,e.width*r.camera.pixelRatio))),u.hasVertexColors||f.uniforms.add(new a("constantColor",e=>e.color)),f.main.add(d`
+gl_Position = transformPosition(proj, view, vpos);`),m.include(s,g),m.fragment.include(o,g),u.uniforms.add(new a("alphaCoverage",(e,o)=>Math.min(1,e.width*o.camera.pixelRatio))),g.hasVertexColors||u.uniforms.add(new l("constantColor",e=>e.color)),u.main.add(n`
     discardBySlice(vpos);
 
-    vec4 color = ${u.hasVertexColors?"vColor":"constantColor"};
+    vec4 color = ${g.hasVertexColors?"vColor":"constantColor"};
 
-    ${u.output===e.ObjectAndLayerIdColor?"color.a = 1.0;":""}
+    ${9===g.output?"color.a = 1.0;":""}
 
-    if (color.a < ${d.float(m)}) {
+    if (color.a < ${n.float(c)}) {
       discard;
     }
 
-    ${r(u.output)?d`fragColor = applySlice(color, vpos);`:""}
+    ${e(g.output)?n`fragColor = applySlice(color, vpos);`:""}
     calculateOcclusionAndOutputHighlight();
-  `),p}const p=Object.freeze(Object.defineProperty({__proto__:null,build:u},Symbol.toStringTag,{value:"Module"}));export{p as N,u as b};
+  `),m}const m=Object.freeze(Object.defineProperty({__proto__:null,build:g},Symbol.toStringTag,{value:"Module"}));export{m as N,g as b};

package/chunks/NoiseTextureAtlas.glsl.js

@@ -2,11 +2,11 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{fromValues as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{NoiseTextureRenderMode as o}from"../views/3d/environment/NoiseTextureAtlasConfiguration.js";import{tileRows as t,weatherTileSize as a,weatherMapSize as r,tileSize as l,atlasSize as i}from"../views/3d/environment/NoiseTextureAtlasDimensions.js";import{ScreenSpacePass as f}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{Float2PassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{glsl as p}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{NoParameters as n}from"../views/webgl/NoParameters.js";import{ShaderBuilder as c}from"../views/webgl/ShaderBuilder.js";class s extends n{constructor(){super(...arguments),this.weatherTile=e(0,0)}}function u(e){const n=new c;if(n.include(f,!1),n.fragment.code.add(p`float remap(float x, float low1, float high1, float low2, float high2) {
+import{fromValues as e}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{tileRows as o,weatherTileSize as t,weatherMapSize as a,tileSize as r,atlasSize as l}from"../views/3d/environment/NoiseTextureAtlasDimensions.js";import{ScreenSpacePass as i}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{Float2PassUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{glsl as d}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{NoParameters as p}from"../views/webgl/NoParameters.js";import{ShaderBuilder as n}from"../views/webgl/ShaderBuilder.js";class c extends p{constructor(){super(...arguments),this.weatherTile=e(0,0)}}function s(e){const p=new n;if(p.include(i,!1),p.fragment.code.add(d`float remap(float x, float low1, float high1, float low2, float high2) {
 return low2 + (x - low1) * (high2 - low2) / (high1 - low1);
-}`),e.mode===o.Full){const e=2,o=8;n.fragment.code.add(p`float saturate(float x) {
+}`),0===e.mode){const e=2,t=8;p.fragment.code.add(d`float saturate(float x) {
 return clamp(x, 0.0, 1.0);
-}`),n.fragment.code.add(p`vec3 modulo(vec3 m, float n) {
+}`),p.fragment.code.add(d`vec3 modulo(vec3 m, float n) {
 return mod(mod(m, n) + n, n);
 }
 vec3 hash(vec3 p3, float frequency) {
@@ -14,9 +14,9 @@ p3 = modulo(p3, frequency);
 p3 = fract(p3 * vec3(0.1031, 0.1030, 0.0973));
 p3 += dot(p3, p3.yxz + 33.33);
 return -1.0 + 2.0 * fract((p3.xxy + p3.yxx) * p3.zyx);
-}`),n.fragment.code.add(p`vec3 fade(vec3 t) {
+}`),p.fragment.code.add(d`vec3 fade(vec3 t) {
 return (t * t * t) * (t * (t * 6.0 - 15.0) + 10.0);
-}`),n.fragment.code.add(p`
+}`),p.fragment.code.add(d`
     float gradientNoise(vec3 p, float frequency) {
       vec3 i = floor(p);
       vec3 f = fract(p);
@@ -70,26 +70,26 @@ return (t * t * t) * (t * (t * 6.0 - 15.0) + 10.0);
 
     vec3 get3Dfrom2D(vec2 uv) {
       vec2 tile = floor(uv);
-      float z = floor(${p.float(t)} * tile.y + tile.x);
+      float z = floor(${d.float(o)} * tile.y + tile.x);
       return vec3(fract(uv), z);
     }
 
     float getTextureForPointPerlinWorley(vec3 p) {
-      float perlinNoise = getPerlinNoise(p, ${p.float(o)});
+      float perlinNoise = getPerlinNoise(p, ${d.float(t)});
 
-      float worley0 = worley(p, ${p.float(e)} * 2.0);
-      float worley1 = worley(p, ${p.float(e)} * 8.0);
-      float worley2 = worley(p, ${p.float(e)} * 14.0);
+      float worley0 = worley(p, ${d.float(e)} * 2.0);
+      float worley1 = worley(p, ${d.float(e)} * 8.0);
+      float worley2 = worley(p, ${d.float(e)} * 14.0);
 
       float worleyFBM = worley0 * 0.625 + worley1 * 0.25 + worley2 * 0.125;
       return remap(perlinNoise, 0.0, 1.0, worleyFBM, 1.0);
     }
 
     float getTextureForPointWorley(vec3 p) {
-      float worley0 = worley(p, ${p.float(e)});
-      float worley1 = worley(p, ${p.float(e)} * 2.0);
-      float worley2 = worley(p, ${p.float(e)} * 4.0);
-      float worley3 = worley(p, ${p.float(e)} * 8.0);
+      float worley0 = worley(p, ${d.float(e)});
+      float worley1 = worley(p, ${d.float(e)} * 2.0);
+      float worley2 = worley(p, ${d.float(e)} * 4.0);
+      float worley3 = worley(p, ${d.float(e)} * 8.0);
 
       float FBM0 = worley0 * 0.625 + worley1 * 0.25 + worley2 * 0.125;
       float FBM1 = worley1 * 0.625 + worley2 * 0.25 + worley3 * 0.125;
@@ -97,20 +97,20 @@ return (t * t * t) * (t * (t * 6.0 - 15.0) + 10.0);
 
       return FBM0 * 0.625 + FBM1 * 0.25 + FBM2 * 0.125;
     }
-  `)}return n.fragment.uniforms.add(new d("weatherTile",e=>e.weatherTile)).code.add(p`
+  `)}return p.fragment.uniforms.add(new f("weatherTile",e=>e.weatherTile)).code.add(d`
     vec2 modulo(vec2 m, float n){
       return mod(mod(m, n) + n, n);
     }
 
     vec2 hash(vec2 p){
       // Get position of p in weather tile
-      p = modulo(p, ${p.float(a)});
+      p = modulo(p, ${d.float(t)});
 
       // Get global coordinates of p
-      p += weatherTile * ${p.float(a)};
+      p += weatherTile * ${d.float(t)};
 
       // Limit position to avoid numerical instability
-      p = modulo(p, ${p.float(r)});
+      p = modulo(p, ${d.float(a)});
 
       vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
       p3 += dot(p3, p3.yzx + 33.33);
@@ -147,10 +147,10 @@ return (t * t * t) * (t * (t * 6.0 - 15.0) + 10.0);
         }
       return 1.0 - clamp(d, 0.0, 1.0);
     }
-  `),e.mode===o.Full?n.fragment.main.add(p`
+  `),0===e.mode?p.fragment.main.add(d`
       float padWidth = 1.0;
-      float paddedSize = ${p.float(l)} + 2.0 * padWidth;
-      float tileCount = ${p.float(t)} * ${p.float(t)};
+      float paddedSize = ${d.float(r)} + 2.0 * padWidth;
+      float tileCount = ${d.float(o)} * ${d.float(o)};
       vec2 tile = floor((gl_FragCoord.xy - 0.5) / paddedSize);
 
       bool padCell = false;
@@ -190,52 +190,52 @@ return (t * t * t) * (t * (t * 6.0 - 15.0) + 10.0);
         vec2 pixel = gl_FragCoord.xy - padWidth - padding;
 
         if (startPadX) {
-          pixel.x += ${p.float(l)};
+          pixel.x += ${d.float(r)};
         }
 
         if (startPadY) {
-          pixel.y += ${p.float(l)};
+          pixel.y += ${d.float(r)};
         }
 
         if (endPadX) {
-          pixel.x -= ${p.float(l)};
+          pixel.x -= ${d.float(r)};
         }
 
         if (endPadY) {
-          pixel.y -= ${p.float(l)};
+          pixel.y -= ${d.float(r)};
         }
 
-        uv = vec2(pixel.xy / ${p.float(l)});
+        uv = vec2(pixel.xy / ${d.float(r)});
       } else {
         vec2 pixel = gl_FragCoord.xy - padWidth - padding;
-        uv = vec2(pixel.xy / ${p.float(l)});
+        uv = vec2(pixel.xy / ${d.float(r)});
       }
 
       vec3 p_ = get3Dfrom2D(uv);
       vec3 p = p_;
-      p.z /= (${p.float(t)} * ${p.float(t)});
+      p.z /= (${d.float(o)} * ${d.float(o)});
 
       float worleyPerlinNoise = getTextureForPointPerlinWorley(p);
       float worleyNoise = getTextureForPointWorley(p);
 
       fragColor.r = saturate(remap(worleyPerlinNoise, worleyNoise, 1.0, 0.0, 1.0));
 
-      p_ = mod(p_ + 1.0, ${p.float(t)} * ${p.float(t)});
+      p_ = mod(p_ + 1.0, ${d.float(o)} * ${d.float(o)});
       p = p_;
-      p.z /= (${p.float(t)} * ${p.float(t)});
+      p.z /= (${d.float(o)} * ${d.float(o)});
 
       worleyPerlinNoise = getTextureForPointPerlinWorley(p);
       worleyNoise = getTextureForPointWorley(p);
 
       fragColor.g = saturate(remap(worleyPerlinNoise, worleyNoise, 1.0, 0.0, 1.0));
 
-      vec2 mapUV = ${p.float(a)} * (gl_FragCoord.xy / ${p.float(i)});
+      vec2 mapUV = ${d.float(t)} * (gl_FragCoord.xy / ${d.float(l)});
       float map = abs(gradientNoise(mapUV));
       map = remap(map, 0.25 * (1.0 - worley(8.0 * mapUV)), 1.0, 0.0, 1.0);
       fragColor.ba = vec2(0.0, map);
-      `):n.fragment.main.add(p`
-      vec2 mapUV = ${p.float(a)} * (gl_FragCoord.xy / ${p.float(i)});
+      `):p.fragment.main.add(d`
+      vec2 mapUV = ${d.float(t)} * (gl_FragCoord.xy / ${d.float(l)});
       float map = abs(gradientNoise(mapUV));
       map = remap(map, 0.25 * (1.0 - worley(8.0 * mapUV)), 1.0, 0.0, 1.0);
       fragColor = vec4(map);
-    `),n}const m=Object.freeze(Object.defineProperty({__proto__:null,NoiseTextureAtlasPassParameters:s,build:u},Symbol.toStringTag,{value:"Module"}));export{s as N,m as a,u as b};
+    `),p}const y=Object.freeze(Object.defineProperty({__proto__:null,NoiseTextureAtlasPassParameters:c,build:s},Symbol.toStringTag,{value:"Module"}));export{c as N,y as a,s as b};

package/chunks/OverlayCompositing.glsl.js

@@ -2,5 +2,5 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{OverlayIndex as e}from"../views/3d/terrain/interfaces.js";import{ScreenSpacePass as r}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{FloatPassUniform as o}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as s}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{IntegerPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/IntegerPassUniform.js";import{Texture2DPassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as i}from"../views/webgl/NoParameters.js";import{ShaderBuilder as n}from"../views/webgl/ShaderBuilder.js";class d extends i{constructor(){super(...arguments),this.overlayIndex=e.INNER,this.opacity=1}}function l(){const e=new n;return e.include(r),e.fragment.uniforms.add(new t("tex",e=>e.texture)),e.fragment.uniforms.add(new a("overlayIdx",e=>e.overlayIndex)),e.fragment.uniforms.add(new o("opacity",e=>e.opacity)),e.fragment.main.add(s`vec2 overlayUV = overlayIdx == 0 ? vec2(uv.x * 0.5, uv.y) : vec2(uv.x * 0.5 + 0.5, uv.y);
-fragColor = texture(tex, overlayUV) * opacity;`),e}const m=Object.freeze(Object.defineProperty({__proto__:null,OverlayCompositingPassParameters:d,build:l},Symbol.toStringTag,{value:"Module"}));export{d as O,m as a,l as b};
+import{ScreenSpacePass as e}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSpacePass.glsl.js";import{FloatPassUniform as r}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as o}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{IntegerPassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/IntegerPassUniform.js";import{Texture2DPassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{NoParameters as t}from"../views/webgl/NoParameters.js";import{ShaderBuilder as i}from"../views/webgl/ShaderBuilder.js";class n extends t{constructor(){super(...arguments),this.overlayIndex=0,this.opacity=1}}function d(){const t=new i;return t.include(e),t.fragment.uniforms.add(new a("tex",e=>e.texture)),t.fragment.uniforms.add(new s("overlayIdx",e=>e.overlayIndex)),t.fragment.uniforms.add(new r("opacity",e=>e.opacity)),t.fragment.main.add(o`vec2 overlayUV = overlayIdx == 0 ? vec2(uv.x * 0.5, uv.y) : vec2(uv.x * 0.5 + 0.5, uv.y);
+fragColor = texture(tex, overlayUV) * opacity;`),t}const l=Object.freeze(Object.defineProperty({__proto__:null,OverlayCompositingPassParameters:n,build:d},Symbol.toStringTag,{value:"Module"}));export{n as O,l as a,d as b};

package/chunks/Path.glsl.js

@@ -2,7 +2,7 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{ForwardLinearDepth as e,addNearFar as i}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";import{isColorOrColorEmission as o,ShaderOutput as a}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SliceDraw as r}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as n}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{PathVertexPosition as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/PathVertexPosition.glsl.js";import{OutputDepth as d}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 c}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as m,addAmbientBoostFactor as g,addLightingGlobalFactor as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as b,PBRMode as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDraw as f}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as j}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as L,addViewNormal as P,addCameraPosition as S}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as O}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as C}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as A,If as D}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as I}from"../views/3d/webgl-engine/effects/weather/SnowCover.glsl.js";import{outputColorHighlightOID as B}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOID.glsl.js";import{ShaderBuilder as F}from"../views/webgl/ShaderBuilder.js";function x(x){const V=new F,{vertex:_,fragment:M,varyings:$}=V;L(_,x),$.add("vpos","vec3",{invariant:!0}),V.include(s,x);const{output:z,spherical:H,pbrMode:N,receiveShadows:E,hasBloom:G,snowCover:T}=x,k=o(z);switch((k||z===a.ObjectAndLayerIdColor)&&(V.include(n,x),V.include(f,x),V.include(e,x),V.include(l,x),V.include(y,x),$.add("vnormal","vec3"),$.add("vcolor","vec4"),_.main.add(A`
+import{ForwardLinearDepth as e,addNearFar as i}from"../views/3d/webgl-engine/core/shaderLibrary/ForwardLinearDepth.glsl.js";import{isColorOrColorEmission as o}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 r}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{PathVertexPosition as s}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 d}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 c,addAmbientBoostFactor as m,addLightingGlobalFactor as g}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightIntensity as v}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{Normals as p}from"../views/3d/webgl-engine/core/shaderLibrary/shading/Normals.glsl.js";import{NormalUtils as w}from"../views/3d/webgl-engine/core/shaderLibrary/shading/NormalUtils.glsl.js";import{PhysicallyBasedRenderingParameters as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapDraw as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as f}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as y,addViewNormal as j,addCameraPosition as L}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as P}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as S}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as O,If as C}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{SnowCover as A}from"../views/3d/webgl-engine/effects/weather/SnowCover.glsl.js";import{outputColorHighlightOID as D}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOID.glsl.js";import{ShaderBuilder as B}from"../views/webgl/ShaderBuilder.js";function F(F){const I=new B,{vertex:_,fragment:x,varyings:M}=I;y(_,F),M.add("vpos","vec3",{invariant:!0}),I.include(s,F);const{output:V,spherical:$,pbrMode:z,receiveShadows:G,hasBloom:N,snowCover:T}=F,k=o(V);switch((k||9===V)&&(I.include(r,F),I.include(h,F),I.include(e,F),I.include(n,F),I.include(u,F),M.add("vnormal","vec3"),M.add("vcolor","vec4"),_.main.add(O`
       vpos = calculateVPos();
       vnormal = normalize(localNormal());
       forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
@@ -12,7 +12,7 @@ import{ForwardLinearDepth as e,addNearFar as i}from"../views/3d/webgl-engine/cor
       ${k?"forwardLinearDepth();":""}
       forwardObjectAndLayerIdColor();
 
-      vcolor = getColor();`)),z){case a.ColorEmission:case a.Color:V.include(b,x),V.include(m,x),M.include(c,x),V.include(f,x),V.include(p,x),M.include(r,x),V.include(B,x),S(M,x),g(M),v(M),M.uniforms.add(_.uniforms.get("localOrigin"),new O("ambient",e=>e.ambient),new O("diffuse",e=>e.diffuse),new C("opacity",e=>e.opacity)),M.include(j),M.include(I,x),h(M),M.main.add(A`
+      vcolor = getColor();`)),V){case 1:case 0:I.include(b,F),I.include(c,F),x.include(t,F),I.include(h,F),I.include(p,F),x.include(a,F),I.include(D,F),L(x,F),m(x),g(x),x.uniforms.add(_.uniforms.get("localOrigin"),new P("ambient",e=>e.ambient),new P("diffuse",e=>e.diffuse),new S("opacity",e=>e.opacity)),x.include(f),x.include(A,F),v(x),x.main.add(O`
         discardBySlice(vpos);
         discardByTerrainDepth();
 
@@ -22,32 +22,32 @@ import{ForwardLinearDepth as e,addNearFar as i}from"../views/3d/webgl-engine/cor
         float ssao = evaluateAmbientOcclusionInverse();
 
         vec3 posWorld = vpos + localOrigin;
-        vec3 normalGround = ${H?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
+        vec3 normalGround = ${$?"normalize(posWorld);":"vec3(0.0, 0.0, 1.0);"}
 
         vec3 albedo = vcolor.rgb * max(ambient, diffuse); // combine the old material parameters into a single one
         float combinedOpacity = vcolor.a * opacity;
 
-        ${D(T,A`float snow = getSnow(normal, normalGround);
+        ${C(T,O`float snow = getSnow(normal, normalGround);
                  albedo = mix(albedo, vec3(1), snow);
                  ssao = mix(ssao, 1.0, snow);`)}
 
         float additionalAmbientScale = additionalDirectedAmbientLight(posWorld);
         vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
-        float shadow = ${E?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth));":H?"lightingGlobalFactor * (1.0 - additionalAmbientScale);":"0.0;"}
+        float shadow = ${G?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth));":$?"lightingGlobalFactor * (1.0 - additionalAmbientScale);":"0.0;"}
 
-        ${D(N===u.Schematic,`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];\n           vec4 emission = ${G?"vec4(0.0)":"getEmissions(albedo)"};\n           ${D(T,"mrr = applySnowToMRR(mrr, snow);\n              emission = snowCoverForEmissions(emission, snow);")}`)}
+        ${C(2===z,`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];\n           vec4 emission = ${N?"vec4(0.0)":"getEmissions(albedo)"};\n           ${C(T,"mrr = applySnowToMRR(mrr, snow);\n              emission = snowCoverForEmissions(emission, snow);")}`)}
 
-        vec3 shadedColor = ${N===u.Schematic?"evaluateSceneLightingPBR(normal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, emission, additionalAmbientIrradiance);":"evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);"}
+        vec3 shadedColor = ${2===z?"evaluateSceneLightingPBR(normal, albedo, shadow, 1.0 - ssao, additionalLight, shadingParams.viewDirection, normalGround, mrr, emission, additionalAmbientIrradiance);":"evaluateSceneLighting(normal, albedo, shadow, 1.0 - ssao, additionalLight);"}
         vec4 finalColor = vec4(shadedColor, combinedOpacity);
-        outputColorHighlightOID(finalColor, vpos, albedo ${D(T,", snow")});`);break;case a.Depth:V.include(n,x),_.main.add(A`vpos = calculateVPos();
-gl_Position = transformPosition(proj, view, vpos);`),V.fragment.include(r,x),M.main.add(A`discardBySlice(vpos);`);break;case a.Shadow:case a.ShadowHighlight:case a.ShadowExcludeHighlight:case a.ViewshedShadow:V.include(n,x),i(V),$.add("depth","float"),_.main.add(A`vpos = calculateVPos();
-gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),V.fragment.include(r,x),V.include(d,x),M.main.add(A`discardBySlice(vpos);
-outputDepth(depth);`);break;case a.ObjectAndLayerIdColor:V.fragment.include(r,x),M.main.add(A`discardBySlice(vpos);
-outputObjectAndLayerIdColor();`);break;case a.Normal:V.include(n,x),V.include(w,x),P(_),$.add("vnormal","vec3"),_.main.add(A`vpos = calculateVPos();
+        outputColorHighlightOID(finalColor, vpos, albedo ${C(T,", snow")});`);break;case 2:I.include(r,F),_.main.add(O`vpos = calculateVPos();
+gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(a,F),x.main.add(O`discardBySlice(vpos);`);break;case 4:case 5:case 6:case 7:I.include(r,F),i(I),M.add("depth","float"),_.main.add(O`vpos = calculateVPos();
+gl_Position = transformPositionWithDepth(proj, view, vpos, nearFar, depth);`),I.fragment.include(a,F),I.include(l,F),x.main.add(O`discardBySlice(vpos);
+outputDepth(depth);`);break;case 9:I.fragment.include(a,F),x.main.add(O`discardBySlice(vpos);
+outputObjectAndLayerIdColor();`);break;case 3:I.include(r,F),I.include(w,F),j(_),M.add("vnormal","vec3"),_.main.add(O`vpos = calculateVPos();
 vnormal = normalize((viewNormal * vec4(localNormal(), 1.0)).xyz);
-gl_Position = transformPosition(proj, view, vpos);`),V.fragment.include(r,x),M.main.add(A`discardBySlice(vpos);
+gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(a,F),x.main.add(O`discardBySlice(vpos);
 vec3 normal = normalize(vnormal);
 if (gl_FrontFacing == false) normal = -normal;
-fragColor = vec4(vec3(0.5) + 0.5 * normal, 1.0);`);break;case a.Highlight:V.include(n,x),V.include(w,x),$.add("vnormal","vec3"),_.main.add(A`vpos = calculateVPos();
-gl_Position = transformPosition(proj, view, vpos);`),V.fragment.include(r,x),V.include(t,x),M.main.add(A`discardBySlice(vpos);
-calculateOcclusionAndOutputHighlight();`)}return V}const V=Object.freeze(Object.defineProperty({__proto__:null,build:x},Symbol.toStringTag,{value:"Module"}));export{V as P,x as b};
+fragColor = vec4(vec3(0.5) + 0.5 * normal, 1.0);`);break;case 8:I.include(r,F),I.include(w,F),M.add("vnormal","vec3"),_.main.add(O`vpos = calculateVPos();
+gl_Position = transformPosition(proj, view, vpos);`),I.fragment.include(a,F),I.include(d,F),x.main.add(O`discardBySlice(vpos);
+calculateOcclusionAndOutputHighlight();`)}return I}const I=Object.freeze(Object.defineProperty({__proto__:null,build:F},Symbol.toStringTag,{value:"Module"}));export{I as P,F as b};

package/chunks/Pattern.glsl.js

@@ -2,17 +2,17 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{ShaderOutput as e}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 r}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{VertexColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{terrainDepthTest as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{VisualVariables as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{ColorConversion as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as c,addCameraPosition as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as s}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as g,If as p}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{VertexAttribute as m}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{Style as f}from"../views/3d/webgl-engine/materials/PatternStyle.js";import{outputColorHighlightOID as u}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOID.glsl.js";import{ShaderBuilder as w}from"../views/webgl/ShaderBuilder.js";const b=.70710678118,h=b,y=.08715574274,S=10,j=1;function x(x){const T=new w,{vertex:P,fragment:R,attributes:V,varyings:D}=T,O=x.output===e.Highlight;c(P,x),T.include(r,x),T.include(a,x),T.include(l,x),T.include(t,x),T.fragment.include(o,x),T.include(u,x),T.include(i,x),x.draped?P.uniforms.add(new v("worldToScreenRatio",e=>1/e.screenToPCSRatio)):V.add(m.BOUNDINGRECT,"mat3"),V.add(m.POSITION,"vec3"),V.add(m.UVMAPSPACE,"vec4"),x.vvColor&&V.add(m.COLORFEATUREATTRIBUTE,"float"),x.hasVertexColors||D.add("vColor","vec4"),D.add("vpos","vec3",{invariant:!0}),D.add("vuv","vec2"),P.uniforms.add(new s("uColor",e=>e.color));const A=x.style===f.ForwardDiagonal||x.style===f.BackwardDiagonal||x.style===f.DiagonalCross;return A&&P.code.add(g`
-      const mat2 rotate45 = mat2(${g.float(b)}, ${g.float(-h)},
-                                 ${g.float(h)}, ${g.float(b)});
-    `),x.draped||(d(P,x),P.uniforms.add(new v("worldToScreenPerDistanceRatio",e=>1/e.camera.perScreenPixelRatio)),P.code.add(g`vec3 projectPointToLineSegment(vec3 center, vec3 halfVector, vec3 point) {
+import{SliceDraw as e}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{Transform as o}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{ObjectAndLayerIdColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{VertexColor as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{terrainDepthTest as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{VisualVariables as i}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{ColorConversion as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as l,addCameraPosition as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as s}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as v,If as p}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOID as m}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOID.glsl.js";import{ShaderBuilder as g}from"../views/webgl/ShaderBuilder.js";const u=.70710678118,f=u,w=.08715574274,b=10,h=1;function y(y){const x=new g,{vertex:j,fragment:C,attributes:R,varyings:P}=x,T=8===y.output;l(j,y),x.include(o,y),x.include(t,y),x.include(i,y),x.include(r,y),x.fragment.include(e,y),x.include(m,y),x.include(a,y),y.draped?j.uniforms.add(new s("worldToScreenRatio",e=>1/e.screenToPCSRatio)):R.add("boundingRect","mat3"),R.add("position","vec3"),R.add("uvMapSpace","vec4"),y.vvColor&&R.add("colorFeatureAttribute","float"),y.hasVertexColors||P.add("vColor","vec4"),P.add("vpos","vec3",{invariant:!0}),P.add("vuv","vec2"),j.uniforms.add(new d("uColor",e=>e.color));const V=3===y.style||4===y.style||5===y.style;return V&&j.code.add(v`
+      const mat2 rotate45 = mat2(${v.float(u)}, ${v.float(-f)},
+                                 ${v.float(f)}, ${v.float(u)});
+    `),y.draped||(c(j,y),j.uniforms.add(new s("worldToScreenPerDistanceRatio",e=>1/e.camera.perScreenPixelRatio)),j.code.add(v`vec3 projectPointToLineSegment(vec3 center, vec3 halfVector, vec3 point) {
 float projectedLength = dot(halfVector, point - center) / dot(halfVector, halfVector);
 return center + halfVector * clamp(projectedLength, -1.0, 1.0);
-}`),P.code.add(g`vec3 intersectRayPlane(vec3 rayDir, vec3 rayOrigin, vec3 planeNormal, vec3 planePoint) {
+}`),j.code.add(v`vec3 intersectRayPlane(vec3 rayDir, vec3 rayOrigin, vec3 planeNormal, vec3 planePoint) {
 float d = dot(planeNormal, planePoint);
 float t = (d - dot(planeNormal, rayOrigin)) / dot(planeNormal, rayDir);
 return rayOrigin + t * rayDir;
-}`),P.code.add(g`
+}`),j.code.add(v`
       float boundingRectDistanceToCamera() {
         vec3 center = vec3(boundingRect[0][0], boundingRect[0][1], boundingRect[0][2]);
         vec3 halfU = vec3(boundingRect[1][0], boundingRect[1][1], boundingRect[1][2]);
@@ -22,7 +22,7 @@ return rayOrigin + t * rayDir;
         vec3 viewDir = - vec3(view[0][2], view[1][2], view[2][2]);
 
         float viewAngle = dot(viewDir, n);
-        float minViewAngle = ${g.float(y)};
+        float minViewAngle = ${v.float(w)};
 
         if (abs(viewAngle) < minViewAngle) {
           // view direction is (almost) parallel to plane -> clamp it to min angle
@@ -42,12 +42,12 @@ return rayOrigin + t * rayDir;
 
         return length(closestPoint - cameraPosition);
       }
-    `)),P.code.add(g`
+    `)),j.code.add(v`
     vec2 scaledUV() {
-      vec2 uv = uvMapSpace.xy ${p(A," * rotate45")};
-      vec2 uvCellOrigin = uvMapSpace.zw ${p(A," * rotate45")};
+      vec2 uv = uvMapSpace.xy ${p(V," * rotate45")};
+      vec2 uvCellOrigin = uvMapSpace.zw ${p(V," * rotate45")};
 
-      ${p(!x.draped,g`float distanceToCamera = boundingRectDistanceToCamera();
+      ${p(!y.draped,v`float distanceToCamera = boundingRectDistanceToCamera();
                float worldToScreenRatio = worldToScreenPerDistanceRatio / distanceToCamera;`)}
 
       // Logarithmically discretize ratio to avoid jittering
@@ -56,21 +56,21 @@ return rayOrigin + t * rayDir;
       discreteWorldToScreenRatio = ceil(discreteWorldToScreenRatio / step) * step;
       discreteWorldToScreenRatio = exp(discreteWorldToScreenRatio);
 
-      vec2 uvOffset = mod(uvCellOrigin * discreteWorldToScreenRatio, ${g.float(S)});
+      vec2 uvOffset = mod(uvCellOrigin * discreteWorldToScreenRatio, ${v.float(b)});
       return uvOffset + (uv * discreteWorldToScreenRatio);
     }
-  `),P.main.add(g`
+  `),j.main.add(v`
     vuv = scaledUV();
     vpos = position;
     forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
     forwardNormalizedVertexColor();
     forwardObjectAndLayerIdColor();
-    ${x.hasVertexColors?"vColor *= uColor;":x.vvColor?"vColor = uColor * interpolateVVColor(colorFeatureAttribute);":"vColor = uColor;"}
+    ${y.hasVertexColors?"vColor *= uColor;":y.vvColor?"vColor = uColor * interpolateVVColor(colorFeatureAttribute);":"vColor = uColor;"}
     gl_Position = transformPosition(proj, view, vpos);
-  `),R.include(n),x.draped&&R.uniforms.add(new v("texelSize",e=>1/e.camera.pixelRatio)),O||(R.code.add(g`
-      const float lineWidth = ${g.float(j)};
-      const float spacing = ${g.float(S)};
-      const float spacingINV = ${g.float(1/S)};
+  `),C.include(n),y.draped&&C.uniforms.add(new s("texelSize",e=>1/e.camera.pixelRatio)),T||(C.code.add(v`
+      const float lineWidth = ${v.float(h)};
+      const float spacing = ${v.float(b)};
+      const float spacingINV = ${v.float(1/b)};
 
       float coverage(float p, float txlSize) {
         p = mod(p, spacing);
@@ -86,7 +86,7 @@ return rayOrigin + t * rayDir;
 
         return coverage / txlSize;
       }
-    `),x.draped||R.code.add(g`const int maxSamples = 5;
+    `),y.draped||C.code.add(v`const int maxSamples = 5;
 float sampleAA(float p) {
 vec2 dxdy = abs(vec2(dFdx(p), dFdy(p)));
 float fwidth = dxdy.x + dxdy.y;
@@ -107,10 +107,10 @@ accumulator += coverage(p + step.x * dxdy.x + step.y * dxdy.y, fwidth);
 }
 accumulator /= float(samples.x * samples.y);
 return accumulator;
-}`)),R.main.add(g`
+}`)),C.main.add(v`
     discardBySlice(vpos);
     discardByTerrainDepth();
     vec4 color = vColor;
-    ${p(!O,g`color.a *= ${C(x)};`)}
+    ${p(!T,v`color.a *= ${S(y)};`)}
     outputColorHighlightOID(color, vpos, color.rgb);
-  `),T}function C(e){function o(o){return e.draped?g`coverage(vuv.${o}, texelSize)`:g`sampleAA(vuv.${o})`}switch(e.style){case f.ForwardDiagonal:case f.Horizontal:return o("y");case f.BackwardDiagonal:case f.Vertical:return o("x");case f.DiagonalCross:case f.Cross:return g`1.0 - (1.0 - ${o("x")}) * (1.0 - ${o("y")})`;default:return"0.0"}}const T=Object.freeze(Object.defineProperty({__proto__:null,build:x},Symbol.toStringTag,{value:"Module"}));export{T as P,x as b};
+  `),x}function S(e){function o(o){return e.draped?v`coverage(vuv.${o}, texelSize)`:v`sampleAA(vuv.${o})`}switch(e.style){case 3:case 0:return o("y");case 4:case 1:return o("x");case 5:case 2:return v`1.0 - (1.0 - ${o("x")}) * (1.0 - ${o("y")})`;default:return"0.0"}}const x=Object.freeze(Object.defineProperty({__proto__:null,build:y},Symbol.toStringTag,{value:"Module"}));export{x as P,y as b};

package/chunks/PointRenderer.glsl.js

@@ -2,7 +2,7 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fromTranslation as o}from"../core/libs/gl-matrix-2/math/mat4.js";import{create as r}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as t}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{i as s}from"./vec32.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{create as c,positiveInfinity as l}from"../geometry/support/aaBoundingBox.js";import{isColorOrColorEmission as p}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePlaneParameters as m,RejectBySlice as d}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{RgbaFloatEncoding as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbaFloatEncoding.glsl.js";import{Float2DrawUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{Float2PassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3DrawUniform as S}from"../views/3d/webgl-engine/core/shaderModules/Float3DrawUniform.js";import{glsl as w}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Matrix4DrawUniform.js";import{VertexAttribute as z}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{NoParameters as b}from"../views/webgl/NoParameters.js";import{ShaderBuilder as M}from"../views/webgl/ShaderBuilder.js";class j extends b{constructor(){super(...arguments),this.clipBox=c(l),this.useFixedSizes=!1,this.useRealWorldSymbolSizes=!1,this.scaleFactor=1,this.minSizePx=0,this.size=0,this.sizePx=0}get fixedSize(){return this.drawScreenSpace?this.sizePx:this.size}get screenMinSize(){return this.useFixedSizes?0:this.minSizePx}get drawScreenSpace(){return this.useFixedSizes&&!this.useRealWorldSymbolSizes}}class P extends m{constructor(e,i,o){super(e),this.origin=e,this.isLeaf=i,this.splatSize=o}}function y(r){const a=new M,n=p(r.output),{vertex:c,fragment:l}=a;return a.vertex.include(d,r),a.attributes.add(z.POSITION,"vec3"),a.attributes.add(z.COLOR,"vec3"),c.uniforms.add(new h("modelView",(e,r)=>i(R,r.camera.viewMatrix,o(R,e.origin))),new v("proj",e=>e.camera.projectionMatrix),new u("screenMinMaxSize",(e,i,o)=>t(F,o.useFixedSizes?0:o.minSizePx*i.camera.pixelRatio,O(e.isLeaf)*i.camera.pixelRatio)),r.useFixedSizes?new x("pointScale",(e,i)=>t(F,e.fixedSize*i.camera.pixelRatio,i.camera.fullHeight)):new u("pointScale",(e,i,o)=>t(F,e.splatSize*o.scaleFactor*i.camera.pixelRatio,i.camera.fullHeight/i.camera.pixelRatio))),r.clippingEnabled?c.uniforms.add(new S("clipMin",(e,i,o)=>s(B,o.clipBox[0]-e.origin[0],o.clipBox[1]-e.origin[1],o.clipBox[2]-e.origin[2])),new S("clipMax",(e,i,o)=>s(B,o.clipBox[3]-e.origin[0],o.clipBox[4]-e.origin[1],o.clipBox[5]-e.origin[2]))):(c.constants.add("clipMin","vec3",[-e,-e,-e]),c.constants.add("clipMax","vec3",[e,e,e])),n&&a.varyings.add("vColor","vec3"),c.main.add(w`
+import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fromTranslation as o}from"../core/libs/gl-matrix-2/math/mat4.js";import{create as r}from"../core/libs/gl-matrix-2/factories/mat4f64.js";import{set as t}from"../core/libs/gl-matrix-2/math/vec2.js";import{create as a}from"../core/libs/gl-matrix-2/factories/vec2f64.js";import{i as s}from"./vec32.js";import{create as n}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{create as c,positiveInfinity as l}from"../geometry/support/aaBoundingBox.js";import{isColorOrColorEmission as p}from"../views/3d/webgl-engine/core/shaderLibrary/ShaderOutput.js";import{SlicePlaneParameters as m,RejectBySlice as d}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{OutputHighlight as f}from"../views/3d/webgl-engine/core/shaderLibrary/output/OutputHighlight.glsl.js";import{RgbaFloatEncoding as g}from"../views/3d/webgl-engine/core/shaderLibrary/util/RgbaFloatEncoding.glsl.js";import{Float2DrawUniform as u}from"../views/3d/webgl-engine/core/shaderModules/Float2DrawUniform.js";import{Float2PassUniform as x}from"../views/3d/webgl-engine/core/shaderModules/Float2PassUniform.js";import{Float3DrawUniform as S}from"../views/3d/webgl-engine/core/shaderModules/Float3DrawUniform.js";import{glsl as v}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{Matrix4DrawUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Matrix4DrawUniform.js";import{NoParameters as z}from"../views/webgl/NoParameters.js";import{ShaderBuilder as b}from"../views/webgl/ShaderBuilder.js";class M extends z{constructor(){super(...arguments),this.clipBox=c(l),this.useFixedSizes=!1,this.useRealWorldSymbolSizes=!1,this.scaleFactor=1,this.minSizePx=0,this.size=0,this.sizePx=0}get fixedSize(){return this.drawScreenSpace?this.sizePx:this.size}get screenMinSize(){return this.useFixedSizes?0:this.minSizePx}get drawScreenSpace(){return this.useFixedSizes&&!this.useRealWorldSymbolSizes}}class j extends m{constructor(e,i,o){super(e),this.origin=e,this.isLeaf=i,this.splatSize=o}}function P(r){const a=new b,n=p(r.output),{vertex:c,fragment:l}=a;return a.vertex.include(d,r),a.attributes.add("position","vec3"),a.attributes.add("color","vec3"),c.uniforms.add(new h("modelView",(e,r)=>i(O,r.camera.viewMatrix,o(O,e.origin))),new w("proj",e=>e.camera.projectionMatrix),new u("screenMinMaxSize",(e,i,o)=>t(B,o.useFixedSizes?0:o.minSizePx*i.camera.pixelRatio,y(e.isLeaf)*i.camera.pixelRatio)),r.useFixedSizes?new x("pointScale",(e,i)=>t(B,e.fixedSize*i.camera.pixelRatio,i.camera.fullHeight)):new u("pointScale",(e,i,o)=>t(B,e.splatSize*o.scaleFactor*i.camera.pixelRatio,i.camera.fullHeight/i.camera.pixelRatio))),r.clippingEnabled?c.uniforms.add(new S("clipMin",(e,i,o)=>s(R,o.clipBox[0]-e.origin[0],o.clipBox[1]-e.origin[1],o.clipBox[2]-e.origin[2])),new S("clipMax",(e,i,o)=>s(R,o.clipBox[3]-e.origin[0],o.clipBox[4]-e.origin[1],o.clipBox[5]-e.origin[2]))):(c.constants.add("clipMin","vec3",[-e,-e,-e]),c.constants.add("clipMax","vec3",[e,e,e])),n&&a.varyings.add("vColor","vec3"),c.main.add(v`
     // Move clipped points outside of clipspace
     if (position.x < clipMin.x || position.y < clipMin.y || position.z < clipMin.z ||
       position.x > clipMax.x || position.y > clipMax.y || position.z > clipMax.z) {
@@ -22,7 +22,7 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
 
     float pointSize = pointScale.x;
     vec4 position = proj * camera;
-    ${r.drawScreenSize?w`float clampedScreenSize = pointSize;`:w`float pointRadius = 0.5 * pointSize;
+    ${r.drawScreenSize?v`float clampedScreenSize = pointSize;`:v`float pointRadius = 0.5 * pointSize;
            vec4 cameraOffset = camera + vec4(0.0, pointRadius, 0.0, 0.0);
            vec4 positionOffset = proj * cameraOffset;
            float radius = abs(positionOffset.y - position.y);
@@ -38,7 +38,7 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
 
     gl_PointSize = clampedScreenSize;
     gl_Position = position;
-    ${n?w`vColor = color;`:""}`),l.include(g,r),a.include(f,r),l.main.add(w`
+    ${n?v`vColor = color;`:""}`),l.include(g,r),a.include(f,r),l.main.add(v`
     vec2 vOffset = gl_PointCoord - vec2(0.5, 0.5);
     float r2 = dot(vOffset, vOffset);
 
@@ -46,4 +46,4 @@ import{numberMaxFloat32 as e}from"../core/mathUtils.js";import{multiply as i,fro
       discard;
     }
     calculateOcclusionAndOutputHighlight();
-    ${n?w`fragColor = vec4(vColor, 1.0);`:""}`),a}function O(e){return e?256:64}const R=r(),B=n(),F=a(),_=Object.freeze(Object.defineProperty({__proto__:null,PointRendererDrawParameters:P,PointRendererPassParameters:j,build:y,getMaxPointSizeScreenspace:O},Symbol.toStringTag,{value:"Module"}));export{j as P,P as a,_ as b,y as c,O as g};
+    ${n?v`fragColor = vec4(vColor, 1.0);`:""}`),a}function y(e){return e?256:64}const O=r(),R=n(),B=a(),F=Object.freeze(Object.defineProperty({__proto__:null,PointRendererDrawParameters:j,PointRendererPassParameters:M,build:P,getMaxPointSizeScreenspace:y},Symbol.toStringTag,{value:"Module"}));export{M as P,j as a,F as b,P as c,y as g};

package/chunks/Precipitation.glsl.js

@@ -2,7 +2,7 @@
 All material copyright ESRI, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
 */
-import{J as e,i as t,a as o,g as i,n as a,e as r,m as n}from"./vec32.js";import{create as s,fromValues as d}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{PrecipitationType as c}from"../views/3d/environment/PrecipitationTechniqueConfiguration.js";import{Float3BindUniform as m}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as l}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{FloatPassUniform as p}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as v}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{VertexAttribute as u}from"../views/3d/webgl-engine/lib/VertexAttribute.js";import{ShaderBuilder as h}from"../views/webgl/ShaderBuilder.js";function g(e){const t=new h;return t.attributes.add(u.POSITION,"vec3"),t.attributes.add(u.INSTANCEFEATUREATTRIBUTE,"float"),t.vertex.uniforms.add(new m("cameraPosition",e=>e.camera.eye),new l("offset",(e,t)=>w(e,t)),new p("width",e=>e.width),new p("time",e=>e.time),new f("proj",e=>e.camera.projectionMatrix),new f("view",e=>e.camera.viewMatrix)),t.varyings.add("vUv","vec2"),t.vertex.code.add(v`vec3 hash31(float p){
+import{J as e,i as t,a as o,g as a,n as i,e as r,m as n}from"./vec32.js";import{create as s,fromValues as d}from"../core/libs/gl-matrix-2/factories/vec3f64.js";import{Float3BindUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float3BindUniform.js";import{Float3PassUniform as m}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 p}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";function u(e){const t=new f;return t.attributes.add("position","vec3"),t.attributes.add("instanceFeatureAttribute","float"),t.vertex.uniforms.add(new c("cameraPosition",e=>e.camera.eye),new m("offset",(e,t)=>h(e,t)),new l("width",e=>e.width),new l("time",e=>e.time),new v("proj",e=>e.camera.projectionMatrix),new v("view",e=>e.camera.viewMatrix)),t.varyings.add("vUv","vec2"),t.vertex.code.add(p`vec3 hash31(float p){
 vec3 p3 = fract(vec3(p) * vec3(0.1031, 0.1030, 0.0973));
 p3 += dot(p3, p3.yzx + 33.33);
 return fract((p3.xxy + p3.yzz) * p3.zyx);
@@ -15,7 +15,7 @@ return fract(p);
 }
 vec3 rotateVectorByQuaternion(vec3 v, vec4 q){
 return 2.0 * cross(q.xyz, v * q.w + cross(q.xyz, v)) + v;
-}`),t.vertex.main.add(v`
+}`),t.vertex.main.add(p`
       vUv = position.xz;
       vec3 rand = hash31(instanceFeatureAttribute);
 
@@ -40,7 +40,7 @@ return 2.0 * cross(q.xyz, v * q.w + cross(q.xyz, v)) + v;
 
       // Rain particles fall straight down and are randomly oriented
       // Snow particles have random sinusoid trajectories and are rotated to face the camera
-      ${e.type===c.Rain?v`
+      ${0===e.type?p`
             // Random rotation for particle
             vec3 rotationAxis = up;
             vec4 quat = vec4(rotationAxis * sin(angle), cos(angle));
@@ -54,7 +54,7 @@ return 2.0 * cross(q.xyz, v * q.w + cross(q.xyz, v)) + v;
 
             vec4 pos = mat4(mat3(view)) * vec4(transformedPos + (mod(width * animatedPos - offset, width) - 0.5 * width), 1.0);
             gl_Position = proj * pos;
-      `:v`
+      `:p`
             vec3 rotationAxis = direction;
             vec4 quat = vec4(rotationAxis * sin(angle), cos(angle));
 
@@ -64,9 +64,9 @@ return 2.0 * cross(q.xyz, v * q.w + cross(q.xyz, v)) + v;
             vec4 pos = mat4(mat3(view)) * vec4((mod(width * animatedPos - offset, width) - 0.5 * width), 1.0);
             gl_Position = proj * (0.5 * vec4(position.xzy, 0.0) + pos);
       `}
-  `),t.fragment.uniforms.add(new p("opacity",e=>e.opacity),new m("particleColor",t=>y(t,e))),t.fragment.main.add(v`
+  `),t.fragment.uniforms.add(new l("opacity",e=>e.opacity),new c("particleColor",t=>g(t,e))),t.fragment.main.add(p`
     float d = length(vUv - vec2(0.5));
 
-    ${e.type===c.Rain?v`d = 0.35 * smoothstep(0.5, 0.0, d);`:v`d = smoothstep(0.5, 0.1, d);`}
+    ${0===e.type?p`d = 0.35 * smoothstep(0.5, 0.0, d);`:p`d = smoothstep(0.5, 0.1, d);`}
     fragColor = opacity * vec4(particleColor * d, d);
-  `),t}function w(a,r){const n=r.camera.eye,s=.5*a.width,d=1/a.width,c=e(x,t(x,(n[0]+s)*d,(n[1]+s)*d,(n[2]+s)*d));return o(c,n,i(c,c,a.width))}function y(e,t){const o=t.type===c.Rain?j:P,s=i(x,o,A),d=e.camera.eye;a(b,d);const m=Math.max(0,r(b,e.lighting.mainLight.direction));return n(s,s,o,m)}const x=s(),b=s(),P=d(1,1,1),j=d(.85,.85,.85),A=.7,q=Object.freeze(Object.defineProperty({__proto__:null,build:g},Symbol.toStringTag,{value:"Module"}));export{q as P,g as b};
+  `),t}function h(i,r){const n=r.camera.eye,s=.5*i.width,d=1/i.width,c=e(w,t(w,(n[0]+s)*d,(n[1]+s)*d,(n[2]+s)*d));return o(c,n,a(c,c,i.width))}function g(e,t){const o=0===t.type?b:x,s=a(w,o,P),d=e.camera.eye;i(y,d);const c=Math.max(0,r(y,e.lighting.mainLight.direction));return n(s,s,o,c)}const w=s(),y=s(),x=d(1,1,1),b=d(.85,.85,.85),P=.7,j=Object.freeze(Object.defineProperty({__proto__:null,build:u},Symbol.toStringTag,{value:"Module"}));export{j as P,u as b};