Use UBOs in project module

docs/api-reference/core/project.md

@@ -151,6 +151,6 @@ Returns a matrix that rotates any vector defined in the default common space to
 
 ## Remarks
 
-* For consistent results, the screen space pixels are logical pixels, not device pixels, i.e. functions in the project module multiply `pixels` with `project_uDevicePixelRatio`.
+* For consistent results, the screen space pixels are logical pixels, not device pixels, i.e. functions in the project module multiply `pixels` with `project.devicePixelRatio`.
 * The pixels offsets will be divided by the `w` coordinate of `gl_Position`. This is simply the GPUs standard treatment of any coordinate. This means that there will be more pixels closer to the camera and less pixels further away from the camer. Setting the `focalDistance` uniform controls this.
 * To avoid pixel sizes scaling with distance from camera, simply set `focalDistance` to 1 and multiply clipspace offset with `gl_Position.w`

docs/api-reference/core/project64.md

@@ -5,7 +5,7 @@ The `project64` shader module is an extension of the [project](./project.md) sha
 
 ## getUniforms
 
-The uniforms needed by `project64` are extracted from the `project` module uniforms `project_uViewProjectionMatrix` and `project_uScale`.
+The uniforms needed by `project64` are extracted from the `project` module uniforms `project.viewProjectionMatrix` and `project.scale`.
 
 
 ## GLSL Uniforms

docs/developer-guide/custom-layers/subclassed-layers.md

@@ -225,7 +225,7 @@ void main(void) {
   /* replaced uniform 'radiusPixels' with 'instanceRadiusPixels' */
   gl_Position.xy += project_pixel_size_to_clipspace(positions.xy * instanceRadiusPixels);
 
-  vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project_uCameraPosition, position_commonspace.xyz, project_normal(instanceNormals));
+  vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project.cameraPosition, position_commonspace.xyz, project_normal(instanceNormals));
 
   vColor = vec4(lightColor, instanceColors.a * opacity) / 255.0;
 

examples/experimental/bezier/src/bezier-curve-layer/bezier-curve-layer-vertex.glsl.js

@@ -39,7 +39,7 @@ out vec4 vColor;
 // offset_direction is -1 (left) or 1 (right)
 vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction) {
   // normalized direction of the line
-  vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize);
+  vec2 dir_screenspace = normalize(line_clipspace * project.viewportSize);
   // rotate by 90 degrees
   dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
 

examples/website/plot/plot-layer/grid-vertex.glsl.ts

@@ -38,7 +38,7 @@ out float shouldDiscard;
 
 // determines if the grid line is behind or in front of the center
 float frontFacing(vec3 v) {
-  vec4 v_clipspace = project_uViewProjectionMatrix * project_uModelMatrix * vec4(v, 0.0);
+  vec4 v_clipspace = project.viewProjectionMatrix * project.modelMatrix * vec4(v, 0.0);
   return step(v_clipspace.z, 0.0);
 }
 

examples/website/plot/plot-layer/label-vertex.glsl.ts

@@ -50,7 +50,7 @@ float sum3(vec3 v) {
 
 // determines if the grid line is behind or in front of the center
 float frontFacing(vec3 v) {
-  vec4 v_clipspace = project_uViewProjectionMatrix * project_uModelMatrix * vec4(v, 0.0);
+  vec4 v_clipspace = project.viewProjectionMatrix * project.modelMatrix * vec4(v, 0.0);
   return step(v_clipspace.z, 0.0);
 }
 

modules/aggregation-layers/src/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.ts

@@ -134,7 +134,7 @@ void main(void) {
   vec3 normals_commonspace = project_normal(normals);
 
    if (extruded) {
-    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);
+    vec3 lightColor = lighting_getLightColor(color.rgb, project.cameraPosition, geometry.position.xyz, normals_commonspace);
     vColor = vec4(lightColor, color.a * opacity) / 255.;
   } else {
     vColor = vec4(color.rgb, color.a * opacity) / 255.;

modules/aggregation-layers/src/screen-grid-layer/screen-grid-cell-layer.ts

@@ -20,7 +20,15 @@
 
 import {Texture} from '@luma.gl/core';
 import {Model, Geometry} from '@luma.gl/engine';
-import {Layer, LayerProps, log, picking, UpdateParameters, DefaultProps} from '@deck.gl/core';
+import {
+  Layer,
+  LayerProps,
+  log,
+  project32,
+  picking,
+  UpdateParameters,
+  DefaultProps
+} from '@deck.gl/core';
 import {defaultColorRange, colorRangeToFlatArray} from '../utils/color-utils';
 import vs from './screen-grid-layer-vertex.glsl';
 import fs from './screen-grid-layer-fragment.glsl';
@@ -59,7 +67,7 @@ export default class ScreenGridCellLayer<DataT = any, ExtraPropsT extends {} = {
   };
 
   getShaders(): {vs: string; fs: string; modules: ShaderModule[]} {
-    return {vs, fs, modules: [picking as ShaderModule]};
+    return {vs, fs, modules: [project32, picking]};
   }
 
   initializeState() {

modules/carto/src/layers/raster-layer-vertex.glsl.ts

@@ -46,8 +46,8 @@ void main(void) {
   // Important to set geometry.position before using project_ methods below
   // as geometry.worldPosition is not set (we don't know our lat/long)
   geometry.position = vec4(common_position, 0.0, 1.0);
-  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-    geometry.position.xyz -= project_uCommonOrigin;
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+    geometry.position.xyz -= project.commonOrigin;
   }
 
   // calculate elevation, if 3d not enabled set to 0
@@ -86,7 +86,7 @@ void main(void) {
     position_commonspace = geometry.position;
     vColor = vec4(color.rgb, color.a * opacity);
 #else
-    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
+    vec3 lightColor = lighting_getLightColor(color.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
     vColor = vec4(lightColor, color.a * opacity);
 #endif
   } else {

modules/core/src/effects/lighting/camera-light.ts

@@ -8,15 +8,15 @@ export default class CameraLight extends PointLight {
     const {projectedLight} = this;
     const viewport = layer.context.viewport;
     const {coordinateSystem, coordinateOrigin, modelMatrix} = layer.props;
-    const {project_uCameraPosition} = getUniformsFromViewport({
+    const {cameraPosition} = getUniformsFromViewport({
       viewport,
       modelMatrix,
       coordinateSystem,
       coordinateOrigin
     });
     projectedLight.color = this.color;
     projectedLight.intensity = this.intensity;
-    projectedLight.position = project_uCameraPosition;
+    projectedLight.position = cameraPosition;
     return projectedLight;
   }
 }

modules/core/src/lib/layer.ts

@@ -1065,8 +1065,12 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
       // TODO/ib - hack move to luma Model.draw
       if (moduleParameters) {
         const {isActive, isAttribute} = moduleParameters.picking;
+        const {viewport, devicePixelRatio, coordinateSystem, coordinateOrigin} = moduleParameters;
         this.setModuleParameters(moduleParameters);
-        this.setShaderModuleProps({picking: {isActive, isAttribute}});
+        this.setShaderModuleProps({
+          picking: {isActive, isAttribute},
+          project32: {viewport, devicePixelRatio, coordinateSystem, coordinateOrigin}
+        });
       }
 
       // Apply polygon offset to avoid z-fighting

modules/core/src/shaderlib/project/project.glsl.ts

@@ -36,23 +36,28 @@ ${COORDINATE_SYSTEM_GLSL_CONSTANTS}
 ${PROJECTION_MODE_GLSL_CONSTANTS}
 ${UNIT_GLSL_CONSTANTS}
 
-uniform int project_uCoordinateSystem;
-uniform int project_uProjectionMode;
-uniform float project_uScale;
-uniform bool project_uWrapLongitude;
-uniform vec3 project_uCommonUnitsPerMeter;
-uniform vec3 project_uCommonUnitsPerWorldUnit;
-uniform vec3 project_uCommonUnitsPerWorldUnit2;
-uniform vec4 project_uCenter;
-uniform mat4 project_uModelMatrix;
-uniform mat4 project_uViewProjectionMatrix;
-uniform vec2 project_uViewportSize;
-uniform float project_uDevicePixelRatio;
-uniform float project_uFocalDistance;
-uniform vec3 project_uCameraPosition;
-uniform vec3 project_uCoordinateOrigin;
-uniform vec3 project_uCommonOrigin;
-uniform bool project_uPseudoMeters;
+uniform project32Uniforms {
+  bool autoWrapLongitude;
+  int coordinateSystem;
+  vec3 commonUnitsPerMeter;
+  int projectionMode;
+  float scale;
+
+  vec3 commonUnitsPerWorldUnit;
+  vec3 commonUnitsPerWorldUnit2;
+  vec4 center;
+  mat4 modelMatrix;
+  mat4 viewProjectionMatrix;
+  vec2 viewportSize;
+  float devicePixelRatio;
+  float focalDistance;
+  vec3 cameraPosition;
+  vec3 coordinateOrigin;
+  vec3 commonOrigin;
+  bool pseudoMeters;
+} project;
+
+
 
 const float TILE_SIZE = 512.0;
 const float PI = 3.1415926536;
@@ -68,9 +73,9 @@ float project_size_at_latitude(float lat) {
 }
 
 float project_size() {
-  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR &&
-    project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
-    project_uPseudoMeters == false) {
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&
+    project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
+    project.pseudoMeters == false) {
 
     // uCommonUnitsPerMeter in low-zoom Web Mercator is non-linear
     // Adjust by 1 / cos(latitude)
@@ -95,27 +100,28 @@ float project_size() {
 }
 
 float project_size_at_latitude(float meters, float lat) {
-  return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude(lat);
+  return meters * project.commonUnitsPerMeter.z * project_size_at_latitude(lat);
 }
 
 //
 // Scaling offsets - scales meters to "world distance"
 // Note the scalar version of project_size is for scaling the z component only
 //
 float project_size(float meters) {
-  return meters * project_uCommonUnitsPerMeter.z * project_size();
+  // For scatter relevant
+  return meters * project.commonUnitsPerMeter.z * project_size();
 }
 
 vec2 project_size(vec2 meters) {
-  return meters * project_uCommonUnitsPerMeter.xy * project_size();
+  return meters * project.commonUnitsPerMeter.xy * project_size();
 }
 
 vec3 project_size(vec3 meters) {
-  return meters * project_uCommonUnitsPerMeter * project_size();
+  return meters * project.commonUnitsPerMeter * project_size();
 }
 
 vec4 project_size(vec4 meters) {
-  return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w);
+  return vec4(meters.xyz * project.commonUnitsPerMeter, meters.w);
 }
 
 // Get rotation matrix that aligns the z axis with the given up vector
@@ -129,7 +135,7 @@ mat3 project_get_orientation_matrix(vec3 up) {
 }
 
 bool project_needs_rotation(vec3 commonPosition, out mat3 transform) {
-  if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {
+  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
     transform = project_get_orientation_matrix(commonPosition);
     return true;
   }
@@ -142,8 +148,8 @@ bool project_needs_rotation(vec3 commonPosition, out mat3 transform) {
 //
 vec3 project_normal(vec3 vector) {
   // Apply model matrix
-  vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0);
-  vec3 n = normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter);
+  vec4 normal_modelspace = project.modelMatrix * vec4(vector, 0.0);
+  vec3 n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);
   mat3 rotation;
   if (project_needs_rotation(geometry.position.xyz, rotation)) {
     n = rotation * n;
@@ -153,7 +159,7 @@ vec3 project_normal(vec3 vector) {
 
 vec4 project_offset_(vec4 offset) {
   float dy = offset.y;
-  vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy;
+  vec3 commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;
   return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);
 }
 
@@ -162,7 +168,7 @@ vec4 project_offset_(vec4 offset) {
 //
 vec2 project_mercator_(vec2 lnglat) {
   float x = lnglat.x;
-  if (project_uWrapLongitude) {
+  if (project.autoWrapLongitude) {
     x = mod(x + 180., 360.0) - 180.;
   }
   float y = clamp(lnglat.y, -89.9, 89.9);
@@ -186,55 +192,55 @@ vec3 project_globe_(vec3 lnglatz) {
 }
 
 //
-// Projects positions (defined by project_uCoordinateSystem) to common space (defined by project_uProjectionMode)
+// Projects positions (defined by project.coordinateSystem) to common space (defined by project.projectionMode)
 //
 vec4 project_position(vec4 position, vec3 position64Low) {
-  vec4 position_world = project_uModelMatrix * position;
+  vec4 position_world = project.modelMatrix * position;
 
   // Work around for a Mac+NVIDIA bug https://github.com/visgl/deck.gl/issues/4145
-  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) {
-    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
       return vec4(
         project_mercator_(position_world.xy),
         project_size_at_latitude(position_world.z, position_world.y),
         position_world.w
       );
     }
-    if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
-      position_world.xyz += project_uCoordinateOrigin;
+    if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
+      position_world.xyz += project.coordinateOrigin;
     }
   }
-  if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {
-    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
       return vec4(
         project_globe_(position_world.xyz),
         position_world.w
       );
     }
   }
-  if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-    if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) {
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+      if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {
         // Too far from the projection center for offset mode to be accurate
         // Only use high parts
         return vec4(
-          project_mercator_(position_world.xy) - project_uCommonOrigin.xy,
+          project_mercator_(position_world.xy) - project.commonOrigin.xy,
           project_size(position_world.z),
           position_world.w
         );
       }
     }
   }
-  if (project_uProjectionMode == PROJECTION_MODE_IDENTITY ||
-    (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
-    (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
-     project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
+  if (project.projectionMode == PROJECTION_MODE_IDENTITY ||
+    (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
+    (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+     project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
     // Subtract high part of 64 bit value. Convert remainder to float32, preserving precision.
-    position_world.xyz -= project_uCoordinateOrigin;
+    position_world.xyz -= project.coordinateOrigin;
   }
 
   // Translation is already added to the high parts
-  return project_offset_(position_world) + project_offset_(project_uModelMatrix * vec4(position64Low, 0.0));
+  return project_offset_(position_world) + project_offset_(project.modelMatrix * vec4(position64Low, 0.0));
 }
 
 vec4 project_position(vec4 position) {
@@ -262,31 +268,31 @@ vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatr
 
 //
 // Projects from common space coordinates to clip space.
-// Uses project_uViewProjectionMatrix
+// Uses project.viewProjectionMatrix
 //
 vec4 project_common_position_to_clipspace(vec4 position) {
-  return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter);
+  return project_common_position_to_clipspace(position, project.viewProjectionMatrix, project.center);
 }
 
 // Returns a clip space offset that corresponds to a given number of screen pixels
 vec2 project_pixel_size_to_clipspace(vec2 pixels) {
-  vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0;
-  return offset * project_uFocalDistance;
+  vec2 offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;
+  return offset * project.focalDistance;
 }
 
 float project_size_to_pixel(float meters) {
-  return project_size(meters) * project_uScale;
+  return project_size(meters) * project.scale;
 }
 float project_size_to_pixel(float size, int unit) {
   if (unit == UNIT_METERS) return project_size_to_pixel(size);
-  if (unit == UNIT_COMMON) return size * project_uScale;
+  if (unit == UNIT_COMMON) return size * project.scale;
   // UNIT_PIXELS
   return size;
 }
 float project_pixel_size(float pixels) {
-  return pixels / project_uScale;
+  return pixels / project.scale;
 }
 vec2 project_pixel_size(vec2 pixels) {
-  return pixels / project_uScale;
+  return pixels / project.scale;
 }
 `;