@luma.gl/shadertools 9.0.19 → 9.0.21

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

@@ -5,9 +5,10 @@
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lightingUniforms} from './lighting-uniforms-glsl';
 import type {NumberArray3} from '../../../lib/utils/uniform-types';
+import {log} from '@luma.gl/core';
 
 /** Max number of supported lights (in addition to ambient light */
-const MAX_LIGHTS = 5;
+const MAX_LIGHTS = 3;
 
 /** Whether to divide */
 const COLOR_FACTOR = 255.0;
@@ -33,12 +34,11 @@ export type PointLight = {
   position: Readonly<NumberArray3>;
   color?: Readonly<NumberArray3>;
   intensity?: number;
-  attenuation?: number;
+  attenuation?: Readonly<NumberArray3>;
 };
 
 export type DirectionalLight = {
   type: 'directional';
-  position: Readonly<NumberArray3>;
   direction: Readonly<NumberArray3>;
   color?: Readonly<NumberArray3>;
   intensity?: number;
@@ -61,10 +61,18 @@ export type LightingUniforms = {
   directionalLightCount: number;
   pointLightCount: number;
   lightType: number; // [];
-  lightColor: Readonly<NumberArray3>; // [];
-  lightPosition: Readonly<NumberArray3>; // [];
-  lightDirection: Readonly<NumberArray3>; // [];
-  lightAttenuation: Readonly<NumberArray3>; // [];
+  lightColor0: Readonly<NumberArray3>;
+  lightPosition0: Readonly<NumberArray3>;
+  lightDirection0: Readonly<NumberArray3>;
+  lightAttenuation0: Readonly<NumberArray3>;
+  lightColor1: Readonly<NumberArray3>;
+  lightPosition1: Readonly<NumberArray3>;
+  lightDirection1: Readonly<NumberArray3>;
+  lightAttenuation1: Readonly<NumberArray3>;
+  lightColor2: Readonly<NumberArray3>;
+  lightPosition2: Readonly<NumberArray3>;
+  lightDirection2: Readonly<NumberArray3>;
+  lightAttenuation2: Readonly<NumberArray3>;
 };
 
 /** UBO ready lighting module */
@@ -83,17 +91,28 @@ export const lighting: ShaderModule<LightingProps, LightingUniforms, {}> = {
 
   uniformTypes: {
     enabled: 'i32',
-    lightType: 'i32', // , array: MAX_LIGHTS,
+    lightType: 'i32',
 
-    directionalLightCount: 'i32', // , array: MAX_LIGHTS,
-    pointLightCount: 'i32', // , array: MAX_LIGHTS,
+    directionalLightCount: 'i32',
+    pointLightCount: 'i32',
 
     ambientLightColor: 'vec3<f32>',
-    lightColor: 'vec3<f32>', // , array: MAX_LIGHTS,
-    lightPosition: 'vec3<f32>', // , array: MAX_LIGHTS,
+
+    // TODO define as arrays once we have appropriate uniformTypes
+    lightColor0: 'vec3<f32>',
+    lightPosition0: 'vec3<f32>',
     // TODO - could combine direction and attenuation
-    lightDirection: 'vec3<f32>', // , array: MAX_LIGHTS,
-    lightAttenuation: 'vec3<f32>' // , array: MAX_LIGHTS},
+    lightDirection0: 'vec3<f32>',
+    lightAttenuation0: 'vec3<f32>',
+
+    lightColor1: 'vec3<f32>',
+    lightPosition1: 'vec3<f32>',
+    lightDirection1: 'vec3<f32>',
+    lightAttenuation1: 'vec3<f32>',
+    lightColor2: 'vec3<f32>',
+    lightPosition2: 'vec3<f32>',
+    lightDirection2: 'vec3<f32>',
+    lightAttenuation2: 'vec3<f32>'
   },
 
   defaultUniforms: {
@@ -104,11 +123,20 @@ export const lighting: ShaderModule<LightingProps, LightingUniforms, {}> = {
     pointLightCount: 0,
 
     ambientLightColor: [0.1, 0.1, 0.1],
-    lightColor: [1, 1, 1],
-    lightPosition: [1, 1, 2],
+    lightColor0: [1, 1, 1],
+    lightPosition0: [1, 1, 2],
     // TODO - could combine direction and attenuation
-    lightDirection: [1, 1, 1],
-    lightAttenuation: [1, 1, 1]
+    lightDirection0: [1, 1, 1],
+    lightAttenuation0: [1, 0, 0],
+
+    lightColor1: [1, 1, 1],
+    lightPosition1: [1, 1, 2],
+    lightDirection1: [1, 1, 1],
+    lightAttenuation1: [1, 0, 0],
+    lightColor2: [1, 1, 1],
+    lightPosition2: [1, 1, 2],
+    lightDirection2: [1, 1, 1],
+    lightAttenuation2: [1, 0, 0]
   }
 };
 
@@ -158,42 +186,35 @@ function getLightSourceUniforms({
   pointLights = [],
   directionalLights = []
 }: LightingProps): Partial<LightingUniforms> {
-  const lightSourceUniforms: Partial<LightingUniforms> = {
-    // lightType: new Array(MAX_LIGHTS).fill(0),
-    // lightColor: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightPosition: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightDirection: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightAttenuation: new Array(MAX_LIGHTS).fill([0, 0, 0])
-  };
+  const lightSourceUniforms: Partial<LightingUniforms> = {};
 
   lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
 
-  let currentLight = 0;
+  let currentLight: 0 | 1 | 2 = 0;
 
   for (const pointLight of pointLights) {
-    // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.POINT;
-    // lightSourceUniforms.lightColor[currentLight] = convertColor(pointLight);
-    // lightSourceUniforms.lightPosition[currentLight] = pointLight.position;
-    // lightSourceUniforms.lightAttenuation[currentLight] = [pointLight.attenuation || 1, 0, 0];
     lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
-    lightSourceUniforms.lightColor = convertColor(pointLight);
-    lightSourceUniforms.lightPosition = pointLight.position;
-    lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];
+
+    const i = currentLight as 0 | 1 | 2;
+    lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
+    lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
+    lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
     currentLight++;
   }
 
   for (const directionalLight of directionalLights) {
-    // lightSourceUniforms.lightType[currentLight] = LIGHT_TYPE.DIRECTIONAL;
-    // lightSourceUniforms.lightColor[currentLight] = convertColor(directionalLight);
-    // lightSourceUniforms.lightPosition[currentLight] = directionalLight.position;
-    // lightSourceUniforms.lightDirection[currentLight] = directionalLight.direction;
     lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
-    lightSourceUniforms.lightColor = convertColor(directionalLight);
-    lightSourceUniforms.lightPosition = directionalLight.position;
-    lightSourceUniforms.lightDirection = directionalLight.direction;
+
+    const i = currentLight as 0 | 1 | 2;
+    lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
+    lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
     currentLight++;
   }
 
+  if (currentLight > MAX_LIGHTS) {
+    log.warn('MAX_LIGHTS exceeded')();
+  }
+
   lightSourceUniforms.directionalLightCount = directionalLights.length;
   lightSourceUniforms.pointLightCount = pointLights.length;
 

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

@@ -5,19 +5,18 @@
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting-uniforms';
 import {PHONG_VS, PHONG_FS} from './phong-shaders-glsl';
+import type {NumberArray3} from '../../../lib/utils/uniform-types';
 
-export type PhongMaterialProps = PhongMaterialUniforms;
-
-export type PhongMaterialUniforms = {
+export type PhongMaterialProps = {
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
   shininess?: number;
-  specularColor?: [number, number, 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 const phongMaterial: ShaderModule<PhongMaterialProps, PhongMaterialUniforms> = {
+export const phongMaterial: ShaderModule<PhongMaterialProps> = {
   name: 'phongMaterial',
   // Note these are switched between phong and gouraud
   vs: PHONG_VS,
@@ -38,7 +37,11 @@ export const phongMaterial: ShaderModule<PhongMaterialProps, PhongMaterialUnifor
     shininess: 32,
     specularColor: [0.15, 0.15, 0.15]
   },
-  getUniforms(props?: PhongMaterialProps): PhongMaterialUniforms {
+  getUniforms(props?: PhongMaterialProps) {
+    const uniforms = {...props};
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map(x => x / 255) as NumberArray3;
+    }
     return {...phongMaterial.defaultUniforms, ...props};
   }
 };

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

@@ -43,102 +43,21 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
   vec3 view_direction = normalize(cameraPosition - position_worldspace);
   lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    PointLight pointLight = lighting_getPointLight(0);
+  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);
-    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);
+    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);
   }
 
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  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;
 }
 
-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 == 0) {
-    return lightColor;
-  }
-
-  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;
-}
 `;
-
-// 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/lighting/gouraud-material/gouraud-shaders-glsl.d.ts

@@ -1,42 +0,0 @@
-export declare const GOURAUD_VS: string;
-export declare const GOURAUD_FS: string;
-/**
-    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);
-    }
-  }
-  */
-//# sourceMappingURL=gouraud-shaders-glsl.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,110 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-export const GOURAUD_VS = `\
-uniform gouraudMaterialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
-} material;
-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 = dot(light_direction, normal_worldspace);
-float specular = 0.0;
-if (lambertian > 0.0) {
-float 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;
-}
-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;
-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);
-}
-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 == 0) {
-return lightColor;
-}
-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;
-}
-`;
-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++) {
-      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/lighting/gouraud-material/gouraud-shaders-glsl.ts

@@ -1,144 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-export const GOURAUD_VS = glsl`\
-uniform gouraudMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-
-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 = dot(light_direction, normal_worldspace);
-  float specular = 0.0;
-  if (lambertian > 0.0) {
-    float 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;
-}
-
-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;
-
-  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);
-  }
-  */
-  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 == 0) {
-    return lightColor;
-  }
-
-  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;
-}
-`;
-
-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++) {
-      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);
-    }
-  }
-  */