@luma.gl/shadertools 9.0.17 → 9.0.19

package/dist/modules/lighting/gouraud-material/gouraud-material.js

@@ -5,7 +5,7 @@ import { lighting } from "../lights/lighting-uniforms.js";
 import { GOURAUD_VS, GOURAUD_FS } from "./gouraud-shaders-glsl.js";
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial = {
-    name: 'gouraud-lighting',
+    name: 'gouraudMaterial',
     // Note these are switched between phong and gouraud
     vs: GOURAUD_VS,
     fs: GOURAUD_FS,

package/dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gouraud-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU,QAOtB,CAAC;AAEF,eAAO,MAAM,UAAU,QAkFtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}
+{"version":3,"file":"gouraud-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU,QAuFtB,CAAC;AAEF,eAAO,MAAM,UAAU,QAOtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}

package/dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.js

@@ -3,15 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { glsl } from "../../../lib/glsl-utils/highlight.js";
 export const GOURAUD_VS = `\
-uniform materialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
-} material;
-`;
-export const GOURAUD_FS = `\
-uniform materialUniforms {
+uniform gouraudMaterialUniforms {
 uniform float ambient;
 uniform float diffuse;
 uniform float shininess;
@@ -30,7 +22,9 @@ return (lambertian * material.diffuse * surfaceColor + specular * material.specu
 }
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
 vec3 lightColor = surfaceColor;
-if (lighting.enabled) {
+if (lighting.enabled == 0) {
+return lightColor;
+}
 vec3 view_direction = normalize(cameraPosition - position_worldspace);
 lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 if (lighting.lightType == 0) {
@@ -42,13 +36,14 @@ lightColor += lighting_getLightColor(surfaceColor, light_direction, view_directi
 DirectionalLight directionalLight = lighting_getDirectionalLight(0);
 lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
 }
-}
 return lightColor;
 }
 vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
 vec3 lightColor = vec3(0, 0, 0);
 vec3 surfaceColor = vec3(0, 0, 0);
-if (lighting.enabled) {
+if (lighting.enabled == 0) {
+return lightColor;
+}
 vec3 view_direction = normalize(cameraPosition - position_worldspace);
 switch (lighting.lightType) {
 case 0:
@@ -62,10 +57,17 @@ DirectionalLight directionalLight = lighting_getDirectionalLight(0);
 lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
 break;
 }
-}
 return lightColor;
 }
 `;
+export const GOURAUD_FS = `\
+uniform gouraudMaterialUniforms {
+uniform float ambient;
+uniform float diffuse;
+uniform float shininess;
+uniform vec3  specularColor;
+} material;
+`;
 // TODO - handle multiple lights
 /**
     for (int i = 0; i < MAX_LIGHTS; i++) {

package/dist/modules/lighting/lights/lighting-uniforms-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lighting-uniforms-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,QAoD5B,CAAC"}
+{"version":3,"file":"lighting-uniforms-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,QAqD5B,CAAC"}

package/dist/modules/lighting/lights/lighting-uniforms-glsl.js

@@ -18,13 +18,13 @@ vec3 direction;
 };
 uniform lightingUniforms {
 int enabled;
-int pointLightCount;
+int lightType;
 int directionalLightCount;
+int pointLightCount;
 vec3 ambientColor;
-int lightType;
 vec3 lightColor;
-vec3 lightDirection;
 vec3 lightPosition;
+vec3 lightDirection;
 vec3 lightAttenuation;
 } lighting;
 PointLight lighting_getPointLight(int index) {

package/dist/modules/lighting/lights/lighting-uniforms.d.ts

@@ -34,7 +34,8 @@ export type LightingProps = {
 export type LightingUniforms = {
     enabled: number;
     ambientLightColor: Readonly<NumberArray3>;
-    numberOfLights: number;
+    directionalLightCount: number;
+    pointLightCount: number;
     lightType: number;
     lightColor: Readonly<NumberArray3>;
     lightPosition: Readonly<NumberArray3>;

package/dist/modules/lighting/lights/lighting-uniforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lighting-uniforms.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,KAAK,EAAC,YAAY,EAAC,4CAAyC;AAcnE,4BAA4B;AAE5B,MAAM,MAAM,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEjE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;IACjB,kBAAkB;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACnC,aAAa,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACtC,cAAc,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACvC,gBAAgB,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;CAC1C,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,aAAa,EAAE,gBAAgB,EAAE,EAAE,CAoCtE,CAAC"}
+{"version":3,"file":"lighting-uniforms.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,KAAK,EAAC,YAAY,EAAC,4CAAyC;AAcnE,4BAA4B;AAE5B,MAAM,MAAM,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEjE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;IACjB,kBAAkB;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC1C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACnC,aAAa,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACtC,cAAc,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACvC,gBAAgB,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;CAC1C,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,aAAa,EAAE,gBAAgB,EAAE,EAAE,CA0CtE,CAAC"}

package/dist/modules/lighting/lights/lighting-uniforms.js

@@ -25,9 +25,10 @@ export const lighting = {
     },
     uniformTypes: {
         enabled: 'i32',
-        ambientLightColor: 'vec3<f32>',
-        numberOfLights: 'i32', // , array: MAX_LIGHTS,
         lightType: 'i32', // , array: MAX_LIGHTS,
+        directionalLightCount: 'i32', // , array: MAX_LIGHTS,
+        pointLightCount: 'i32', // , array: MAX_LIGHTS,
+        ambientLightColor: 'vec3<f32>',
         lightColor: 'vec3<f32>', // , array: MAX_LIGHTS,
         lightPosition: 'vec3<f32>', // , array: MAX_LIGHTS,
         // TODO - could combine direction and attenuation
@@ -36,9 +37,10 @@ export const lighting = {
     },
     defaultUniforms: {
         enabled: 1,
-        ambientLightColor: [0.1, 0.1, 0.1],
-        numberOfLights: 0,
         lightType: LIGHT_TYPE.POINT,
+        directionalLightCount: 0,
+        pointLightCount: 0,
+        ambientLightColor: [0.1, 0.1, 0.1],
         lightColor: [1, 1, 1],
         lightPosition: [1, 1, 2],
         // TODO - could combine direction and attenuation
@@ -108,7 +110,8 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLig
         lightSourceUniforms.lightDirection = directionalLight.direction;
         currentLight++;
     }
-    lightSourceUniforms.numberOfLights = currentLight;
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
 }
 function extractLightTypes(lights) {

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

@@ -5,7 +5,7 @@ import { lighting } from "../lights/lighting-uniforms.js";
 import { PHONG_VS, PHONG_FS } from "./phong-shaders-glsl.js";
 /** 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: 'phong-lighting',
+    name: 'phongMaterial',
     // Note these are switched between phong and gouraud
     vs: PHONG_VS,
     fs: PHONG_FS,

package/dist/modules/lighting/phong-material/phong-shaders-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,QAOpB,CAAC;AAEF,eAAO,MAAM,QAAQ,QAqFpB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}
+{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,QAOpB,CAAC;AAEF,eAAO,MAAM,QAAQ,QAuFpB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}

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

@@ -50,6 +50,8 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
 vec3 lightColor = vec3(0, 0, 0);
 vec3 surfaceColor = vec3(0, 0, 0);
 if (lighting.enabled == 0) {
+return lightColor;
+}
 vec3 view_direction = normalize(cameraPosition - position_worldspace);
 switch (lighting.lightType) {
 case 0:
@@ -63,7 +65,6 @@ DirectionalLight directionalLight = lighting_getDirectionalLight(0);
 lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
 break;
 }
-}
 return lightColor;
 }
 `;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.0.17",
+  "version": "9.0.19",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -53,5 +53,5 @@
     "@math.gl/types": "^4.0.0",
     "wgsl_reflect": "^1.0.1"
   },
-  "gitHead": "f348f3221ab2842ffa877b6c99e0e9e4df82426e"
+  "gitHead": "5e1ede7bdaf2c9ccdbd167804601537e93dc4225"
 }

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

@@ -18,7 +18,7 @@ export type GouraudMaterialUniforms = {
 
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial: ShaderModule<GouraudMaterialProps, GouraudMaterialUniforms> = {
-  name: 'gouraud-lighting',
+  name: 'gouraudMaterial',
   // Note these are switched between phong and gouraud
   vs: GOURAUD_VS,
   fs: GOURAUD_FS,

package/src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts

@@ -5,16 +5,7 @@
 import {glsl} from '../../../lib/glsl-utils/highlight';
 
 export const GOURAUD_VS = glsl`\
-uniform materialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-`;
-
-export const GOURAUD_FS = glsl`\
-uniform materialUniforms {
+uniform gouraudMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -36,39 +27,41 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-    if (lighting.lightType == 0) {
-      PointLight pointLight = lighting_getPointLight(0);
-      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);
-    } else if (lighting.lightType == 1) {
-      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-      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.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);
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    PointLight pointLight = lighting_getPointLight(0);
+    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);
+  } else if (lighting.lightType == 1) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+    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.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);
+  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);
   }
+  */
   return lightColor;
 }
 
@@ -76,27 +69,39 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   vec3 lightColor = vec3(0, 0, 0);
   vec3 surfaceColor = vec3(0, 0, 0);
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        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);
-        break;
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  switch (lighting.lightType) {
+    case 0:
+      PointLight pointLight = lighting_getPointLight(0);
+      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);
+      break;
+
+    case 1:
+      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      break;
   }
+
   return lightColor;
 }
 `;
 
+export const GOURAUD_FS = glsl`\
+uniform gouraudMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+`;
+
 // TODO - handle multiple lights
 /**
     for (int i = 0; i < MAX_LIGHTS; i++) {

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

@@ -25,15 +25,16 @@ struct DirectionalLight {
 
 uniform lightingUniforms {
   int enabled;
-  int pointLightCount;
+  int lightType;
+
   int directionalLightCount;
+  int pointLightCount;
 
   vec3 ambientColor;
 
-  int lightType;
   vec3 lightColor;
-  vec3 lightDirection;
   vec3 lightPosition;
+  vec3 lightDirection;
   vec3 lightAttenuation;
 
   // AmbientLight ambientLight;

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

@@ -58,7 +58,8 @@ export type LightingProps = {
 export type LightingUniforms = {
   enabled: number;
   ambientLightColor: Readonly<NumberArray3>;
-  numberOfLights: number;
+  directionalLightCount: number;
+  pointLightCount: number;
   lightType: number; // [];
   lightColor: Readonly<NumberArray3>; // [];
   lightPosition: Readonly<NumberArray3>; // [];
@@ -82,9 +83,12 @@ export const lighting: ShaderModule<LightingProps, LightingUniforms, {}> = {
 
   uniformTypes: {
     enabled: 'i32',
-    ambientLightColor: 'vec3<f32>',
-    numberOfLights: 'i32', // , array: MAX_LIGHTS,
     lightType: 'i32', // , array: MAX_LIGHTS,
+
+    directionalLightCount: 'i32', // , array: MAX_LIGHTS,
+    pointLightCount: 'i32', // , array: MAX_LIGHTS,
+
+    ambientLightColor: 'vec3<f32>',
     lightColor: 'vec3<f32>', // , array: MAX_LIGHTS,
     lightPosition: 'vec3<f32>', // , array: MAX_LIGHTS,
     // TODO - could combine direction and attenuation
@@ -94,9 +98,12 @@ export const lighting: ShaderModule<LightingProps, LightingUniforms, {}> = {
 
   defaultUniforms: {
     enabled: 1,
-    ambientLightColor: [0.1, 0.1, 0.1],
-    numberOfLights: 0,
     lightType: LIGHT_TYPE.POINT,
+
+    directionalLightCount: 0,
+    pointLightCount: 0,
+
+    ambientLightColor: [0.1, 0.1, 0.1],
     lightColor: [1, 1, 1],
     lightPosition: [1, 1, 2],
     // TODO - could combine direction and attenuation
@@ -187,7 +194,8 @@ function getLightSourceUniforms({
     currentLight++;
   }
 
-  lightSourceUniforms.numberOfLights = currentLight;
+  lightSourceUniforms.directionalLightCount = directionalLights.length;
+  lightSourceUniforms.pointLightCount = pointLights.length;
 
   return lightSourceUniforms;
 }

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

@@ -18,7 +18,7 @@ export type PhongMaterialUniforms = {
 
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
 export const phongMaterial: ShaderModule<PhongMaterialProps, PhongMaterialUniforms> = {
-  name: 'phong-lighting',
+  name: 'phongMaterial',
   // Note these are switched between phong and gouraud
   vs: PHONG_VS,
   fs: PHONG_FS,

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

@@ -80,21 +80,23 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   vec3 surfaceColor = vec3(0, 0, 0);
 
   if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        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);
-        break;
+    return lightColor;
+  }
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+
+  switch (lighting.lightType) {
+    case 0:
+      PointLight pointLight = lighting_getPointLight(0);
+      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);
+      break;
+
+    case 1:
+      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      break;
   }
   return lightColor;
 }