@luma.gl/shadertools 9.1.0-alpha.10 → 9.1.0-alpha.13

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js

@@ -0,0 +1,130 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const PHONG_WGSL = /* wgsl */ `\
+struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      }
+    }
+  }
+  return lightColor;
+}
+`;
+// TODO - handle multiple lights
+/**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+    /**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  */

package/dist/modules/math/fp64/fp64-utils.d.ts

@@ -1,4 +1,4 @@
-import type { NumberArray } from '@math.gl/types';
+import type { NumericArray } from '@math.gl/types';
 /**
  * Calculate WebGL 64 bit float
  * @param a  - the input float number
@@ -6,7 +6,7 @@ import type { NumberArray } from '@math.gl/types';
  * @param startIndex - the index in the output array to fill from. Default 0.
  * @returns - the fp64 representation of the input number
  */
-export declare function fp64ify(a: number, out?: NumberArray, startIndex?: number): NumberArray;
+export declare function fp64ify(a: number, out?: NumericArray, startIndex?: number): NumericArray;
 /**
  * Calculate the low part of a WebGL 64 bit float
  * @param a the input float number
@@ -18,5 +18,5 @@ export declare function fp64LowPart(a: number): number;
  * @param matrix  the input matrix
  * @returns the fp64 representation of the input matrix
  */
-export declare function fp64ifyMatrix4(matrix: NumberArray): Float32Array;
+export declare function fp64ifyMatrix4(matrix: NumericArray): Float32Array;
 //# sourceMappingURL=fp64-utils.d.ts.map

package/dist/modules/math/fp64/fp64-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp64-utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,WAAgB,EAAE,UAAU,GAAE,MAAU,GAAG,WAAW,CAM7F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAUhE"}
+{"version":3,"file":"fp64-utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,YAAiB,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAM/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAUjE"}

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts

@@ -1,7 +1,7 @@
 import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
-import type { NumberArray } from "../../../types.js";
+import type { NumericArray } from "../../../types.js";
 export type DirlightOptions = {
-    lightDirection?: NumberArray;
+    lightDirection?: NumericArray;
 };
 /**
  * Cheap lighting - single directional light, single dot product, one uniform

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AACtE,OAAO,KAAK,EAAC,WAAW,EAAC,0BAAuB;AAKhD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,WAAW,CAAC;CAC9B,CAAC;AA4BF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC"}
+{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AACtE,OAAO,KAAK,EAAC,YAAY,EAAC,0BAAuB;AAKjD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B,CAAC;AA4BF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.1.0-alpha.10",
+  "version": "9.1.0-alpha.13",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -46,12 +46,12 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "^9.0.0-beta"
+    "@luma.gl/core": "9.1.0-alpha.10"
   },
   "dependencies": {
-    "@math.gl/core": "^4.0.0",
-    "@math.gl/types": "^4.0.0",
+    "@math.gl/core": "4.1.0-alpha.3",
+    "@math.gl/types": "4.1.0-alpha.3",
     "wgsl_reflect": "^1.0.1"
   },
-  "gitHead": "f419cdc284e87b553df60af49d2888ac7dbbf288"
+  "gitHead": "c2c641d67a5aec97467de13b0e3d8f9307ba03c2"
 }

package/src/lib/shader-assembly/assemble-shaders.ts

@@ -224,17 +224,17 @@ export function assembleShaderWGSL(platformInfo: PlatformInfo, options: Assemble
   }
 
   // TODO - hack until shadertool modules support WebGPU
-  const modulesToInject = platformInfo.type !== 'webgpu' ? modules : [];
+  const modulesToInject = modules;
 
   for (const module of modulesToInject) {
     if (log) {
       checkShaderModuleDeprecations(module, coreSource, log);
     }
-    const moduleSource = getShaderModuleSource(module, stage);
+    const moduleSource = getShaderModuleSource(module, 'wgsl');
     // Add the module source, and a #define that declares it presence
     assembledSource += moduleSource;
 
-    const injections = module.injections[stage];
+    const injections = module.injections?.[stage] || {};
     for (const key in injections) {
       const match = /^(v|f)s:#([\w-]+)$/.exec(key);
       if (match) {
@@ -496,14 +496,15 @@ export function getShaderModuleSource(
     throw new Error('Shader module must have a name');
   }
   const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, '_');
-  return `\
+  let source = `\
 // ----- MODULE ${module.name} ---------------
 
-#define MODULE_${moduleName}
-${moduleSource}\
-
-
 `;
+  if (stage !== 'wgsl') {
+    source += `#define MODULE_${moduleName}\n`;
+  }
+  source += `${moduleSource}\n`;
+  return source;
 }
 
 /*

package/src/lib/shader-module/shader-module-dependencies.ts

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ShaderModule} from './shader-module';
-import {initializeShaderModules} from '../shader-module/shader-module';
+import {ShaderModule, initializeShaderModules} from './shader-module';
 
 // import type {ShaderModule} from '../shader-module/shader-module';
 

package/src/lib/shader-module/shader-module.ts

@@ -2,16 +2,20 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumberArray} from '@math.gl/types';
+import type {NumericArray} from '@math.gl/types';
 import {Sampler, Texture} from '@luma.gl/core';
 import type {UniformFormat} from '../../types';
-import {PropType, PropValidator} from '../filters/prop-types';
-import {ShaderInjection} from '../shader-assembly/shader-injections';
-import {makePropValidators, getValidatedProperties} from '../filters/prop-types';
-import {normalizeInjections} from '../shader-assembly/shader-injections';
+import {
+  PropType,
+  PropValidator,
+  makePropValidators,
+  getValidatedProperties
+} from '../filters/prop-types';
+import {ShaderInjection, normalizeInjections} from '../shader-assembly/shader-injections';
 
 export type BindingValue = Buffer | Texture | Sampler;
-export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
+export type UniformValue = number | boolean | Readonly<NumericArray>;
+// Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
 
 export type UniformInfo = {
   format?: UniformFormat;

package/src/modules/engine/picking/picking.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {NumberArray} from '../../../types';
+import {NumericArray} from '../../../types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
 // cyan color
@@ -19,9 +19,9 @@ export type PickingProps = {
   /** Set to true when picking an attribute value instead of object index */
   isAttribute?: boolean;
   /** Set to a picking color to visually highlight that item, or `null` to explicitly clear **/
-  highlightedObjectColor?: NumberArray | null;
+  highlightedObjectColor?: NumericArray | null;
   /** Color of visual highlight of "selected" item */
-  highlightColor?: NumberArray;
+  highlightColor?: NumericArray;
   /** Color range 0-1 or 0-255 */
   useFloatColors?: boolean;
 };
@@ -44,9 +44,9 @@ export type PickingUniforms = {
   /** Do we have a highlighted item? */
   isHighlightActive?: boolean;
   /** Set to a picking color to visually highlight that item */
-  highlightedObjectColor?: NumberArray;
+  highlightedObjectColor?: NumericArray;
   /** Color of visual highlight of "selected" item */
-  highlightColor?: NumberArray;
+  highlightColor?: NumericArray;
 };
 
 const vs = /* glsl */ `\

package/src/modules/lighting/lights/lighting-uniforms-glsl.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-export const lightingUniforms = /* glsl */ `\
+export const lightingUniformsGLSL = /* glsl */ `\
 precision highp int;
 
 // #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))

package/src/modules/lighting/lights/lighting-uniforms-wgsl.ts

@@ -0,0 +1,57 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const lightingUniformsWGSL = /* wgsl */ `\
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  poightCount: i32,
+  directionalLightCount: i32,
+
+  ambientColor: vec3<f32>,
+
+  // TODO - support multiple lights by uncommenting arrays below
+  lightType: i32,
+  lightColor: vec3<f32>,
+  lightDirection: vec3<f32>,
+  lightPosition: vec3<f32>,
+  lightAttenuation: vec3<f32>,
+
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
+};
+
+// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
+@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+}
+
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
+
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+`;

package/src/modules/lighting/lights/lighting.ts

@@ -4,7 +4,8 @@
 
 import type {NumberArray} from '@math.gl/types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
-import {lightingUniforms} from './lighting-uniforms-glsl';
+import {lightingUniformsGLSL} from './lighting-uniforms-glsl';
+import {lightingUniformsWGSL} from './lighting-uniforms-wgsl';
 
 /** Max number of supported lights (in addition to ambient light */
 const MAX_LIGHTS = 5;
@@ -100,8 +101,9 @@ export const lighting = {
     lightDirection: [1, 1, 1],
     lightAttenuation: [1, 1, 1]
   },
-  vs: lightingUniforms,
-  fs: lightingUniforms,
+  source: lightingUniformsWGSL,
+  vs: lightingUniformsGLSL,
+  fs: lightingUniformsGLSL,
 
   getUniforms
 } as const satisfies ShaderModule<LightingProps, LightingUniforms>;

package/src/modules/lighting/no-material/dirlight.ts

@@ -2,31 +2,40 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumberArray} from '@math.gl/types';
+import type {Vector3Like, TypedArray} from '@math.gl/core';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
 export type DirlightProps = {
-  lightDirection?: NumberArray | [number, number, number];
+  lightDirection?: Vector3Like | TypedArray;
 };
 
 export type DirlightUniforms = DirlightProps;
 
 // TODO
-export const VS_WGSL = /* WGSL */ `\  
-void dirlight_setNormal(normal: vec3<f32>) {
-  dirlight_vNormal = normalize(normal);
-}
-`;
+export const SOURCE_WGSL = /* WGSL */ `\  
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
 
-// TODO
-export const FS_WGSL = /* WGSL */ `\
-uniform dirlightUniforms {
-  vec3 lightDirection;
-} dirlight;
+alias DirlightNormal = vec3<f32>;
+
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
+
+@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
 
 // Returns color attenuated by angle from light source
-fn dirlight_filterColor(color: vec4<f32>, dirlightInputs): vec4<f32> {
-  const d: float = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
   return vec4<f32>(color.rgb * d, color.a);
 }
 `;
@@ -62,6 +71,7 @@ export const dirlight = {
 
   name: 'dirlight',
   dependencies: [],
+  source: SOURCE_WGSL,
   vs: VS_GLSL,
   fs: FS_GLSL,
 

package/src/modules/lighting/phong-material/phong-material.ts

@@ -4,6 +4,7 @@
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
+import {PHONG_WGSL} from './phong-shaders-wgsl';
 import {PHONG_VS, PHONG_FS} from './phong-shaders-glsl';
 
 export type PhongMaterialProps = PhongMaterialUniforms;
@@ -24,6 +25,7 @@ export const phongMaterial = {
   name: 'phong-lighting',
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
+  source: PHONG_WGSL,
   vs: PHONG_VS,
   fs: PHONG_FS,
   defines: {

package/src/modules/lighting/phong-material/phong-shaders-wgsl.ts

@@ -0,0 +1,132 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const PHONG_WGSL = /* wgsl */ `\
+struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      }
+    }
+  }
+  return lightColor;
+}
+`;
+
+// TODO - handle multiple lights
+/**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+    /**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  */

package/src/modules/math/fp64/fp64-utils.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumberArray} from '@math.gl/types';
+import type {NumericArray} from '@math.gl/types';
 
 /**
  * Calculate WebGL 64 bit float
@@ -11,7 +11,7 @@ import type {NumberArray} from '@math.gl/types';
  * @param startIndex - the index in the output array to fill from. Default 0.
  * @returns - the fp64 representation of the input number
  */
-export function fp64ify(a: number, out: NumberArray = [], startIndex: number = 0): NumberArray {
+export function fp64ify(a: number, out: NumericArray = [], startIndex: number = 0): NumericArray {
   const hiPart = Math.fround(a);
   const loPart = a - hiPart;
   out[startIndex] = hiPart;
@@ -33,7 +33,7 @@ export function fp64LowPart(a: number): number {
  * @param matrix  the input matrix
  * @returns the fp64 representation of the input matrix
  */
-export function fp64ifyMatrix4(matrix: NumberArray): Float32Array {
+export function fp64ifyMatrix4(matrix: NumericArray): Float32Array {
   // Transpose the projection matrix to column major for GLSL.
   const matrixFP64 = new Float32Array(32);
   for (let i = 0; i < 4; ++i) {

package/src/modules-webgl1/lighting/dirlight/dirlight.ts

@@ -3,13 +3,13 @@
 // Copyright (c) vis.gl contributors
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
-import type {NumberArray} from '../../../types';
+import type {NumericArray} from '../../../types';
 import {project} from '../../project/project';
 
 /* eslint-disable camelcase */
 
 export type DirlightOptions = {
-  lightDirection?: NumberArray;
+  lightDirection?: NumericArray;
 };
 
 const DEFAULT_MODULE_OPTIONS: Required<DirlightOptions> = {