@webviz/subsurface-viewer 1.11.0 → 1.11.2

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";

package/dist/layers/shader_modules/phong-lighting/phong-shaders-glsl.js

@@ -0,0 +1,59 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const PHONG_VS = /* glsl */ `\
+uniform phongMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+`;
+export const PHONG_FS = /* glsl */ `\
+
+uniform phongMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+
+// Note modified for two sided lighing.
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
+  vec3 halfway_direction = normalize(light_direction + view_direction); 
+
+  float lambertian = abs(dot(light_direction, normal_worldspace));
+  float specular_angle = abs(dot(normal_worldspace, halfway_direction));
+
+  float specular = pow(specular_angle, material.shininess);       
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+}
+`;
+//# sourceMappingURL=phong-shaders-glsl.js.map

package/dist/layers/shader_modules/phong-lighting/phong-shaders-glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phong-shaders-glsl.js","sourceRoot":"","sources":["../../../../src/layers/shader_modules/phong-lighting/phong-shaders-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;CAOlC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ClC,CAAC"}

package/dist/layers/triangle/fragment.fs.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const fsShader = "#version 300 es\n#define SHADER_NAME terrainmap-shader\n\nprecision highp float;\n\nuniform bool isContoursDepth;\nuniform float contourReferencePoint;\nuniform float contourInterval;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec3 worldPos;\nin float property;\n\nuniform vec4 uColor;\nuniform bool smoothShading;\n\nout vec4 fragColor;\n\nvoid main(void) {\n   vec3 normal = normals_commonspace;\n\n   if (!smoothShading) {\n      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n   } \n\n   vec4 color = uColor;\n   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;\n   if (is_contours) {\n      // Contours are made of either depths or properties.\n      float val = (abs(worldPos.z) - contourReferencePoint) / contourInterval;\n\n      float f  = fract(val);\n      float df = fwidth(val);\n\n      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.\n      float c = smoothstep(0.0, df * 2.0, f);\n\n      color = color * vec4(c, c, c, 1.0);\n   }\n\n   // Use two sided phong lighting. This has no effect if \"material\" property is not set.\n   vec3 lightColor = getPhongLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n   fragColor = vec4(lightColor, 1.0);\n   DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
+declare const fsShader = "#version 300 es\n#define SHADER_NAME triangle-fragment-shader\n\nprecision highp float;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec3 worldPos;\nin float property;\n\nout vec4 fragColor;\n\nvoid main(void) {\n   vec3 normal = normals_commonspace;\n\n   if (!triangles.smoothShading) {\n      normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n   } \n\n   vec4 color = triangles.uColor;\n   bool is_contours = triangles.contourReferencePoint != -1.0 && triangles.contourInterval != -1.0;\n   if (is_contours) {\n      // Contours are made of either depths or properties.\n      float val = (abs(worldPos.z) - triangles.contourReferencePoint) / triangles.contourInterval;\n\n      float f  = fract(val);\n      float df = fwidth(val);\n\n      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smoothstep from/to no of pixels distance from contour line.\n      float c = smoothstep(0.0, df * 2.0, f);\n\n      color = color * vec4(c, c, c, 1.0);\n   }\n\n   // Use two sided phong lighting. This has no effect if \"material\" property is not set.\n   vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n   fragColor = vec4(lightColor, 1.0);\n   DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
 export default fsShader;

package/dist/layers/triangle/fragment.fs.glsl.js

@@ -1,12 +1,8 @@
 const fsShader = `#version 300 es
-#define SHADER_NAME terrainmap-shader
+#define SHADER_NAME triangle-fragment-shader
 
 precision highp float;
 
-uniform bool isContoursDepth;
-uniform float contourReferencePoint;
-uniform float contourInterval;
-
 in vec2 vTexCoord;
 in vec3 cameraPosition;
 in vec3 normals_commonspace;
@@ -14,35 +10,32 @@ in vec4 position_commonspace;
 in vec3 worldPos;
 in float property;
 
-uniform vec4 uColor;
-uniform bool smoothShading;
-
 out vec4 fragColor;
 
 void main(void) {
    vec3 normal = normals_commonspace;
 
-   if (!smoothShading) {
+   if (!triangles.smoothShading) {
       normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
    } 
 
-   vec4 color = uColor;
-   bool is_contours = contourReferencePoint != -1.0 && contourInterval != -1.0;
+   vec4 color = triangles.uColor;
+   bool is_contours = triangles.contourReferencePoint != -1.0 && triangles.contourInterval != -1.0;
    if (is_contours) {
       // Contours are made of either depths or properties.
-      float val = (abs(worldPos.z) - contourReferencePoint) / contourInterval;
+      float val = (abs(worldPos.z) - triangles.contourReferencePoint) / triangles.contourInterval;
 
       float f  = fract(val);
       float df = fwidth(val);
 
-      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smootstep from/to no of pixels distance fronm contour line.
+      // keep: float c = smoothstep(df * 1.0, df * 2.0, f); // smoothstep from/to no of pixels distance from contour line.
       float c = smoothstep(0.0, df * 2.0, f);
 
       color = color * vec4(c, c, c, 1.0);
    }
 
    // Use two sided phong lighting. This has no effect if "material" property is not set.
-   vec3 lightColor = getPhongLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+   vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
    fragColor = vec4(lightColor, 1.0);
    DECKGL_FILTER_COLOR(fragColor, geometry);
 }

package/dist/layers/triangle/fragment.fs.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fragment.fs.glsl.js","sourceRoot":"","sources":["../../../src/layers/triangle/fragment.fs.glsl.ts"],"names":[],"mappings":"AAAA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDhB,CAAC;AAEF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"fragment.fs.glsl.js","sourceRoot":"","sources":["../../../src/layers/triangle/fragment.fs.glsl.ts"],"names":[],"mappings":"AAAA,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyChB,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/dist/layers/triangle/fragment_lines.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const fragmentShader = "#version 300 es\n#define SHADER_NAME graph-layer-fragment-shader\n\nprecision highp float;\n\nout vec4 fragColor;\n\nvoid main(void) {\n\n  // Picking pass.\n  if (picking.isActive > 0.5) {\n    discard;\n    return;\n  }\n\n  fragColor = vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+declare const fragmentShader = "#version 300 es\n#define SHADER_NAME triangle-lines-fragment-shader\n\nprecision highp float;\n\nout vec4 fragColor;\n\nvoid main(void) {\n\n  // Picking pass.\n  if (picking.isActive > 0.5) {\n    discard;\n    return;\n  }\n\n  fragColor = vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
 export default fragmentShader;

package/dist/layers/triangle/fragment_lines.glsl.js

@@ -1,6 +1,6 @@
 const fragmentShader = `\
 #version 300 es
-#define SHADER_NAME graph-layer-fragment-shader
+#define SHADER_NAME triangle-lines-fragment-shader
 
 precision highp float;
 

package/dist/layers/triangle/privateTriangleLayer.d.ts

@@ -1,7 +1,8 @@
-import type { LayerContext, PickingInfo, UpdateParameters } from "@deck.gl/core";
+import type { PickingInfo, UpdateParameters } from "@deck.gl/core";
 import { Layer } from "@deck.gl/core";
 import type { GeometryProps } from "@luma.gl/engine";
-import type { Device, UniformValue } from "@luma.gl/core";
+import { Model } from "@luma.gl/engine";
+import type { Device } from "@luma.gl/core";
 import type { DeckGLLayerContext } from "../../components/Map";
 import type { ExtendedLayerProps, LayerPickInfo } from "../utils/layerTools";
 export type GeometryTriangles = {
@@ -40,12 +41,6 @@ export type GeometryLines = {
     };
     vertexCount: number;
 };
-export type Material = {
-    ambient: number;
-    diffuse: number;
-    shininess: number;
-    specularColor: [number, number, number];
-} | boolean;
 export interface PrivateTriangleLayerProps extends ExtendedLayerProps {
     geometryTriangles: GeometryTriangles;
     geometryLines: GeometryLines;
@@ -55,18 +50,18 @@ export interface PrivateTriangleLayerProps extends ExtendedLayerProps {
     smoothShading: boolean;
     depthTest: boolean;
     ZIncreasingDownwards: boolean;
+    enableLighting: boolean;
 }
 export default class PrivateTriangleLayer extends Layer<PrivateTriangleLayerProps> {
     get isLoaded(): boolean;
+    setShaderModuleProps(args: Partial<{
+        [x: string]: Partial<Record<string, unknown> | undefined>;
+    }>): void;
     initializeState(context: DeckGLLayerContext): void;
     shouldUpdateState({ props, oldProps, context, changeFlags, }: UpdateParameters<this>): boolean;
     updateState({ context }: UpdateParameters<this>): void;
-    _getModels(device: Device): [unknown, unknown];
-    draw(args: {
-        moduleParameters?: unknown;
-        uniforms: UniformValue;
-        context: LayerContext;
-    }): void;
+    _getModels(device: Device): [Model, Model];
+    draw(args: any): void;
     decodePickingColor(): number;
     getPickingInfo({ info }: {
         info: PickingInfo;