@webviz/subsurface-viewer 1.11.0 → 1.11.1

package/dist/layers/piechart/vertex.glsl.js

@@ -1,6 +1,6 @@
 export default `\
 #version 300 es
-#define SHADER_NAME graph-layer-axis-vertex-shader
+#define SHADER_NAME piechart-vertex-shader
 
 precision highp float;
 

package/dist/layers/points/privatePointsLayer.d.ts

@@ -1,8 +1,5 @@
 import type { ScatterplotLayerProps } from "@deck.gl/layers";
 import { ScatterplotLayer } from "@deck.gl/layers";
-import type { NumericArray } from "@math.gl/types";
-import type { LayerContext } from "@deck.gl/core";
-type UniformValue = number | boolean | Readonly<NumericArray>;
 export interface ExtendedScatterplotLayerProps {
     depthTest: boolean;
     ZIncreasingDownwards: boolean;
@@ -10,10 +7,5 @@ export interface ExtendedScatterplotLayerProps {
 export declare class PrivatePointsLayer extends ScatterplotLayer<unknown, ExtendedScatterplotLayerProps> {
     constructor(props: ScatterplotLayerProps);
     getShaders(): any;
-    draw(args: {
-        moduleParameters?: unknown;
-        uniforms: Record<string, UniformValue>;
-        context: LayerContext;
-    }): void;
+    draw(args: any): void;
 }
-export {};

package/dist/layers/points/privatePointsLayer.js

@@ -6,23 +6,50 @@ export class PrivatePointsLayer extends ScatterplotLayer {
         super(props);
     }
     getShaders() {
-        const defaultShaders = super.getShaders();
-        // Inject custom vertex shader.
-        return Object.assign(Object.assign({}, defaultShaders), { vs });
+        const superShaders = super.getShaders();
+        // use object.assign to make sure we don't overwrite existing fields like `vs`, `modules`...
+        return Object.assign({}, superShaders, {
+            vs: vs,
+            modules: [...superShaders.modules, pointsUniforms],
+        });
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     draw(args) {
-        args.uniforms["ZIncreasingDownwards"] = this.props.ZIncreasingDownwards;
+        var _a;
         let restoreDepthTest = false;
         if (typeof this.props.depthTest === "boolean" &&
             !this.props.depthTest) {
             restoreDepthTest = true;
             this.context.gl.disable(GL.DEPTH_TEST);
         }
-        super.draw({ uniforms: args.uniforms });
+        // inject the local uniforms into the shader
+        (_a = this.state.model) === null || _a === void 0 ? void 0 : _a.shaderInputs.setProps({
+            points: {
+                opacity: this.props.opacity,
+                ZIncreasingDownwards: this.props.ZIncreasingDownwards,
+            },
+        });
+        super.draw(args.uniforms);
         if (restoreDepthTest) {
             this.context.gl.enable(GL.DEPTH_TEST);
         }
     }
 }
 PrivatePointsLayer.layerName = "PrivatePointsLayer";
+const pointsUniformsBlock = /*glsl*/ `\
+uniform pointsUniforms {
+   float opacity;
+   bool ZIncreasingDownwards;
+} points;
+`;
+// NOTE: this must exactly the same name than in the uniform block
+const pointsUniforms = {
+    name: "points",
+    vs: pointsUniformsBlock,
+    fs: undefined,
+    uniformTypes: {
+        opacity: "f32",
+        ZIncreasingDownwards: "u32",
+    },
+};
 //# sourceMappingURL=privatePointsLayer.js.map

package/dist/layers/points/privatePointsLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"privatePointsLayer.js","sourceRoot":"","sources":["../../../src/layers/points/privatePointsLayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAKxC,OAAO,EAAE,MAAM,eAAe,CAAC;AAS/B,MAAM,OAAO,kBAAmB,SAAQ,gBAGvC;IACG,YAAY,KAA4B;QACpC,KAAK,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED,UAAU;QACN,MAAM,cAAc,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QAE1C,+BAA+B;QAC/B,uCAAY,cAAc,KAAE,EAAE,IAAG;IACrC,CAAC;IAED,IAAI,CAAC,IAIJ;QACG,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC;QAExE,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IACI,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS;YACzC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EACvB,CAAC;YACC,gBAAgB,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC3C,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxC,IAAI,gBAAgB,EAAE,CAAC;YACnB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC1C,CAAC;IACL,CAAC;CACJ;AAED,kBAAkB,CAAC,SAAS,GAAG,oBAAoB,CAAC"}
+{"version":3,"file":"privatePointsLayer.js","sourceRoot":"","sources":["../../../src/layers/points/privatePointsLayer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAIxC,OAAO,EAAE,MAAM,eAAe,CAAC;AAO/B,MAAM,OAAO,kBAAmB,SAAQ,gBAGvC;IACG,YAAY,KAA4B;QACpC,KAAK,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED,UAAU;QACN,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACxC,4FAA4F;QAC5F,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE;YACnC,EAAE,EAAE,EAAE;YACN,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,OAAO,EAAE,cAAc,CAAC;SACrD,CAAC,CAAC;IACP,CAAC;IAED,8DAA8D;IAC9D,IAAI,CAAC,IAAS;;QACV,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IACI,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS;YACzC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EACvB,CAAC;YACC,gBAAgB,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC3C,CAAC;QACD,4CAA4C;QAC5C,MAAA,IAAI,CAAC,KAAK,CAAC,KAAK,0CAAE,YAAY,CAAC,QAAQ,CAAC;YACpC,MAAM,EAAE;gBACJ,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO;gBAC3B,oBAAoB,EAAE,IAAI,CAAC,KAAK,CAAC,oBAAoB;aACxD;SACJ,CAAC,CAAC;QACH,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,IAAI,gBAAgB,EAAE,CAAC;YACnB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC1C,CAAC;IACL,CAAC;CACJ;AAED,kBAAkB,CAAC,SAAS,GAAG,oBAAoB,CAAC;AAEpD,MAAM,mBAAmB,GAAG,QAAQ,CAAC;;;;;CAKpC,CAAC;AAOF,kEAAkE;AAClE,MAAM,cAAc,GAAG;IACnB,IAAI,EAAE,QAAQ;IACd,EAAE,EAAE,mBAAmB;IACvB,EAAE,EAAE,SAAS;IACb,YAAY,EAAE;QACV,OAAO,EAAE,KAAK;QACd,oBAAoB,EAAE,KAAK;KAC9B;CAC4D,CAAC"}

package/dist/layers/points/vertex.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "#version 300 es\n#define SHADER_NAME points-layer-vertex-shader\n\nin vec3 positions;\n\nin vec3 instancePositions;\nin vec3 instancePositions64Low;\nin float instanceRadius;\nin float instanceLineWidths;\nin vec4 instanceFillColors;\nin vec4 instanceLineColors;\nin vec3 instancePickingColors;\n\nuniform float opacity;\nuniform float radiusScale;\nuniform float radiusMinPixels;\nuniform float radiusMaxPixels;\nuniform float lineWidthScale;\nuniform float lineWidthMinPixels;\nuniform float lineWidthMaxPixels;\nuniform float stroked;\nuniform bool filled;\nuniform bool antialiasing;\nuniform bool billboard;\nuniform int radiusUnits;\nuniform int lineWidthUnits;\nuniform bool ZIncreasingDownwards;\n\nout vec4 vFillColor;\nout vec4 vLineColor;\nout vec2 unitPosition;\nout float innerUnitRadius;\nout float outerRadiusPixels;\n\n\nvoid main(void) {\n  vec3 position = instancePositions;\n  vec3 position64low = instancePositions64Low;\n\n  if(ZIncreasingDownwards) {\n    position.z *= -1.0;\n    position64low.z *= -1.0;\n  }\n  geometry.worldPosition = position;\n\n  // Multiply out radius and clamp to limits\n  outerRadiusPixels = clamp(\n    project_size_to_pixel(radiusScale * instanceRadius, radiusUnits),\n    radiusMinPixels, radiusMaxPixels\n  );\n  \n  // Multiply out line width and clamp to limits\n  float lineWidthPixels = clamp(\n    project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits),\n    lineWidthMinPixels, lineWidthMaxPixels\n  );\n\n  // outer radius needs to offset by half stroke width\n  outerRadiusPixels += stroked * lineWidthPixels / 2.0;\n\n  // Expand geometry to accomodate edge smoothing\n  float edgePadding = antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;\n\n  // position on the containing square in [-1, 1] space\n  unitPosition = edgePadding * positions.xy;\n  geometry.uv = unitPosition;\n  geometry.pickingColor = instancePickingColors;\n\n  innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels;\n  \n  if (billboard) {\n    gl_Position = project_position_to_clipspace(position, position64low, vec3(0.0), geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n    vec3 offset = edgePadding * positions * outerRadiusPixels;\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n  } else {\n    vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels);\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position = project_position_to_clipspace(position, position64low, offset, geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n  }\n\n  // Apply opacity to instance color, or return instance picking color\n  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity);\n  DECKGL_FILTER_COLOR(vFillColor, geometry);\n  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity);\n  DECKGL_FILTER_COLOR(vLineColor, geometry);\n}\n";
+declare const _default: "#version 300 es\n#define SHADER_NAME points-vertex-shader\n\nin vec3 positions;\n\nin vec3 instancePositions;\nin vec3 instancePositions64Low;\nin float instanceRadius;\nin float instanceLineWidths;\nin vec4 instanceFillColors;\nin vec4 instanceLineColors;\nin vec3 instancePickingColors;\n\nout vec4 vFillColor;\nout vec4 vLineColor;\nout vec2 unitPosition;\nout float innerUnitRadius;\nout float outerRadiusPixels;\n\n\nvoid main(void) {\n  vec3 position = instancePositions;\n  vec3 position64low = instancePositions64Low;\n\n  if(points.ZIncreasingDownwards) {\n    position.z *= -1.0;\n    position64low.z *= -1.0;\n  }\n  geometry.worldPosition = position;\n\n  // Multiply out radius and clamp to limits\n  outerRadiusPixels = clamp(\n    project_size_to_pixel(scatterplot.radiusScale * instanceRadius, scatterplot.radiusUnits),\n    scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels\n  );\n  \n  // Multiply out line width and clamp to limits\n  float lineWidthPixels = clamp(\n    project_size_to_pixel(scatterplot.lineWidthScale * instanceLineWidths, scatterplot.lineWidthUnits),\n    scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels\n  );\n\n  // outer radius needs to offset by half stroke width\n  outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;\n\n  // Expand geometry to accommodate edge smoothing\n  float edgePadding = scatterplot.antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;\n\n  // position on the containing square in [-1, 1] space\n  unitPosition = edgePadding * positions.xy;\n  geometry.uv = unitPosition;\n  geometry.pickingColor = instancePickingColors;\n\n  innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / outerRadiusPixels;\n  \n  if (scatterplot.billboard) {\n    gl_Position = project_position_to_clipspace(position, position64low, vec3(0.0), geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n    vec3 offset = edgePadding * positions * outerRadiusPixels;\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n  } else {\n    vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels);\n    DECKGL_FILTER_SIZE(offset, geometry);\n    gl_Position = project_position_to_clipspace(position, position64low, offset, geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n  }\n\n  // Apply opacity to instance color, or return instance picking color\n  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * points.opacity);\n  DECKGL_FILTER_COLOR(vFillColor, geometry);\n  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * points.opacity);\n  DECKGL_FILTER_COLOR(vLineColor, geometry);\n}\n";
 export default _default;

package/dist/layers/points/vertex.glsl.js

@@ -19,7 +19,7 @@
 // THE SOFTWARE.
 export default `\
 #version 300 es
-#define SHADER_NAME points-layer-vertex-shader
+#define SHADER_NAME points-vertex-shader
 
 in vec3 positions;
 
@@ -31,21 +31,6 @@ in vec4 instanceFillColors;
 in vec4 instanceLineColors;
 in vec3 instancePickingColors;
 
-uniform float opacity;
-uniform float radiusScale;
-uniform float radiusMinPixels;
-uniform float radiusMaxPixels;
-uniform float lineWidthScale;
-uniform float lineWidthMinPixels;
-uniform float lineWidthMaxPixels;
-uniform float stroked;
-uniform bool filled;
-uniform bool antialiasing;
-uniform bool billboard;
-uniform int radiusUnits;
-uniform int lineWidthUnits;
-uniform bool ZIncreasingDownwards;
-
 out vec4 vFillColor;
 out vec4 vLineColor;
 out vec2 unitPosition;
@@ -57,7 +42,7 @@ void main(void) {
   vec3 position = instancePositions;
   vec3 position64low = instancePositions64Low;
 
-  if(ZIncreasingDownwards) {
+  if(points.ZIncreasingDownwards) {
     position.z *= -1.0;
     position64low.z *= -1.0;
   }
@@ -65,30 +50,30 @@ void main(void) {
 
   // Multiply out radius and clamp to limits
   outerRadiusPixels = clamp(
-    project_size_to_pixel(radiusScale * instanceRadius, radiusUnits),
-    radiusMinPixels, radiusMaxPixels
+    project_size_to_pixel(scatterplot.radiusScale * instanceRadius, scatterplot.radiusUnits),
+    scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels
   );
   
   // Multiply out line width and clamp to limits
   float lineWidthPixels = clamp(
-    project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits),
-    lineWidthMinPixels, lineWidthMaxPixels
+    project_size_to_pixel(scatterplot.lineWidthScale * instanceLineWidths, scatterplot.lineWidthUnits),
+    scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels
   );
 
   // outer radius needs to offset by half stroke width
-  outerRadiusPixels += stroked * lineWidthPixels / 2.0;
+  outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;
 
-  // Expand geometry to accomodate edge smoothing
-  float edgePadding = antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;
+  // Expand geometry to accommodate edge smoothing
+  float edgePadding = scatterplot.antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;
 
   // position on the containing square in [-1, 1] space
   unitPosition = edgePadding * positions.xy;
   geometry.uv = unitPosition;
   geometry.pickingColor = instancePickingColors;
 
-  innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels;
+  innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / outerRadiusPixels;
   
-  if (billboard) {
+  if (scatterplot.billboard) {
     gl_Position = project_position_to_clipspace(position, position64low, vec3(0.0), geometry.position);
     DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
     vec3 offset = edgePadding * positions * outerRadiusPixels;
@@ -102,9 +87,9 @@ void main(void) {
   }
 
   // Apply opacity to instance color, or return instance picking color
-  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity);
+  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * points.opacity);
   DECKGL_FILTER_COLOR(vFillColor, geometry);
-  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity);
+  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * points.opacity);
   DECKGL_FILTER_COLOR(vLineColor, geometry);
 }
 `;

package/dist/layers/points/vertex.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"vertex.glsl.js","sourceRoot":"","sources":["../../../src/layers/points/vertex.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Fd,CAAC"}
+{"version":3,"file":"vertex.glsl.js","sourceRoot":"","sources":["../../../src/layers/points/vertex.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Ed,CAAC"}

package/dist/layers/polylines/path-layer-fragment.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "#version 300 es\n#define SHADER_NAME path-layer-fragment-shader\n\nprecision highp float;\n\nuniform float miterLimit;\n\nin vec4 vColor;\nin vec2 vCornerOffset;\nin float vMiterLength;\n/*\n * vPathPosition represents the relative coordinates of the current fragment on the path segment.\n * vPathPosition.x - position along the width of the path, between [-1, 1]. 0 is the center line.\n * vPathPosition.y - position along the length of the path, between [0, L / width].\n */\nin vec2 vPathPosition;\nin float vPathLength;\nin float vJointType;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  geometry.uv = vPathPosition;\n\n  if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {\n    // if joint is rounded, test distance from the corner\n    if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {\n      discard;\n    }\n    // trim miter\n    if (vJointType < 0.5 && vMiterLength > miterLimit + 1.0) {\n      discard;\n    }\n  }\n  fragColor = vColor;\n\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
+declare const _default: "#version 300 es\n#define SHADER_NAME polylines-fragment-shader\n\nprecision highp float;\n\nin vec4 vColor;\nin vec2 vCornerOffset;\nin float vMiterLength;\n/*\n * vPathPosition represents the relative coordinates of the current fragment on the path segment.\n * vPathPosition.x - position along the width of the path, between [-1, 1]. 0 is the center line.\n * vPathPosition.y - position along the length of the path, between [0, L / width].\n */\nin vec2 vPathPosition;\nin float vPathLength;\nin float vJointType;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  geometry.uv = vPathPosition;\n\n  if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {\n    // if joint is rounded, test distance from the corner\n    if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {\n      discard;\n    }\n    // trim miter\n    if (vJointType < 0.5 && vMiterLength > path.miterLimit + 1.0) {\n      discard;\n    }\n  }\n  fragColor = vColor;\n\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
 export default _default;

package/dist/layers/polylines/path-layer-fragment.glsl.js

@@ -19,12 +19,10 @@
 // THE SOFTWARE.
 export default `\
 #version 300 es
-#define SHADER_NAME path-layer-fragment-shader
+#define SHADER_NAME polylines-fragment-shader
 
 precision highp float;
 
-uniform float miterLimit;
-
 in vec4 vColor;
 in vec2 vCornerOffset;
 in float vMiterLength;
@@ -48,7 +46,7 @@ void main(void) {
       discard;
     }
     // trim miter
-    if (vJointType < 0.5 && vMiterLength > miterLimit + 1.0) {
+    if (vJointType < 0.5 && vMiterLength > path.miterLimit + 1.0) {
       discard;
     }
   }

package/dist/layers/polylines/path-layer-fragment.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"path-layer-fragment.glsl.js","sourceRoot":"","sources":["../../../src/layers/polylines/path-layer-fragment.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCd,CAAC"}
+{"version":3,"file":"path-layer-fragment.glsl.js","sourceRoot":"","sources":["../../../src/layers/polylines/path-layer-fragment.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd,CAAC"}

package/dist/layers/polylines/path-layer-vertex.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "#version 300 es\n#define SHADER_NAME path-layer-vertex-shader\n\nin vec2 positions;\n\nin float instanceTypes;\nin vec3 instanceStartPositions;\nin vec3 instanceEndPositions;\nin vec3 instanceLeftPositions;\nin vec3 instanceRightPositions;\nin vec3 instanceLeftPositions64Low;\nin vec3 instanceStartPositions64Low;\nin vec3 instanceEndPositions64Low;\nin vec3 instanceRightPositions64Low;\nin float instanceStrokeWidths;\nin vec4 instanceColors;\nin vec3 instancePickingColors;\n\nuniform float widthScale;\nuniform float widthMinPixels;\nuniform float widthMaxPixels;\nuniform float jointType;\nuniform float capType;\nuniform float miterLimit;\nuniform bool billboard;\nuniform int widthUnits;\n\nuniform float opacity;\nuniform bool ZIncreasingDownwards;\n\nout vec4 vColor;\nout vec2 vCornerOffset;\nout float vMiterLength;\nout vec2 vPathPosition;\nout float vPathLength;\nout float vJointType;\n\nconst float EPSILON = 0.001;\nconst vec3 ZERO_OFFSET = vec3(0.0);\n\nfloat flipIfTrue(bool flag) {\n  return -(float(flag) * 2. - 1.);\n}\n\n// calculate line join positions\nvec3 getLineJoinOffset(\n  vec3 prevPoint, vec3 currPoint, vec3 nextPoint,\n  vec2 width\n) {\n  bool isEnd = positions.x > 0.0;\n  // side of the segment - -1: left, 0: center, 1: right\n  float sideOfPath = positions.y;\n  float isJoint = float(sideOfPath == 0.0);\n\n  vec3 deltaA3 = (currPoint - prevPoint);\n  vec3 deltaB3 = (nextPoint - currPoint);\n\n  mat3 rotationMatrix;\n  bool needsRotation = !billboard && project_needs_rotation(currPoint, rotationMatrix);\n  if (needsRotation) {\n    deltaA3 = deltaA3 * rotationMatrix;\n    deltaB3 = deltaB3 * rotationMatrix;\n  }\n  vec2 deltaA = deltaA3.xy / width;\n  vec2 deltaB = deltaB3.xy / width;\n\n  float lenA = length(deltaA);\n  float lenB = length(deltaB);\n\n  vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0);\n  vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0);\n\n  vec2 perpA = vec2(-dirA.y, dirA.x);\n  vec2 perpB = vec2(-dirB.y, dirB.x);\n\n  // tangent of the corner\n  vec2 tangent = dirA + dirB;\n  tangent = length(tangent) > 0. ? normalize(tangent) : perpA;\n  // direction of the corner\n  vec2 miterVec = vec2(-tangent.y, tangent.x);\n  // direction of the segment\n  vec2 dir = isEnd ? dirA : dirB;\n  // direction of the extrusion\n  vec2 perp = isEnd ? perpA : perpB;\n  // length of the segment\n  float L = isEnd ? lenA : lenB;\n\n  // A = angle of the corner\n  float sinHalfA = abs(dot(miterVec, perp));\n  float cosHalfA = abs(dot(dirA, miterVec));\n\n  // -1: right, 1: left\n  float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x);\n\n  // relative position to the corner:\n  // -1: inside (smaller side of the angle)\n  // 0: center\n  // 1: outside (bigger side of the angle)\n  float cornerPosition = sideOfPath * turnDirection;\n\n  float miterSize = 1.0 / max(sinHalfA, EPSILON);\n  // trim if inside corner extends further than the line segment\n  miterSize = mix(\n    min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)),\n    miterSize,\n    step(0.0, cornerPosition)\n  );\n\n  vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition))\n    * (sideOfPath + isJoint * turnDirection);\n\n  // special treatment for start cap and end cap\n  bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0));\n  bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0));\n  bool isCap = isStartCap || isEndCap;\n\n  // extend out a triangle to envelope the round cap\n  if (isCap) {\n    offsetVec = mix(perp * sideOfPath, dir * capType * 4.0 * flipIfTrue(isStartCap), isJoint);\n    vJointType = capType;\n  } else {\n    vJointType = jointType;\n  }\n\n  // Generate variables for fragment shader\n  vPathLength = L;\n  vCornerOffset = offsetVec;\n  vMiterLength = dot(vCornerOffset, miterVec * turnDirection);\n  vMiterLength = isCap ? isJoint : vMiterLength;\n\n  vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);\n  vPathPosition = vec2(\n    dot(offsetFromStartOfPath, perp),\n    dot(offsetFromStartOfPath, dir)\n  );\n  geometry.uv = vPathPosition;\n\n  float isValid = step(instanceTypes, 3.5);\n  vec3 offset = vec3(offsetVec * width * isValid, 0.0);\n\n  if (needsRotation) {\n    offset = rotationMatrix * offset;\n  }\n  return offset;\n}\n\n// In clipspace extrusion, if a line extends behind the camera, clip it to avoid visual artifacts\nvoid clipLine(inout vec4 position, vec4 refPosition) {\n  if (position.w < EPSILON) {\n    float r = (EPSILON - refPosition.w) / (position.w - refPosition.w);\n    position = refPosition + (position - refPosition) * r;\n  }\n}\n\nvoid main() {\n  geometry.pickingColor = instancePickingColors;\n\n  vColor = vec4(instanceColors.rgb, instanceColors.a * opacity);\n  vec3 leftPosition  = instanceLeftPositions;\n  vec3 startPosition = instanceStartPositions;\n  vec3 leftPos64Low  = instanceLeftPositions64Low;\n  vec3 startPos64Low = instanceStartPositions64Low;\n\n  vec3 rightposition = instanceRightPositions;\n  vec3 endPosition   = instanceEndPositions;\n  vec3 rightPos64Low = instanceRightPositions64Low;\n  vec3 endPos64Low   = instanceEndPositions64Low;\n\n  if(ZIncreasingDownwards) {\n    leftPosition.z *= -1.0;\n    startPosition.z *= -1.0;\n    leftPos64Low.z  *= -1.0;\n    startPos64Low.z *= -1.0;\n    rightposition.z *= -1.0;\n    endPosition.z   *= -1.0;\n    rightPos64Low.z *= -1.0;\n    endPos64Low.z   *= -1.0; \n  }\n\n  float isEnd = positions.x;\n\n  vec3 prevPosition = mix(leftPosition, startPosition, isEnd);\n  vec3 prevPosition64Low = mix(leftPos64Low, startPos64Low, isEnd);\n\n  vec3 currPosition = mix(startPosition, endPosition, isEnd);\n  vec3 currPosition64Low = mix(startPos64Low, endPos64Low, isEnd);\n\n  vec3 nextPosition = mix(endPosition, rightposition, isEnd);\n  vec3 nextPosition64Low = mix(endPos64Low, rightPos64Low, isEnd);\n\n  geometry.worldPosition = currPosition;\n  vec2 widthPixels = vec2(clamp(\n    project_size_to_pixel(instanceStrokeWidths * widthScale, widthUnits),\n    widthMinPixels, widthMaxPixels) / 2.0);\n  vec3 width;\n\n  if (billboard) {\n    // Extrude in clipspace\n    vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);\n    vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);\n    vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);\n\n    clipLine(prevPositionScreen, currPositionScreen);\n    clipLine(nextPositionScreen, currPositionScreen);\n    clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd));\n\n    width = vec3(widthPixels, 0.0);\n    DECKGL_FILTER_SIZE(width, geometry);\n\n    vec3 offset = getLineJoinOffset(\n      prevPositionScreen.xyz / prevPositionScreen.w,\n      currPositionScreen.xyz / currPositionScreen.w,\n      nextPositionScreen.xyz / nextPositionScreen.w,\n      project_pixel_size_to_clipspace(width.xy)\n    );\n\n    DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);\n    gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);\n  } else {\n    // Extrude in commonspace\n    prevPosition = project_position(prevPosition, prevPosition64Low);\n    currPosition = project_position(currPosition, currPosition64Low);\n    nextPosition = project_position(nextPosition, nextPosition64Low);\n\n    width = vec3(project_pixel_size(widthPixels), 0.0);\n    DECKGL_FILTER_SIZE(width, geometry);\n\n    vec3 offset = getLineJoinOffset(prevPosition, currPosition, nextPosition, width.xy);\n    geometry.position = vec4(currPosition + offset, 1.0);\n    gl_Position = project_common_position_to_clipspace(geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n  }\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n";
+declare const _default: "#version 300 es\n#define SHADER_NAME polylines-vertex-shader\n\nin vec2 positions;\n\nin float instanceTypes;\nin vec3 instanceStartPositions;\nin vec3 instanceEndPositions;\nin vec3 instanceLeftPositions;\nin vec3 instanceRightPositions;\nin vec3 instanceLeftPositions64Low;\nin vec3 instanceStartPositions64Low;\nin vec3 instanceEndPositions64Low;\nin vec3 instanceRightPositions64Low;\nin float instanceStrokeWidths;\nin vec4 instanceColors;\nin vec3 instancePickingColors;\n\nout vec4 vColor;\nout vec2 vCornerOffset;\nout float vMiterLength;\nout vec2 vPathPosition;\nout float vPathLength;\nout float vJointType;\n\nconst float EPSILON = 0.001;\nconst vec3 ZERO_OFFSET = vec3(0.0);\n\nfloat flipIfTrue(bool flag) {\n  return -(float(flag) * 2. - 1.);\n}\n\n// calculate line join positions\nvec3 getLineJoinOffset(\n  vec3 prevPoint, vec3 currPoint, vec3 nextPoint,\n  vec2 width\n) {\n  bool isEnd = positions.x > 0.0;\n  // side of the segment - -1: left, 0: center, 1: right\n  float sideOfPath = positions.y;\n  float isJoint = float(sideOfPath == 0.0);\n\n  vec3 deltaA3 = (currPoint - prevPoint);\n  vec3 deltaB3 = (nextPoint - currPoint);\n\n  mat3 rotationMatrix;\n  bool needsRotation = !path.billboard && project_needs_rotation(currPoint, rotationMatrix);\n  if (needsRotation) {\n    deltaA3 = deltaA3 * rotationMatrix;\n    deltaB3 = deltaB3 * rotationMatrix;\n  }\n  vec2 deltaA = deltaA3.xy / width;\n  vec2 deltaB = deltaB3.xy / width;\n\n  float lenA = length(deltaA);\n  float lenB = length(deltaB);\n\n  vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0);\n  vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0);\n\n  vec2 perpA = vec2(-dirA.y, dirA.x);\n  vec2 perpB = vec2(-dirB.y, dirB.x);\n\n  // tangent of the corner\n  vec2 tangent = dirA + dirB;\n  tangent = length(tangent) > 0. ? normalize(tangent) : perpA;\n  // direction of the corner\n  vec2 miterVec = vec2(-tangent.y, tangent.x);\n  // direction of the segment\n  vec2 dir = isEnd ? dirA : dirB;\n  // direction of the extrusion\n  vec2 perp = isEnd ? perpA : perpB;\n  // length of the segment\n  float L = isEnd ? lenA : lenB;\n\n  // A = angle of the corner\n  float sinHalfA = abs(dot(miterVec, perp));\n  float cosHalfA = abs(dot(dirA, miterVec));\n\n  // -1: right, 1: left\n  float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x);\n\n  // relative position to the corner:\n  // -1: inside (smaller side of the angle)\n  // 0: center\n  // 1: outside (bigger side of the angle)\n  float cornerPosition = sideOfPath * turnDirection;\n\n  float miterSize = 1.0 / max(sinHalfA, EPSILON);\n  // trim if inside corner extends further than the line segment\n  miterSize = mix(\n    min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)),\n    miterSize,\n    step(0.0, cornerPosition)\n  );\n\n  vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition))\n    * (sideOfPath + isJoint * turnDirection);\n\n  // special treatment for start cap and end cap\n  bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0));\n  bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0));\n  bool isCap = isStartCap || isEndCap;\n\n  // extend out a triangle to envelope the round cap\n  if (isCap) {\n    offsetVec = mix(perp * sideOfPath, dir * path.capType * 4.0 * flipIfTrue(isStartCap), isJoint);\n    vJointType = path.capType;\n  } else {\n    vJointType = path.jointType;\n  }\n\n  // Generate variables for fragment shader\n  vPathLength = L;\n  vCornerOffset = offsetVec;\n  vMiterLength = dot(vCornerOffset, miterVec * turnDirection);\n  vMiterLength = isCap ? isJoint : vMiterLength;\n\n  vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);\n  vPathPosition = vec2(\n    dot(offsetFromStartOfPath, perp),\n    dot(offsetFromStartOfPath, dir)\n  );\n  geometry.uv = vPathPosition;\n\n  float isValid = step(instanceTypes, 3.5);\n  vec3 offset = vec3(offsetVec * width * isValid, 0.0);\n\n  if (needsRotation) {\n    offset = rotationMatrix * offset;\n  }\n  return offset;\n}\n\n// In clipspace extrusion, if a line extends behind the camera, clip it to avoid visual artifacts\nvoid clipLine(inout vec4 position, vec4 refPosition) {\n  if (position.w < EPSILON) {\n    float r = (EPSILON - refPosition.w) / (position.w - refPosition.w);\n    position = refPosition + (position - refPosition) * r;\n  }\n}\n\nvoid main() {\n  geometry.pickingColor = instancePickingColors;\n\n  vColor = vec4(instanceColors.rgb, instanceColors.a * polylines.opacity);\n  vec3 leftPosition  = instanceLeftPositions;\n  vec3 startPosition = instanceStartPositions;\n  vec3 leftPos64Low  = instanceLeftPositions64Low;\n  vec3 startPos64Low = instanceStartPositions64Low;\n\n  vec3 rightposition = instanceRightPositions;\n  vec3 endPosition   = instanceEndPositions;\n  vec3 rightPos64Low = instanceRightPositions64Low;\n  vec3 endPos64Low   = instanceEndPositions64Low;\n\n  if(polylines.ZIncreasingDownwards) {\n    leftPosition.z *= -1.0;\n    startPosition.z *= -1.0;\n    leftPos64Low.z  *= -1.0;\n    startPos64Low.z *= -1.0;\n    rightposition.z *= -1.0;\n    endPosition.z   *= -1.0;\n    rightPos64Low.z *= -1.0;\n    endPos64Low.z   *= -1.0; \n  }\n\n  float isEnd = positions.x;\n\n  vec3 prevPosition = mix(leftPosition, startPosition, isEnd);\n  vec3 prevPosition64Low = mix(leftPos64Low, startPos64Low, isEnd);\n\n  vec3 currPosition = mix(startPosition, endPosition, isEnd);\n  vec3 currPosition64Low = mix(startPos64Low, endPos64Low, isEnd);\n\n  vec3 nextPosition = mix(endPosition, rightposition, isEnd);\n  vec3 nextPosition64Low = mix(endPos64Low, rightPos64Low, isEnd);\n\n  geometry.worldPosition = currPosition;\n  vec2 widthPixels = vec2(clamp(\n    project_size_to_pixel(instanceStrokeWidths * path.widthScale, path.widthUnits),\n    path.widthMinPixels, path.widthMaxPixels) / 2.0);\n  vec3 width;\n\n  if (path.billboard) {\n    // Extrude in clipspace\n    vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);\n    vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);\n    vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);\n\n    clipLine(prevPositionScreen, currPositionScreen);\n    clipLine(nextPositionScreen, currPositionScreen);\n    clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd));\n\n    width = vec3(widthPixels, 0.0);\n    DECKGL_FILTER_SIZE(width, geometry);\n\n    vec3 offset = getLineJoinOffset(\n      prevPositionScreen.xyz / prevPositionScreen.w,\n      currPositionScreen.xyz / currPositionScreen.w,\n      nextPositionScreen.xyz / nextPositionScreen.w,\n      project_pixel_size_to_clipspace(width.xy)\n    );\n\n    DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);\n    gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);\n  } else {\n    // Extrude in commonspace\n    prevPosition = project_position(prevPosition, prevPosition64Low);\n    currPosition = project_position(currPosition, currPosition64Low);\n    nextPosition = project_position(nextPosition, nextPosition64Low);\n\n    width = vec3(project_pixel_size(widthPixels), 0.0);\n    DECKGL_FILTER_SIZE(width, geometry);\n\n    vec3 offset = getLineJoinOffset(prevPosition, currPosition, nextPosition, width.xy);\n    geometry.position = vec4(currPosition + offset, 1.0);\n    gl_Position = project_common_position_to_clipspace(geometry.position);\n    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n  }\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n";
 export default _default;

package/dist/layers/polylines/path-layer-vertex.glsl.js

@@ -19,7 +19,7 @@
 // THE SOFTWARE.
 export default `\
 #version 300 es
-#define SHADER_NAME path-layer-vertex-shader
+#define SHADER_NAME polylines-vertex-shader
 
 in vec2 positions;
 
@@ -36,18 +36,6 @@ in float instanceStrokeWidths;
 in vec4 instanceColors;
 in vec3 instancePickingColors;
 
-uniform float widthScale;
-uniform float widthMinPixels;
-uniform float widthMaxPixels;
-uniform float jointType;
-uniform float capType;
-uniform float miterLimit;
-uniform bool billboard;
-uniform int widthUnits;
-
-uniform float opacity;
-uniform bool ZIncreasingDownwards;
-
 out vec4 vColor;
 out vec2 vCornerOffset;
 out float vMiterLength;
@@ -76,7 +64,7 @@ vec3 getLineJoinOffset(
   vec3 deltaB3 = (nextPoint - currPoint);
 
   mat3 rotationMatrix;
-  bool needsRotation = !billboard && project_needs_rotation(currPoint, rotationMatrix);
+  bool needsRotation = !path.billboard && project_needs_rotation(currPoint, rotationMatrix);
   if (needsRotation) {
     deltaA3 = deltaA3 * rotationMatrix;
     deltaB3 = deltaB3 * rotationMatrix;
@@ -136,10 +124,10 @@ vec3 getLineJoinOffset(
 
   // extend out a triangle to envelope the round cap
   if (isCap) {
-    offsetVec = mix(perp * sideOfPath, dir * capType * 4.0 * flipIfTrue(isStartCap), isJoint);
-    vJointType = capType;
+    offsetVec = mix(perp * sideOfPath, dir * path.capType * 4.0 * flipIfTrue(isStartCap), isJoint);
+    vJointType = path.capType;
   } else {
-    vJointType = jointType;
+    vJointType = path.jointType;
   }
 
   // Generate variables for fragment shader
@@ -175,7 +163,7 @@ void clipLine(inout vec4 position, vec4 refPosition) {
 void main() {
   geometry.pickingColor = instancePickingColors;
 
-  vColor = vec4(instanceColors.rgb, instanceColors.a * opacity);
+  vColor = vec4(instanceColors.rgb, instanceColors.a * polylines.opacity);
   vec3 leftPosition  = instanceLeftPositions;
   vec3 startPosition = instanceStartPositions;
   vec3 leftPos64Low  = instanceLeftPositions64Low;
@@ -186,7 +174,7 @@ void main() {
   vec3 rightPos64Low = instanceRightPositions64Low;
   vec3 endPos64Low   = instanceEndPositions64Low;
 
-  if(ZIncreasingDownwards) {
+  if(polylines.ZIncreasingDownwards) {
     leftPosition.z *= -1.0;
     startPosition.z *= -1.0;
     leftPos64Low.z  *= -1.0;
@@ -210,11 +198,11 @@ void main() {
 
   geometry.worldPosition = currPosition;
   vec2 widthPixels = vec2(clamp(
-    project_size_to_pixel(instanceStrokeWidths * widthScale, widthUnits),
-    widthMinPixels, widthMaxPixels) / 2.0);
+    project_size_to_pixel(instanceStrokeWidths * path.widthScale, path.widthUnits),
+    path.widthMinPixels, path.widthMaxPixels) / 2.0);
   vec3 width;
 
-  if (billboard) {
+  if (path.billboard) {
     // Extrude in clipspace
     vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);
     vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);

package/dist/layers/polylines/path-layer-vertex.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"path-layer-vertex.glsl.js","sourceRoot":"","sources":["../../../src/layers/polylines/path-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Od,CAAC"}
+{"version":3,"file":"path-layer-vertex.glsl.js","sourceRoot":"","sources":["../../../src/layers/polylines/path-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,6EAA6E;AAC7E,sDAAsD;AACtD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,gBAAgB;AAEhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Nd,CAAC"}

package/dist/layers/polylines/privatePolylinesLayer.d.ts

@@ -1,53 +1,11 @@
 import type { PathLayerProps } from "@deck.gl/layers";
 import { PathLayer } from "@deck.gl/layers";
-import type { NumericArray } from "@math.gl/types";
-import type { LayerContext } from "@deck.gl/core";
-type UniformValue = number | boolean | Readonly<NumericArray>;
 export interface ExtendedPathLayerProps {
     depthTest?: boolean;
     ZIncreasingDownwards: boolean;
 }
 export declare class PrivatePolylinesLayer extends PathLayer<unknown, ExtendedPathLayerProps> {
     constructor(props: PathLayerProps);
-    getShaders(): {
-        vs: string;
-        fs: string;
-        modules: (import("@luma.gl/shadertools").ShaderModule | {
-            defaultUniforms: {
-                useFloatColors: boolean;
-                isActive?: boolean | undefined;
-                isAttribute?: boolean | undefined;
-                isHighlightActive?: boolean | undefined;
-                highlightedObjectColor?: import("@luma.gl/shadertools/dist/lib/utils/uniform-types").NumberArray3 | undefined;
-                highlightColor?: import("@luma.gl/shadertools/dist/lib/utils/uniform-types").NumberArray4 | undefined;
-            };
-            inject: {
-                'vs:DECKGL_FILTER_GL_POSITION': string;
-                'vs:DECKGL_FILTER_COLOR': string;
-                'fs:DECKGL_FILTER_COLOR': {
-                    order: number;
-                    injection: string;
-                };
-            };
-            props?: Required<import("@luma.gl/shadertools").PickingProps> | undefined;
-            uniforms?: import("@luma.gl/shadertools/dist/modules/engine/picking/picking").PickingUniforms | undefined;
-            bindings?: import("@luma.gl/shadertools/dist/lib/shader-module/shader-module").PickBindings<import("@luma.gl/shadertools").PickingProps> | undefined;
-            name: string;
-            fs?: string | undefined;
-            vs?: string | undefined;
-            uniformTypes?: Required<import("@luma.gl/shadertools/dist/lib/utils/uniform-types").UniformTypes<import("@luma.gl/shadertools/dist/modules/engine/picking/picking").PickingUniforms>> | undefined;
-            uniformPropTypes?: Record<keyof import("@luma.gl/shadertools/dist/modules/engine/picking/picking").PickingUniforms, import("@luma.gl/shadertools/dist/lib/shader-module/shader-module").UniformInfo> | undefined;
-            getUniforms?: ((props?: Partial<import("@luma.gl/shadertools").PickingProps> | undefined, prevUniforms?: import("@luma.gl/shadertools/dist/modules/engine/picking/picking").PickingUniforms | undefined) => Partial<import("@luma.gl/shadertools/dist/modules/engine/picking/picking").PickingUniforms & import("@luma.gl/shadertools/dist/lib/shader-module/shader-module").PickBindings<import("@luma.gl/shadertools").PickingProps>>) | undefined;
-            defines?: Record<string, string | number> | undefined;
-            dependencies?: import("@luma.gl/shadertools").ShaderModule<any, any, import("@luma.gl/shadertools/dist/lib/shader-module/shader-module").PickBindings<any>>[] | undefined;
-            deprecations?: import("@luma.gl/shadertools/dist/lib/shader-module/shader-module").ShaderModuleDeprecation[] | undefined;
-            normalized?: boolean | undefined;
-        })[];
-    };
-    draw(args: {
-        moduleParameters?: unknown;
-        uniforms: Record<string, UniformValue>;
-        context: LayerContext;
-    }): void;
+    getShaders(): any;
+    draw(args: any): void;
 }
-export {};

package/dist/layers/polylines/privatePolylinesLayer.js

@@ -1,5 +1,4 @@
 import { PathLayer } from "@deck.gl/layers";
-import { picking, project32 } from "@deck.gl/core";
 import fs from "./path-layer-fragment.glsl";
 import vs from "./path-layer-vertex.glsl";
 export class PrivatePolylinesLayer extends PathLayer {
@@ -7,10 +6,18 @@ export class PrivatePolylinesLayer extends PathLayer {
         super(props);
     }
     getShaders() {
-        return { vs, fs, modules: [project32, picking] };
+        const superShaders = super.getShaders();
+        // use object.assign to make sure we don't overwrite existing fields like `vs`, `modules`...
+        return Object.assign({}, superShaders, {
+            vs: vs,
+            fs: fs,
+            modules: [...superShaders.modules, polylinesUniforms],
+        });
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     draw(args) {
-        args.uniforms["ZIncreasingDownwards"] = this.props.ZIncreasingDownwards;
+        var _a;
+        //conf g = context.device.getDefaultCanvasContext();
         const { gl } = this.context;
         let restoreDepthTest = false;
         if (typeof this.props.depthTest === "boolean" &&
@@ -18,11 +25,34 @@ export class PrivatePolylinesLayer extends PathLayer {
             restoreDepthTest = true;
             gl.disable(gl.DEPTH_TEST);
         }
-        super.draw({ uniforms: args.uniforms });
+        // inject the local uniforms into the shader
+        (_a = this.state.model) === null || _a === void 0 ? void 0 : _a.shaderInputs.setProps({
+            polylines: {
+                opacity: this.props.opacity,
+                ZIncreasingDownwards: this.props.ZIncreasingDownwards,
+            },
+        });
+        super.draw(args.uniforms);
         if (restoreDepthTest) {
             gl.enable(gl.DEPTH_TEST);
         }
     }
 }
 PrivatePolylinesLayer.layerName = "PrivatePolylinesLayer";
+const polylinesUniformsBlock = /*glsl*/ `\
+uniform polylinesUniforms {
+    float opacity;
+    bool ZIncreasingDownwards;
+} polylines;
+`;
+// NOTE: this must exactly the same name than in the uniform block
+const polylinesUniforms = {
+    name: "polylines",
+    vs: polylinesUniformsBlock,
+    fs: undefined,
+    uniformTypes: {
+        opacity: "f32",
+        ZIncreasingDownwards: "u32",
+    },
+};
 //# sourceMappingURL=privatePolylinesLayer.js.map

package/dist/layers/polylines/privatePolylinesLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"privatePolylinesLayer.js","sourceRoot":"","sources":["../../../src/layers/polylines/privatePolylinesLayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC5C,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAS1C,MAAM,OAAO,qBAAsB,SAAQ,SAG1C;IACG,YAAY,KAAqB;QAC7B,KAAK,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED,UAAU;QACN,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC;IACrD,CAAC;IAED,IAAI,CAAC,IAIJ;QACG,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC;QAExE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAE5B,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IACI,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS;YACzC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EACvB,CAAC;YACC,gBAAgB,GAAG,IAAI,CAAC;YACxB,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC9B,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxC,IAAI,gBAAgB,EAAE,CAAC;YACnB,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;CACJ;AAED,qBAAqB,CAAC,SAAS,GAAG,uBAAuB,CAAC"}
+{"version":3,"file":"privatePolylinesLayer.js","sourceRoot":"","sources":["../../../src/layers/polylines/privatePolylinesLayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC5C,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAO1C,MAAM,OAAO,qBAAsB,SAAQ,SAG1C;IACG,YAAY,KAAqB;QAC7B,KAAK,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED,UAAU;QACN,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACxC,4FAA4F;QAC5F,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE;YACnC,EAAE,EAAE,EAAE;YACN,EAAE,EAAE,EAAE;YACN,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,OAAO,EAAE,iBAAiB,CAAC;SACxD,CAAC,CAAC;IACP,CAAC;IAED,8DAA8D;IAC9D,IAAI,CAAC,IAAS;;QACV,oDAAoD;QACpD,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAE5B,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IACI,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS;YACzC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EACvB,CAAC;YACC,gBAAgB,GAAG,IAAI,CAAC;YACxB,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC9B,CAAC;QACD,4CAA4C;QAC5C,MAAA,IAAI,CAAC,KAAK,CAAC,KAAK,0CAAE,YAAY,CAAC,QAAQ,CAAC;YACpC,SAAS,EAAE;gBACP,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO;gBAC3B,oBAAoB,EAAE,IAAI,CAAC,KAAK,CAAC,oBAAoB;aACxD;SACJ,CAAC,CAAC;QACH,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,IAAI,gBAAgB,EAAE,CAAC;YACnB,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;CACJ;AAED,qBAAqB,CAAC,SAAS,GAAG,uBAAuB,CAAC;AAE1D,MAAM,sBAAsB,GAAG,QAAQ,CAAC;;;;;CAKvC,CAAC;AAOF,kEAAkE;AAClE,MAAM,iBAAiB,GAAG;IACtB,IAAI,EAAE,WAAW;IACjB,EAAE,EAAE,sBAAsB;IAC1B,EAAE,EAAE,SAAS;IACb,YAAY,EAAE;QACV,OAAO,EAAE,KAAK;QACd,oBAAoB,EAAE,KAAK;KAC9B;CAC+D,CAAC"}

package/dist/layers/shader_modules/index.d.ts

@@ -1,3 +1,3 @@
 export { decoder } from "./decoder";
-export { localPhongLighting } from "./localPhongLighting";
 export { utilities } from "./utilities";
+export { phongMaterial } from "./phong-lighting/phong-material";

package/dist/layers/shader_modules/index.js

@@ -1,4 +1,4 @@
 export { decoder } from "./decoder";
-export { localPhongLighting } from "./localPhongLighting";
 export { utilities } from "./utilities";
+export { phongMaterial } from "./phong-lighting/phong-material";
 //# sourceMappingURL=index.js.map

package/dist/layers/shader_modules/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/layers/shader_modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/layers/shader_modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/layers/shader_modules/phong-lighting/phong-material.d.ts

@@ -0,0 +1,11 @@
+import type { NumberArray3 } from "@math.gl/types";
+import type { ShaderModule } from "@luma.gl/shadertools";
+export type PhongMaterialProps = {
+    ambient?: number;
+    diffuse?: number;
+    /** Specularity exponent */
+    shininess?: number;
+    specularColor?: NumberArray3;
+};
+/** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
+export declare const phongMaterial: ShaderModule<PhongMaterialProps>;

package/dist/layers/shader_modules/phong-lighting/phong-material.js

@@ -0,0 +1,38 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { lighting } from "@luma.gl/shadertools";
+import { PHONG_VS, PHONG_FS } from "./phong-shaders-glsl";
+/** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
+export const phongMaterial = {
+    name: "phongMaterial",
+    dependencies: [lighting],
+    // Note these are switched between phong and gouraud
+    vs: PHONG_VS,
+    fs: PHONG_FS,
+    defines: {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        LIGHTING_FRAGMENT: true,
+    },
+    uniformTypes: {
+        ambient: "f32",
+        diffuse: "f32",
+        shininess: "f32",
+        specularColor: "vec3<f32>",
+    },
+    defaultUniforms: {
+        ambient: 0.35,
+        diffuse: 0.6,
+        shininess: 32,
+        specularColor: [0.15, 0.15, 0.15],
+    },
+    getUniforms(props) {
+        const uniforms = Object.assign({}, props);
+        if (uniforms.specularColor) {
+            uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+        }
+        return Object.assign(Object.assign({}, phongMaterial.defaultUniforms), uniforms);
+    },
+};
+//# sourceMappingURL=phong-material.js.map

package/dist/layers/shader_modules/phong-lighting/phong-material.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phong-material.js","sourceRoot":"","sources":["../../../../src/layers/shader_modules/phong-lighting/phong-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AASpC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAU1D,wIAAwI;AACxI,MAAM,CAAC,MAAM,aAAa,GAAqC;IAC3D,IAAI,EAAE,eAAe;IACrB,YAAY,EAAE,CAAC,QAAQ,CAAC;IACxB,oDAAoD;IACpD,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,QAAQ;IACZ,OAAO,EAAE;QACL,6DAA6D;QAC7D,mBAAmB;QACnB,iBAAiB,EAAE,IAAI;KAC1B;IACD,YAAY,EAAE;QACV,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC7B;IACD,eAAe,EAAE;QACb,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;KACpC;IACD,WAAW,CAAC,KAA0B;QAClC,MAAM,QAAQ,qBAAQ,KAAK,CAAE,CAAC;QAC9B,IAAI,QAAQ,CAAC,aAAa,EAAE,CAAC;YACzB,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAC/C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,GAAG,CACD,CAAC;QACtB,CAAC;QACD,uCAAY,aAAa,CAAC,eAAe,GAAK,QAAQ,EAAG;IAC7D,CAAC;CACJ,CAAC"}

package/dist/layers/shader_modules/phong-lighting/phong-shaders-glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const PHONG_VS = "uniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
+export declare const PHONG_FS = "\nuniform phongMaterialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\n// Note modified for two sided lighing.\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction); \n\n  float lambertian = abs(dot(light_direction, normal_worldspace));\n  float specular_angle = abs(dot(normal_worldspace, halfway_direction));\n\n  float specular = pow(specular_angle, material.shininess);       \n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  for (int i = 0; i < lighting.pointLightCount; i++) {\n    PointLight pointLight = lighting_getPointLight(i);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);\n  }\n\n  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);\n  for (int i = lighting.pointLightCount; i < totalLights; i++) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n}\n";