@arcgis/core 5.1.0-next.71 → 5.1.0-next.72

package/chunks/Pattern.glsl.js

@@ -1,25 +1,25 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-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 l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as n,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{outputColorHighlightOLID as u}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getTextureBackedBufferModule as m}from"../views/3d/webgl-engine/shaders/PatternTextureBuffer.glsl.js";import{ShaderBuilder as f}from"../views/webgl/ShaderBuilder.js";const g=.70710678118,w=g,h=.08715574274,b=10,x=1;function y(y){const j=m(y),C=null!=j,T=new f;C&&T.include(j.TextureBackedBufferModule,y);const{vertex:V,fragment:P,attributes:$,varyings:R}=T,A=10===y.output;n(V,y),T.include(o);let L="";C?(y.hasVVColor&&(L=j.getTextureAttribute("colorFeatureAttribute")),y.hasVertexColors?(T.varyings.add("vColor","vec4"),T.vertex.code.add(v`void forwardVertexColor() { vColor = ${j.getTextureAttribute("color")}; }`)):T.vertex.code.add(v`void forwardVertexColor() {}`),$.add("textureElementIndex","uint")):(T.include(t,y),y.hasVVColor&&($.add("colorFeatureAttribute","float"),L="colorFeatureAttribute")),T.include(i,y),T.include(r,y),T.fragment.include(e,y),T.include(u,y),T.include(a,y),y.draped&&V.uniforms.add(new s("worldToScreenRatio",e=>1/e.screenToPCSRatio)),$.add("position","vec3"),$.add("uvMapSpace","vec4"),y.hasVertexColors||R.add("vColor","vec4"),R.add("vpos","vec3",{invariant:!0}),R.add("vuv","vec2"),V.uniforms.add(new d("uColor",e=>e.color));const D=3===y.style||4===y.style||5===y.style;return D&&V.code.add(v`
-      const mat2 rotate45 = mat2(${v.float(g)}, ${v.float(-w)},
-                                 ${v.float(w)}, ${v.float(g)});
-    `),!y.draped&&C&&(c(V,y),V.uniforms.add(new s("worldToScreenPerDistanceRatio",e=>1/e.camera.perScreenPixelRatio)),V.code.add(v`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 t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{VertexColor as r}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/VertexColor.glsl.js";import{VisualVariables as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{ColorConversion as i}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as l,addCameraPosition as n}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float4PassUniform as c}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as d}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{glsl as s,If as v}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOLID as u}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{getTextureBackedBufferModule as p}from"../views/3d/webgl-engine/shaders/PatternTextureBuffer.glsl.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";const f=.70710678118,g=f,w=.08715574274,b=10,h=1;function x(x){const S=p(x),j=null!=S,C=new m;j&&C.include(S.TextureBackedBufferModule,x);const{vertex:V,fragment:T,attributes:P,varyings:$}=C,R=10===x.output;l(V,x),C.include(o);let A="";j?(x.hasVVColor&&(A=S.getTextureAttribute("colorFeatureAttribute")),x.hasVertexColors?(C.varyings.add("vColor","vec4"),C.vertex.code.add(s`void forwardVertexColor() { vColor = ${S.getTextureAttribute("color")}; }`)):C.vertex.code.add(s`void forwardVertexColor() {}`),P.add("textureElementIndex","uint")):(C.include(r,x),x.hasVVColor&&(P.add("colorFeatureAttribute","float"),A="colorFeatureAttribute")),P.add("position","vec3"),V.inputs.add("position",()=>"position"),C.include(a,x),C.include(t,x),T.include(e,x),C.include(u,x),x.draped&&V.uniforms.add(new d("worldToScreenRatio",e=>1/e.screenToPCSRatio)),P.add("uvMapSpace","vec4"),x.hasVertexColors||$.add("vColor","vec4"),$.add("vpos","vec3",{invariant:!0}),$.add("vuv","vec2"),V.uniforms.add(new c("uColor",e=>e.color));const L=3===x.style||4===x.style||5===x.style;return L&&V.code.add(s`
+      const mat2 rotate45 = mat2(${s.float(f)}, ${s.float(-g)},
+                                 ${s.float(g)}, ${s.float(f)});
+    `),!x.draped&&j&&(n(V,x),V.uniforms.add(new d("worldToScreenPerDistanceRatio",e=>1/e.camera.perScreenPixelRatio)),V.code.add(s`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);
-}`),V.code.add(v`vec3 intersectRayPlane(vec3 rayDir, vec3 rayOrigin, vec3 planeNormal, vec3 planePoint) {
+}`),V.code.add(s`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;
-}`),V.code.add(v`
+}`),V.code.add(s`
       float boundingRectDistanceToCamera() {
-        vec3 center = ${j.getTextureAttribute("boundingRect")}[0];
-        vec3 halfU = ${j.getTextureAttribute("boundingRect")}[1];
-        vec3 halfV = ${j.getTextureAttribute("boundingRect")}[2];
+        vec3 center = ${S.getTextureAttribute("boundingRect")}[0];
+        vec3 halfU = ${S.getTextureAttribute("boundingRect")}[1];
+        vec3 halfV = ${S.getTextureAttribute("boundingRect")}[2];
         vec3 n = normalize(cross(halfU, halfV));
 
         vec3 viewDir = - vec3(view[0][2], view[1][2], view[2][2]);
 
         float viewAngle = dot(viewDir, n);
-        float minViewAngle = ${v.float(h)};
+        float minViewAngle = ${s.float(w)};
 
         if (abs(viewAngle) < minViewAngle) {
           // view direction is (almost) parallel to plane -> clamp it to min angle
@@ -39,12 +39,12 @@ return rayOrigin + t * rayDir;
 
         return length(closestPoint - cameraPosition);
       }
-    `)),V.code.add(v`
+    `)),V.code.add(s`
     vec2 scaledUV() {
-      vec2 uv = uvMapSpace.xy ${p(D," * rotate45")};
-      vec2 uvCellOrigin = uvMapSpace.zw ${p(D," * rotate45")};
+      vec2 uv = uvMapSpace.xy ${v(L," * rotate45")};
+      vec2 uvCellOrigin = uvMapSpace.zw ${v(L," * rotate45")};
 
-      ${p(!y.draped,v`float distanceToCamera = boundingRectDistanceToCamera();
+      ${v(!x.draped,s`float distanceToCamera = boundingRectDistanceToCamera();
                float worldToScreenRatio = worldToScreenPerDistanceRatio / distanceToCamera;`)}
 
       // Logarithmically discretize ratio to avoid jittering
@@ -53,21 +53,20 @@ return rayOrigin + t * rayDir;
       discreteWorldToScreenRatio = ceil(discreteWorldToScreenRatio / step) * step;
       discreteWorldToScreenRatio = exp(discreteWorldToScreenRatio);
 
-      vec2 uvOffset = mod(uvCellOrigin * discreteWorldToScreenRatio, ${v.float(b)});
+      vec2 uvOffset = mod(uvCellOrigin * discreteWorldToScreenRatio, ${s.float(b)});
       return uvOffset + (uv * discreteWorldToScreenRatio);
     }
-  `),V.main.add(v`
+  `),V.main.add(s`
     vuv = scaledUV();
     vpos = position;
-    forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
     forwardVertexColor();
     forwardObjectAndLayerIdColor();
-    ${y.hasVertexColors?"vColor *= uColor;":y.hasVVColor?v`vColor = uColor * interpolateVVColor(${L});`:"vColor = uColor;"}
+    ${x.hasVertexColors?"vColor *= uColor;":x.hasVVColor?s`vColor = uColor * interpolateVVColor(${A});`:"vColor = uColor;"}
     gl_Position = transformPosition(proj, view, vpos);
-  `),P.include(l),y.draped&&P.uniforms.add(new s("texelSize",e=>1/e.camera.pixelRatio)),A||(P.code.add(v`
-      const float lineWidth = ${v.float(x)};
-      const float spacing = ${v.float(b)};
-      const float spacingINV = ${v.float(1/b)};
+  `),T.include(i),x.draped&&T.uniforms.add(new d("texelSize",e=>1/e.camera.pixelRatio)),R||(T.code.add(s`
+      const float lineWidth = ${s.float(h)};
+      const float spacing = ${s.float(b)};
+      const float spacingINV = ${s.float(1/b)};
 
       float coverage(float p, float txlSize) {
         p = mod(p, spacing);
@@ -83,7 +82,7 @@ return rayOrigin + t * rayDir;
 
         return coverage / txlSize;
       }
-    `),y.draped||P.code.add(v`const int maxSamples = 5;
+    `),x.draped||T.code.add(s`const int maxSamples = 5;
 float sampleAA(float p) {
 vec2 dxdy = abs(vec2(dFdx(p), dFdy(p)));
 float fwidth = dxdy.x + dxdy.y;
@@ -104,10 +103,9 @@ accumulator += coverage(p + step.x * dxdy.x + step.y * dxdy.y, fwidth);
 }
 accumulator /= float(samples.x * samples.y);
 return accumulator;
-}`)),P.main.add(v`
+}`)),T.main.add(s`
     discardBySlice(vpos);
-    discardByTerrainDepth();
     vec4 color = vColor;
-    ${p(!A,v`color.a *= ${S(y)};`)}
+    ${v(!R,s`color.a *= ${y(x)};`)}
     outputColorHighlightOLID(applySlice(color, vpos), color.rgb);
-  `),T}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 j=Object.freeze(Object.defineProperty({__proto__:null,build:y},Symbol.toStringTag,{value:"Module"}));export{j as P,y as b};
+  `),C}function y(e){function o(o){return e.draped?s`coverage(vuv.${o}, texelSize)`:s`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 s`1.0 - (1.0 - ${o("x")}) * (1.0 - ${o("y")})`;default:return"0.0"}}const S=Object.freeze(Object.defineProperty({__proto__:null,build:x},Symbol.toStringTag,{value:"Module"}));export{S as P,x as b};

package/chunks/RealisticTree.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as o}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 i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstanceColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstanceColor.glsl.js";import{InstancedDoublePrecision as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{MaskedColorDefinition as t,CreateMaskedFromNaNColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/MaskedColor.glsl.js";import{NormalAttribute as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{SymbolColor as d}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{EvaluateAmbientOcclusion as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as w,addAmbientBoostFactor as p,addLightingGlobalFactor as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightDirection as f,addMainLightIntensity as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{PhysicallyBasedRendering as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as C,ReadShadowMapDrawFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{terrainDepthTest as j}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{VisualVariables as M}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as O}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{MixExternalColor as P}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{addProjViewLocalOrigin as N,addCameraPosition as S}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as A}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as E}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as D}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as F,If as V}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as T}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as I}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{colorMixModes as $}from"../views/3d/webgl-engine/materials/internal/MaterialUtil.js";import{alphaCutoff as k}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as R}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as B}from"../views/webgl/ShaderBuilder.js";function _(_){const z=new B,{attributes:U,vertex:W,fragment:H,varyings:G}=z,{output:q,offsetBackfaces:J,pbrMode:K,snowCover:Q,spherical:X}=_,Y=1===K||2===K;if(N(W,_),U.add("position","vec3"),G.add("vpos","vec3",{invariant:!0}),z.include(M,_),z.include(l,_),z.include(m,_),z.include(j,_),!o(q))return z.include(v,_),z;S(z.vertex,_),z.include(n,_),z.include(i),J&&z.include(e),G.add("vNormalWorld","vec3"),G.add("localvpos","vec3",{invariant:!0}),z.include(c,_),z.include(d,_),z.include(a,_),z.include(g,_),W.include(t),W.include(s),W.uniforms.add(new E("externalColor",e=>e.externalColor,{supportsNaN:!0})),G.add("vcolorExt","vec4"),z.include(_.instancedDoublePrecision?C:L,_),W.include(k),W.main.add(F`
+import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.js";import{isColor as o}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 i}from"../views/3d/webgl-engine/core/shaderLibrary/Transform.glsl.js";import{InstanceColor as a}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstanceColor.glsl.js";import{InstancedDoublePrecision as l}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/InstancedDoublePrecision.glsl.js";import{MaskedColorDefinition as t,CreateMaskedFromNaNColor as s}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/MaskedColor.glsl.js";import{NormalAttribute as n}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";import{SymbolColor as d}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{EvaluateAmbientOcclusion as b}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateAmbientOcclusion.glsl.js";import{EvaluateSceneLighting as p,addAmbientBoostFactor as w,addLightingGlobalFactor as u}from"../views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js";import{addMainLightDirection as f,addMainLightIntensity as h}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MainLighting.glsl.js";import{PhysicallyBasedRendering as y}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js";import{PhysicallyBasedRenderingParameters as x}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRenderingParameters.glsl.js";import{ReadShadowMapPassFragment as C,ReadShadowMapDrawFragment as L}from"../views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js";import{VisualVariables as j}from"../views/3d/webgl-engine/core/shaderLibrary/shading/VisualVariables.glsl.js";import{DiscardOrAdjustAlphaPass as M}from"../views/3d/webgl-engine/core/shaderLibrary/util/DiscardOrAdjustAlpha.glsl.js";import{MixExternalColor as O}from"../views/3d/webgl-engine/core/shaderLibrary/util/MixExternalColor.glsl.js";import{addProjViewLocalOrigin as N,addCameraPosition as P}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as S}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as A}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatPassUniform as E}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as F,If as V}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Texture2DPassUniform as D}from"../views/3d/webgl-engine/core/shaderModules/Texture2DPassUniform.js";import{SnowCover as I}from"../views/3d/webgl-engine/effects/snowcover/SnowCover.glsl.js";import{colorMixModes as $}from"../views/3d/webgl-engine/materials/internal/MaterialUtil.js";import{alphaCutoff as k}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{outputColorHighlightOLID as R}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as T}from"../views/webgl/ShaderBuilder.js";function B(B){const _=new T,{attributes:U,vertex:z,fragment:W,varyings:H}=_,{output:G,offsetBackfaces:q,pbrMode:J,snowCover:K,spherical:Q}=B,X=1===J||2===J;if(N(z,B),U.add("position","vec3"),z.inputs.add("position",()=>"position"),H.add("vpos","vec3",{invariant:!0}),_.include(j,B),_.include(l,B),_.include(m,B),!o(G))return _.include(v,B),_;P(_.vertex,B),_.include(n,B),_.include(i),q&&_.include(e),H.add("vNormalWorld","vec3"),H.add("localvpos","vec3",{invariant:!0}),_.include(c,B),_.include(d,B),_.include(a,B),_.include(g,B),z.include(t),z.include(s),z.uniforms.add(new A("externalColor",e=>e.externalColor,{supportsNaN:!0})),H.add("vcolorExt","vec4"),_.include(B.instancedDoublePrecision?C:L,B),z.include(k),z.main.add(F`
     forwardVertexColor();
 
     MaskedColor maskedColorExt =
@@ -17,16 +17,14 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
     vpos = addVerticalOffset(vpos, localOrigin);
     vec4 basePosition = transformPosition(proj, view, vpos);
 
-    forwardViewPosDepth((view * vec4(vpos, 1.0)).xyz);
     forwardTextureCoordinates();
     forwardLinearDepthToReadShadowMap();
     gl_Position = alphaCut ? vec4(1e38, 1e38, 1e38, 1.0) :
-    ${V(J,"offsetBackfacingClipPosition(basePosition, vpos, vNormalWorld, cameraPosition);","basePosition;")}
-  `);const{hasColorTexture:Z,hasColorTextureTransform:ee}=_;return H.include(w,_),H.include(b,_),z.include(O,_),H.include(r,_),z.include(R,_),S(H,_),f(H),p(H),u(H),H.uniforms.add(W.uniforms.get("localOrigin"),W.uniforms.get("view"),new A("ambient",e=>e.ambient),new A("diffuse",e=>e.diffuse),new D("opacity",e=>e.opacity),new D("layerOpacity",e=>e.layerOpacity)),Z&&H.uniforms.add(new T("tex",e=>e.texture)),z.include(x,_),H.include(y,_),H.include(P),H.include(I,_),h(H),H.main.add(F`
+    ${V(q,"offsetBackfacingClipPosition(basePosition, vpos, vNormalWorld, cameraPosition);","basePosition;")}
+  `);const{hasColorTexture:Y,hasColorTextureTransform:Z}=B;return W.include(p,B),W.include(b,B),_.include(M,B),W.include(r,B),_.include(R,B),P(W,B),f(W),w(W),u(W),W.uniforms.add(z.uniforms.get("localOrigin"),z.uniforms.get("view"),new S("ambient",e=>e.ambient),new S("diffuse",e=>e.diffuse),new E("opacity",e=>e.opacity),new E("layerOpacity",e=>e.layerOpacity)),Y&&W.uniforms.add(new D("tex",e=>e.texture)),_.include(x,B),W.include(y,B),W.include(O),W.include(I,B),h(W),W.main.add(F`
       discardBySlice(vpos);
-      discardByTerrainDepth();
-      vec4 texColor = ${Z?`texture(tex, ${ee?"colorUV":"vuv0"})`:" vec4(1.0)"};
-      ${V(Z,`${V(_.textureAlphaPremultiplied,"texColor.rgb /= texColor.a;")}\n        discardOrAdjustAlpha(texColor);`)}
+      vec4 texColor = ${Y?`texture(tex, ${Z?"colorUV":"vuv0"})`:" vec4(1.0)"};
+      ${V(Y,`${V(B.textureAlphaPremultiplied,"texColor.rgb /= texColor.a;")}\n        discardOrAdjustAlpha(texColor);`)}
       vec3 viewDirection = normalize(vpos - cameraPosition);
       applyPBRFactors();
       float ssao = evaluateAmbientOcclusionInverse();
@@ -36,14 +34,14 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
       vec3 additionalLight = ssao * mainLightIntensity * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor;
       float shadow = readShadow(additionalAmbientScale, vpos);
       vec3 matColor = max(ambient, diffuse);
-      ${_.hasVertexColors?F`vec3 albedo = mixExternalColor(vColor.rgb * matColor, texColor.rgb, vcolorExt.rgb, colorMixMode);
+      ${B.hasVertexColors?F`vec3 albedo = mixExternalColor(vColor.rgb * matColor, texColor.rgb, vcolorExt.rgb, colorMixMode);
              float opacity_ = layerOpacity * mixExternalOpacity(vColor.a * opacity, texColor.a, vcolorExt.a, opacityMixMode);`:F`vec3 albedo = mixExternalColor(matColor, texColor.rgb, vcolorExt.rgb, colorMixMode);
              float opacity_ = layerOpacity * mixExternalOpacity(opacity, texColor.a, vcolorExt.a, opacityMixMode);`}
 
       vec3 shadingNormal = normalize(vNormalWorld);
-      vec3 groundNormal = ${X?"normalize(vpos + localOrigin)":"vec3(0.0, 0.0, 1.0)"};
+      vec3 groundNormal = ${Q?"normalize(vpos + localOrigin)":"vec3(0.0, 0.0, 1.0)"};
 
-      ${V(Q,"vec3 faceNormal = screenDerivativeNormal(vpos);\n         float snow = getRealisticTreeSnow(faceNormal, shadingNormal, groundNormal);\n         albedo = mix(albedo, vec3(1), snow);")}
+      ${V(K,"vec3 faceNormal = screenDerivativeNormal(vpos);\n         float snow = getRealisticTreeSnow(faceNormal, shadingNormal, groundNormal);\n         albedo = mix(albedo, vec3(1), snow);")}
 
       ${F`albedo *= 1.2;
              vec3 viewForward = vec3(view[0][2], view[1][2], view[2][2]);
@@ -53,8 +51,8 @@ import{Offset as e}from"../views/3d/webgl-engine/core/shaderLibrary/Offset.glsl.
              float backLightFactor = 0.5 * treeRadialFalloff * alignmentLightView * transmittance * (1.0 - shadow);
              additionalLight += backLightFactor * mainLightIntensity;`}
 
-      ${Y?F`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
-            ${V(Q,"mrr = applySnowToMRR(mrr, snow);")}
+      ${X?F`float additionalAmbientIrradiance = additionalAmbientIrradianceFactor * mainLightIntensity[2];
+            ${V(K,"mrr = applySnowToMRR(mrr, snow);")}
             vec3 shadedColor = evaluateSceneLightingPBR(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight, viewDirection, groundNormal, mrr, additionalAmbientIrradiance);`:F`vec3 shadedColor = evaluateSceneLighting(shadingNormal, albedo, shadow, 1.0 - ssao, additionalLight);`}
       vec4 finalColor = vec4(shadedColor, opacity_);
-      outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${V(Q,", 1.0")});`),z}const z=Object.freeze(Object.defineProperty({__proto__:null,build:_},Symbol.toStringTag,{value:"Module"}));export{z as R,_ as b};
+      outputColorHighlightOLID(applySlice(finalColor, vpos), albedo ${V(K,", 1.0")});`),_}const _=Object.freeze(Object.defineProperty({__proto__:null,build:B},Symbol.toStringTag,{value:"Module"}));export{_ as R,B as b};

package/chunks/RibbonLine.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{SliceDraw as e}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{ObjectAndLayerIdColor as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{RibbonVertexPosition as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{LineStipple as n,computePixelSize as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js";import{MarkerSizing as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{PiUtils as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{positionOutsideClipSpace as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{terrainDepthTest as l}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as d}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as p,NoPerspectiveRead as c}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as m,addPixelRatio as v}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2BindUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as h}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as x}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as S,If as D}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as w}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{alphaCutoff as L}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{AnimatedLine as b}from"../views/3d/webgl-engine/shaders/AnimatedLine.glsl.js";import{outputColorHighlightOLID as y}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as z}from"../views/webgl/ShaderBuilder.js";const P=1;function j(j){const C=new z,{attributes:W,varyings:R,vertex:F,fragment:A}=C,{applyMarkerOffset:V,draped:T,output:E,capType:N,stippleEnabled:O,falloffEnabled:M,roundJoins:$,wireframe:_,innerColorEnabled:k,hasAnimation:I,hasScreenSizePerspective:B,worldSizedImagePattern:H}=j;A.include(a),C.include(t,j),C.include(n,j),C.include(i,j),C.include(l,j),C.include(b,j);const J=V&&!T;J&&(F.uniforms.add(new u("markerScale",e=>e.markerScale)),C.include(r,{space:2,hasScreenSizePerspective:B})),m(F,j),F.uniforms.add(new w("inverseProjectionMatrix",e=>e.camera.inverseProjectionMatrix),new f("nearFar",e=>e.camera.nearFar),new u("miterLimit",e=>"miter"!==e.join?0:e.miterLimit),new g("viewport",e=>e.camera.fullViewport)),F.constants.add("LARGE_HALF_FLOAT","float",65500),W.add("position","vec3"),W.add("previousDelta","vec4"),W.add("nextDelta","vec4"),W.add("lineParameters","vec2"),W.add("u0","float"),R.add("vColor","vec4"),R.add("vpos","vec3",{invariant:!0}),R.add("vLineDistance","float"),R.add("vLineWidth","float");const U=O;U&&R.add("vLineSizeInv","float");const Z=2===N,G=O&&Z,X=M||G;X&&R.add("vLineDistanceNorm","float"),Z&&(R.add("vSegmentSDF","float"),R.add("vReverseSegmentSDF","float")),F.code.add(S`vec3 perpendicular(vec3 v) {
+import{SliceDraw as e}from"../views/3d/webgl-engine/core/shaderLibrary/Slice.glsl.js";import{ObjectAndLayerIdColor as i}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/ObjectAndLayerIdColor.glsl.js";import{RibbonVertexPosition as t}from"../views/3d/webgl-engine/core/shaderLibrary/attributes/RibbonVertexPosition.glsl.js";import{LineStipple as n,computePixelSize as o}from"../views/3d/webgl-engine/core/shaderLibrary/shading/LineStipple.glsl.js";import{MarkerSizing as r}from"../views/3d/webgl-engine/core/shaderLibrary/shading/MarkerSizing.glsl.js";import{PiUtils as a}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PiUtils.glsl.js";import{positionOutsideClipSpace as s}from"../views/3d/webgl-engine/core/shaderLibrary/shading/PositionOutsideClipSpace.js";import{ColorConversion as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{NoPerspectiveWrite as d,NoPerspectiveRead as p}from"../views/3d/webgl-engine/core/shaderLibrary/util/NoPerspective.glsl.js";import{addProjViewLocalOrigin as c,addPixelRatio as m}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float2BindUniform as v}from"../views/3d/webgl-engine/core/shaderModules/Float2BindUniform.js";import{Float4BindUniform as f}from"../views/3d/webgl-engine/core/shaderModules/Float4BindUniform.js";import{Float4PassUniform as g}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{FloatBindUniform as h}from"../views/3d/webgl-engine/core/shaderModules/FloatBindUniform.js";import{FloatPassUniform as u}from"../views/3d/webgl-engine/core/shaderModules/FloatPassUniform.js";import{glsl as x,If as S}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{Matrix4BindUniform as D}from"../views/3d/webgl-engine/core/shaderModules/Matrix4BindUniform.js";import{alphaCutoff as w}from"../views/3d/webgl-engine/shaders/alphaCutoff.glsl.js";import{AnimatedLine as L}from"../views/3d/webgl-engine/shaders/AnimatedLine.glsl.js";import{outputColorHighlightOLID as b}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as y}from"../views/webgl/ShaderBuilder.js";const z=1;function P(P){const j=new y,{attributes:C,varyings:W,vertex:R,fragment:F}=j,{applyMarkerOffset:A,draped:V,output:T,capType:E,stippleEnabled:N,falloffEnabled:O,roundJoins:M,wireframe:$,innerColorEnabled:_,hasAnimation:k,hasScreenSizePerspective:I,worldSizedImagePattern:B}=P;R.inputs.add("position",()=>"position"),F.include(a),j.include(t,P),j.include(n,P),j.include(i,P),j.include(L,P);const H=A&&!V;H&&(R.uniforms.add(new u("markerScale",e=>e.markerScale)),j.include(r,{space:2,hasScreenSizePerspective:I})),c(R,P),R.uniforms.add(new D("inverseProjectionMatrix",e=>e.camera.inverseProjectionMatrix),new v("nearFar",e=>e.camera.nearFar),new u("miterLimit",e=>"miter"!==e.join?0:e.miterLimit),new f("viewport",e=>e.camera.fullViewport)),R.constants.add("LARGE_HALF_FLOAT","float",65500),C.add("position","vec3"),C.add("previousDelta","vec4"),C.add("nextDelta","vec4"),C.add("lineParameters","vec2"),C.add("u0","float"),W.add("vColor","vec4"),W.add("vpos","vec3",{invariant:!0}),W.add("vLineDistance","float"),W.add("vLineWidth","float");const J=N;J&&W.add("vLineSizeInv","float");const U=2===E,Z=N&&U,G=O||Z;G&&W.add("vLineDistanceNorm","float"),U&&(W.add("vSegmentSDF","float"),W.add("vReverseSegmentSDF","float")),R.code.add(x`vec3 perpendicular(vec3 v) {
 return vec3(v.y, -v.x, 0.0);
 }
 float interp(float ncp, vec4 a, vec4 b) {
@@ -10,12 +10,12 @@ float s = sin(a);
 float c = cos(a);
 mat2 m = mat2(c, -s, s, c);
 return vec3(m * v.xy, v.z);
-}`),F.code.add(S`vec4 projectAndScale(vec4 pos) {
+}`),R.code.add(x`vec4 projectAndScale(vec4 pos) {
 vec4 posNdc = proj * pos;
 posNdc.xy *= viewport.zw / posNdc.w;
 posNdc.z /= posNdc.w;
 return posNdc;
-}`),F.code.add(S`void clip(
+}`),R.code.add(x`void clip(
 inout vec4 pos,
 inout vec4 prev,
 inout vec4 next,
@@ -46,7 +46,7 @@ if (next.z > -nearFar[0]) {
 next = mix(next, pos, interp(vnp, next, pos));
 }
 }
-}`),v(F),F.constants.add("aaWidth","float",O?0:1).main.add(S`
+}`),m(R),R.constants.add("aaWidth","float",N?0:1).main.add(x`
     // unpack values from vertex type
     bool isStartVertex = abs(abs(lineParameters.y) - 3.0) == 1.0;
     vec3 prevPosition = position + previousDelta.xyz * previousDelta.w;
@@ -65,18 +65,16 @@ next = mix(next, pos, interp(vnp, next, pos));
       vec4 next = view * vec4(nextPosition, 1.0);
 
       bool isJoin = abs(lineParameters.y) < 3.0;
-  `),J&&F.main.add(S`vec4 other = isStartVertex ? next : prev;
+  `),H&&R.main.add(x`vec4 other = isStartVertex ? next : prev;
 bool markersHidden = areWorldMarkersHidden(pos.xyz, other.xyz);
 if (!isJoin && !markersHidden) {
 pos.xyz += normalize(other.xyz - pos.xyz) * getWorldMarkerSize(pos.xyz) * 0.5;
-}`),C.include(p),F.main.add(S`
+}`),j.include(d),R.main.add(x`
       clip(pos, prev, next, isStartVertex);
 
       vec3 clippedPos = pos.xyz;
       vec3 clippedCenter = mix(pos.xyz, isStartVertex ? next.xyz : prev.xyz, 0.5);
 
-      forwardViewPosDepth(pos.xyz);
-
       pos = projectAndScale(pos);
       next = projectAndScale(next);
       prev = projectAndScale(prev);
@@ -87,18 +85,18 @@ pos.xyz += normalize(other.xyz - pos.xyz) * getWorldMarkerSize(pos.xyz) * 0.5;
       float leftLen = length(left);
       float rightLen = length(right);
 
-      float lineSize = getSize(${D(B,"clippedPos")});
-      ${D(O&&B,"float patternLineSize = getSize(clippedCenter);")}
-      ${D(O&&!B,"float patternLineSize = lineSize;")}
+      float lineSize = getSize(${S(I,"clippedPos")});
+      ${S(N&&I,"float patternLineSize = getSize(clippedCenter);")}
+      ${S(N&&!I,"float patternLineSize = lineSize;")}
 
-      ${D(H,S`
+      ${S(B,x`
           lineSize += aaWidth;
           float lineWidth = lineSize * pixelRatio * worldToScreenRatio;
           if (lineWidth < 1.0) {
             coverage = lineWidth;
             lineWidth = 1.0;
           }
-        `,S`
+        `,x`
           if (lineSize < 1.0) {
             coverage = lineSize; // convert sub-pixel coverage to alpha
             lineSize = 1.0;
@@ -109,13 +107,13 @@ pos.xyz += normalize(other.xyz - pos.xyz) * getWorldMarkerSize(pos.xyz) * 0.5;
         `)}
 
       vLineWidth = noPerspectiveWrite(lineWidth, pos.w);
-      ${U?S`vLineSizeInv = noPerspectiveWrite(1.0 / lineSize, pos.w);`:""}
-  `);(O||Z)&&F.main.add(S`
+      ${J?x`vLineSizeInv = noPerspectiveWrite(1.0 / lineSize, pos.w);`:""}
+  `);(N||U)&&R.main.add(x`
       float isEndVertex = float(!isStartVertex);
       vec3 segmentOrigin = mix(pos.xyz, prev.xyz, isEndVertex);
       vec3 segment = mix(right, left, isEndVertex);
-      ${Z?S`vec3 segmentEnd = mix(next.xyz, pos.xyz, isEndVertex);`:""}
-    `),F.main.add(S`left = (leftLen > 0.001) ? left/leftLen : vec3(0.0, 0.0, 0.0);
+      ${U?x`vec3 segmentEnd = mix(next.xyz, pos.xyz, isEndVertex);`:""}
+    `),R.main.add(x`left = (leftLen > 0.001) ? left/leftLen : vec3(0.0, 0.0, 0.0);
 right = (rightLen > 0.001) ? right/rightLen : vec3(0.0, 0.0, 0.0);
 vec3 segmentDirection = isStartVertex ? right : left;
 vec3 capDisplacementDir = vec3(0.0, 0.0, 0.0);
@@ -133,18 +131,18 @@ displacementLen = min(displacementLen, min(leftLen, rightLen)/abs(nDotSeg));
 }
 }
 float subdivisionFactor = lineParameters.x;
-if (isOutside && (displacementLen > miterLimit * lineWidth)) {`),$?F.main.add(S`
+if (isOutside && (displacementLen > miterLimit * lineWidth)) {`),M?R.main.add(x`
         vec3 startDir = leftLen < 0.001 ? right : left;
         startDir = perpendicular(startDir);
 
         vec3 endDir = rightLen < 0.001 ? left : right;
         endDir = perpendicular(endDir);
 
-        float factor = ${O?S`min(1.0, subdivisionFactor * ${S.float((P+2)/(P+1))})`:S`subdivisionFactor`};
+        float factor = ${N?x`min(1.0, subdivisionFactor * ${x.float((z+2)/(z+1))})`:x`subdivisionFactor`};
 
         float rotationAngle = acos(clamp(dot(startDir.xy, endDir.xy), -1.0, 1.0));
         joinDisplacementDir = rotateZ(startDir, -sign(lineParameters.y) * factor * rotationAngle);
-      `):F.main.add(S`if (leftLen < 0.001) {
+      `):R.main.add(x`if (leftLen < 0.001) {
 joinDisplacementDir = right;
 }
 else if (rightLen < 0.001) {
@@ -153,7 +151,7 @@ joinDisplacementDir = left;
 else {
 joinDisplacementDir = (isStartVertex || subdivisionFactor > 0.0) ? right : left;
 }
-joinDisplacementDir = perpendicular(joinDisplacementDir);`);const Y=0!==N;return F.main.add(S`
+joinDisplacementDir = perpendicular(joinDisplacementDir);`);const X=0!==E;return R.main.add(x`
         displacementLen = lineWidth;
       }
     } else {
@@ -161,9 +159,9 @@ joinDisplacementDir = perpendicular(joinDisplacementDir);`);const Y=0!==N;return
       joinDisplacementDir = isStartVertex ? right : left;
       joinDisplacementDir = perpendicular(joinDisplacementDir);
 
-      ${Y?S`capDisplacementDir = vec3((isStartVertex ? -right : left).xy, 0.0);`:""}
+      ${X?x`capDisplacementDir = vec3((isStartVertex ? -right : left).xy, 0.0);`:""}
     }
-  `),F.main.add(S`
+  `),R.main.add(x`
     // Displacement (in pixels) caused by join/or cap
     vec2 dposXY = (joinDisplacementDir.xy * sign(lineParameters.y) + capDisplacementDir.xy) * displacementLen;
 
@@ -178,22 +176,22 @@ joinDisplacementDir = perpendicular(joinDisplacementDir);`);const Y=0!==N;return
     float lineDistNorm = noPerspectiveWrite(sign(lineParameters.y), pos.w);
 
     vLineDistance = lineWidth * lineDistNorm;
-    ${X?S`vLineDistanceNorm = lineDistNorm;`:""}
+    ${G?x`vLineDistanceNorm = lineDistNorm;`:""}
 
     pos.xyz += dpos;
-  `),Z&&F.main.add(S`vec2 segmentDir = normalize(segment.xy);
+  `),U&&R.main.add(x`vec2 segmentDir = normalize(segment.xy);
 vSegmentSDF = noPerspectiveWrite((isJoin && isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentOrigin.xy, segmentDir)), pos.w);
-vReverseSegmentSDF = noPerspectiveWrite((isJoin && !isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentEnd.xy, -segmentDir)), pos.w);`),O&&(T?F.uniforms.add(new x("worldToScreenRatio",e=>1/e.screenToPCSRatio)):F.main.add(S`vec3 segmentCenter = mix((nextPosition + position) * 0.5, (position + prevPosition) * 0.5, isEndVertex);
-float worldToScreenRatio = computeWorldToScreenRatio(segmentCenter);`),F.main.add(S`float segmentLengthScreenDouble = length(segment.xy);
+vReverseSegmentSDF = noPerspectiveWrite((isJoin && !isStartVertex) ? LARGE_HALF_FLOAT : (dot(pos.xy - segmentEnd.xy, -segmentDir)), pos.w);`),N&&(V?R.uniforms.add(new h("worldToScreenRatio",e=>1/e.screenToPCSRatio)):R.main.add(x`vec3 segmentCenter = mix((nextPosition + position) * 0.5, (position + prevPosition) * 0.5, isEndVertex);
+float worldToScreenRatio = computeWorldToScreenRatio(segmentCenter);`),R.main.add(x`float segmentLengthScreenDouble = length(segment.xy);
 float segmentLengthScreen = segmentLengthScreenDouble * 0.5;
 float discreteWorldToScreenRatio = discretizeWorldToScreenRatio(worldToScreenRatio);
 float segmentLengthRender = length(mix(nextPosition - position, position - prevPosition, isEndVertex));
-vStipplePatternStretch = worldToScreenRatio / discreteWorldToScreenRatio;`),T?F.main.add(S`float segmentLengthPseudoScreen = segmentLengthScreen / pixelRatio * discreteWorldToScreenRatio / worldToScreenRatio;
-float startPseudoScreen = u0 * discreteWorldToScreenRatio - mix(0.0, segmentLengthPseudoScreen, isEndVertex);`):F.main.add(S`float startPseudoScreen = mix(u0, u0 - segmentLengthRender, isEndVertex) * discreteWorldToScreenRatio;
-float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRatio;`),F.uniforms.add(new u("stipplePatternPixelSize",e=>o(e))),F.main.add(S`
+vStipplePatternStretch = worldToScreenRatio / discreteWorldToScreenRatio;`),V?R.main.add(x`float segmentLengthPseudoScreen = segmentLengthScreen / pixelRatio * discreteWorldToScreenRatio / worldToScreenRatio;
+float startPseudoScreen = u0 * discreteWorldToScreenRatio - mix(0.0, segmentLengthPseudoScreen, isEndVertex);`):R.main.add(x`float startPseudoScreen = mix(u0, u0 - segmentLengthRender, isEndVertex) * discreteWorldToScreenRatio;
+float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRatio;`),R.uniforms.add(new u("stipplePatternPixelSize",e=>o(e))),R.main.add(x`
       float patternLength = patternLineSize * stipplePatternPixelSize;
 
-      ${D(H,S`
+      ${S(B,x`
           float uu = mix(u0, u0 - segmentLengthRender, isEndVertex);
           vStippleDistanceLimits = vec2(uu, uu + segmentLengthRender);
           vStipplePatternStretch = 1.0;
@@ -201,7 +199,7 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
           // The v-coordinate used in case of an image pattern.
           bool isLeft = sign(lineParameters.y) < 0.0;
           vStippleV = isLeft ? 0.0 : 1.0;
-        `,S`
+        `,x`
           // 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);
@@ -232,7 +230,7 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
                                  isStartVertex ?
                                   vec2(-1e34, vStippleDistanceLimits.y) :
                                   vec2(vStippleDistanceLimits.x, 1e34);
-    `)),F.main.add(S`
+    `)),R.main.add(x`
       // Convert back into NDC
       pos.xy = (pos.xy / viewport.zw) * pos.w;
       pos.z = pos.z * pos.w;
@@ -240,43 +238,42 @@ float segmentLengthPseudoScreen = segmentLengthRender * discreteWorldToScreenRat
       vColor = getColor();
       vColor.a = noPerspectiveWrite(vColor.a * coverage, pos.w);
 
-      ${_&&!T?"pos.z -= 0.001 * pos.w;":""}
+      ${$&&!V?"pos.z -= 0.001 * pos.w;":""}
 
       // transform final position to camera space for slicing
       vpos = (inverseProjectionMatrix * pos).xyz;
       gl_Position = pos;
       forwardObjectAndLayerIdColor();
-    }`),C.fragment.include(e,j),C.include(y,j),A.include(d),A.main.add(S`discardBySlice(vpos);
-discardByTerrainDepth();`),C.include(c),A.include(L),A.main.add(S`
+    }`),j.fragment.include(e,P),j.include(b,P),F.include(l),F.main.add(x`discardBySlice(vpos);`),j.include(p),F.include(w),F.main.add(x`
     float lineWidth = noPerspectiveRead(vLineWidth);
     float lineDistance = noPerspectiveRead(vLineDistance);
-    ${D(X,S`float lineDistanceNorm = noPerspectiveRead(vLineDistanceNorm);`)}
-  `),_?A.main.add(S`vec4 finalColor = vec4(1.0, 0.0, 1.0, 1.0);`):(Z&&A.main.add(S`float sdf = noPerspectiveRead(min(vSegmentSDF, vReverseSegmentSDF));
+    ${S(G,x`float lineDistanceNorm = noPerspectiveRead(vLineDistanceNorm);`)}
+  `),$?F.main.add(x`vec4 finalColor = vec4(1.0, 0.0, 1.0, 1.0);`):(U&&F.main.add(x`float sdf = noPerspectiveRead(min(vSegmentSDF, vReverseSegmentSDF));
 vec2 fragmentPosition = vec2(min(sdf, 0.0), lineDistance);
 float fragmentRadius = length(fragmentPosition);
 float fragmentCapSDF = (fragmentRadius - lineWidth) * 0.5;
 float capCoverage = clamp(0.5 - fragmentCapSDF, 0.0, 1.0);
 if (capCoverage < alphaCutoff) {
 discard;
-}`),G?A.main.add(S`vec2 stipplePosition = vec2(
+}`),Z?F.main.add(x`vec2 stipplePosition = vec2(
 min(getStippleSDF() * 2.0 - 1.0, 0.0),
 lineDistanceNorm
 );
 float stippleRadius = length(stipplePosition * lineWidth);
 float stippleCapSDF = (stippleRadius - lineWidth) * 0.5;
 float stippleCoverage = clamp(0.5 - stippleCapSDF, 0.0, 1.0);
-float stippleAlpha = step(alphaCutoff, stippleCoverage);`):A.main.add(S`float stippleAlpha = getStippleAlpha(lineWidth);`),11!==E&&A.main.add(S`discardByStippleAlpha(stippleAlpha, alphaCutoff);`),C.include(c),A.uniforms.add(new h("intrinsicColor",e=>e.color)).main.add(S`vec4 color = intrinsicColor * vColor;
-color.a = noPerspectiveRead(color.a);`),k&&A.uniforms.add(new h("innerColor",e=>e.innerColor??e.color),new u("innerWidth",(e,i)=>e.innerWidth*i.camera.pixelRatio)).main.add(S`float distToInner = abs(lineDistance) - innerWidth;
+float stippleAlpha = step(alphaCutoff, stippleCoverage);`):F.main.add(x`float stippleAlpha = getStippleAlpha(lineWidth);`),11!==T&&F.main.add(x`discardByStippleAlpha(stippleAlpha, alphaCutoff);`),j.include(p),F.uniforms.add(new g("intrinsicColor",e=>e.color)).main.add(x`vec4 color = intrinsicColor * vColor;
+color.a = noPerspectiveRead(color.a);`),_&&F.uniforms.add(new g("innerColor",e=>e.innerColor??e.color),new u("innerWidth",(e,i)=>e.innerWidth*i.camera.pixelRatio)).main.add(x`float distToInner = abs(lineDistance) - 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);`),A.main.add(S`vec4 finalColor = blendStipple(color, stippleAlpha);`),M&&(A.uniforms.add(new u("falloff",e=>e.falloff)),A.main.add(S`finalColor.a *= pow(max(0.0, 1.0 - abs(lineDistanceNorm)), falloff);`)),O||A.main.add(S`float featherStartDistance = max(lineWidth - 2.0, 0.0);
+color = mix(color, vec4(innerColor.rgb, innerAlpha), innerAA);`),F.main.add(x`vec4 finalColor = blendStipple(color, stippleAlpha);`),O&&(F.uniforms.add(new u("falloff",e=>e.falloff)),F.main.add(x`finalColor.a *= pow(max(0.0, 1.0 - abs(lineDistanceNorm)), falloff);`)),N||F.main.add(x`float featherStartDistance = max(lineWidth - 2.0, 0.0);
 float value = abs(lineDistance);
 float feather = (value - featherStartDistance) / (lineWidth - featherStartDistance);
-finalColor.a *= 1.0 - clamp(feather, 0.0, 1.0);`),I&&A.main.add(S`
+finalColor.a *= 1.0 - clamp(feather, 0.0, 1.0);`),k&&F.main.add(x`
         finalColor = animate(finalColor);
 
-        ${D(11!==E,S`
+        ${S(11!==T,x`
             if (finalColor.a <= alphaCutoff) {
               discard;
             }`)}
-      `)),A.main.add(S`outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),C}const C=Object.freeze(Object.defineProperty({__proto__:null,build:j,ribbonlineNumRoundJoinSubdivisions:P},Symbol.toStringTag,{value:"Module"}));export{C as R,j as b,P as r};
+      `)),F.main.add(x`outputColorHighlightOLID(applySlice(finalColor, vpos), finalColor.rgb);`),j}const j=Object.freeze(Object.defineProperty({__proto__:null,build:P,ribbonlineNumRoundJoinSubdivisions:z},Symbol.toStringTag,{value:"Module"}));export{j as R,P as b,z as r};

package/chunks/ShadedColorMaterial.glsl.js

@@ -1,14 +1,13 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{create as e}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{ScreenSizeScaling as o}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSizeScaling.glsl.js";import{SliceDraw as r}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{terrainDepthTest as n}from"../views/3d/webgl-engine/core/shaderLibrary/shading/TerrainDepthTest.glsl.js";import{ColorConversion as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as s,addViewNormal as a}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as t}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{glsl as c,If as g}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOLID as m}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as v}from"../views/webgl/ShaderBuilder.js";function w(e){const w=new v;w.include(i),w.include(o,e),w.fragment.include(r,e),w.include(m,e),w.include(n,e);const{vertex:u,fragment:b}=w;return b.include(l),s(u,e),b.uniforms.add(new t("uColor",e=>e.color)),w.attributes.add("position","vec3"),w.varyings.add("vWorldPosition","vec3"),e.screenSizeEnabled&&w.attributes.add("offset","vec3"),e.shadingEnabled&&(a(u),w.attributes.add("normal","vec3"),w.varyings.add("vViewNormal","vec3"),b.uniforms.add(new d("shadingDirection",e=>e.shadingDirection)),b.uniforms.add(new t("shadedColor",e=>f(e.shadingTint,e.color)))),u.main.add(c`
-    vWorldPosition = ${e.screenSizeEnabled?c`screenSizeScaling(offset, position)`:c`position`};
-    ${g(e.shadingEnabled,c`vec3 worldNormal = normal;
+import{create as e}from"../core/libs/gl-matrix-2/factories/vec4f64.js";import{ScreenSizeScaling as o}from"../views/3d/webgl-engine/core/shaderLibrary/ScreenSizeScaling.glsl.js";import{SliceDraw as i}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{ColorConversion as l}from"../views/3d/webgl-engine/core/shaderLibrary/util/ColorConversion.glsl.js";import{addProjViewLocalOrigin as n,addViewNormal as s}from"../views/3d/webgl-engine/core/shaderLibrary/util/View.glsl.js";import{Float3PassUniform as a}from"../views/3d/webgl-engine/core/shaderModules/Float3PassUniform.js";import{Float4PassUniform as d}from"../views/3d/webgl-engine/core/shaderModules/Float4PassUniform.js";import{glsl as t,If as c}from"../views/3d/webgl-engine/core/shaderModules/glsl.js";import{outputColorHighlightOLID as g}from"../views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js";import{ShaderBuilder as m}from"../views/webgl/ShaderBuilder.js";function v(e){const v=new m;v.include(r),v.include(o,e),v.fragment.include(i,e),v.include(g,e);const{vertex:w,fragment:u}=v;return u.include(l),n(w,e),u.uniforms.add(new d("uColor",e=>e.color)),v.attributes.add("position","vec3"),v.varyings.add("vWorldPosition","vec3"),e.screenSizeEnabled&&v.attributes.add("offset","vec3"),e.shadingEnabled&&(s(w),v.attributes.add("normal","vec3"),v.varyings.add("vViewNormal","vec3"),u.uniforms.add(new a("shadingDirection",e=>e.shadingDirection)),u.uniforms.add(new d("shadedColor",e=>f(e.shadingTint,e.color)))),w.main.add(t`
+    vWorldPosition = ${e.screenSizeEnabled?t`screenSizeScaling(offset, position)`:t`position`};
+    ${c(e.shadingEnabled,t`vec3 worldNormal = normal;
            vViewNormal = (viewNormal * vec4(worldNormal, 1)).xyz;`)}
-    forwardViewPosDepth((view * vec4(vWorldPosition, 1.0)).xyz);
     gl_Position = transformPosition(proj, view, vWorldPosition);
-  `),b.main.add(c`
+  `),u.main.add(t`
       discardBySlice(vWorldPosition);
-      discardByTerrainDepth();
-      ${e.shadingEnabled?c`vec3 viewNormalNorm = normalize(vViewNormal);
+
+      ${e.shadingEnabled?t`vec3 viewNormalNorm = normalize(vViewNormal);
              float shadingFactor = 1.0 - clamp(-dot(viewNormalNorm, shadingDirection), 0.0, 1.0);
-             vec4 finalColor = mix(uColor, shadedColor, shadingFactor);`:c`vec4 finalColor = uColor;`}
-      outputColorHighlightOLID(applySlice(finalColor, vWorldPosition), finalColor.rgb);`),w}function f(e,o){const r=1-e[3],i=e[3]+o[3]*r;return 0===i?(u[3]=i,u):(u[0]=(e[0]*e[3]+o[0]*o[3]*r)/i,u[1]=(e[1]*e[3]+o[1]*o[3]*r)/i,u[2]=(e[2]*e[3]+o[2]*o[3]*r)/i,u[3]=o[3],u)}const u=e(),b=Object.freeze(Object.defineProperty({__proto__:null,build:w},Symbol.toStringTag,{value:"Module"}));export{b as S,w as b};
+             vec4 finalColor = mix(uColor, shadedColor, shadingFactor);`:t`vec4 finalColor = uColor;`}
+      outputColorHighlightOLID(applySlice(finalColor, vWorldPosition), finalColor.rgb);`),v}function f(e,o){const i=1-e[3],r=e[3]+o[3]*i;return 0===r?(w[3]=r,w):(w[0]=(e[0]*e[3]+o[0]*o[3]*i)/r,w[1]=(e[1]*e[3]+o[1]*o[3]*i)/r,w[2]=(e[2]*e[3]+o[2]*o[3]*i)/r,w[3]=o[3],w)}const w=e(),u=Object.freeze(Object.defineProperty({__proto__:null,build:v},Symbol.toStringTag,{value:"Module"}));export{u as S,v as b};