@luma.gl/shadertools 9.1.0-alpha.16 → 9.1.0-alpha.18

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

@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumberArray} from '@math.gl/types';
+import {log} from '@luma.gl/core';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lightingUniformsGLSL} from './lighting-uniforms-glsl';
 import {lightingUniformsWGSL} from './lighting-uniforms-wgsl';
+import type {NumberArray3} from '@math.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;
@@ -26,23 +27,22 @@ export type Light = AmbientLight | PointLight | DirectionalLight;
 
 export type AmbientLight = {
   type: 'ambient';
-  color?: Readonly<NumberArray>;
+  color?: Readonly<NumberArray3>;
   intensity?: number;
 };
 
 export type PointLight = {
   type: 'point';
-  position: Readonly<NumberArray>;
-  color?: Readonly<NumberArray>;
+  position: Readonly<NumberArray3>;
+  color?: Readonly<NumberArray3>;
   intensity?: number;
-  attenuation?: number;
+  attenuation?: Readonly<NumberArray3>;
 };
 
 export type DirectionalLight = {
   type: 'directional';
-  position: Readonly<NumberArray>;
-  direction: Readonly<NumberArray>;
-  color?: Readonly<NumberArray>;
+  direction: Readonly<NumberArray3>;
+  color?: Readonly<NumberArray3>;
   intensity?: number;
 };
 
@@ -59,13 +59,22 @@ export type LightingProps = {
 
 export type LightingUniforms = {
   enabled: number;
-  ambientLightColor: Readonly<NumberArray>;
-  numberOfLights: number;
+  ambientLightColor: Readonly<NumberArray3>;
+  directionalLightCount: number;
+  pointLightCount: number;
   lightType: number; // [];
-  lightColor: Readonly<NumberArray>; // [];
-  lightPosition: Readonly<NumberArray>; // [];
-  lightDirection: Readonly<NumberArray>; // [];
-  lightAttenuation: Readonly<NumberArray>; // [];
+  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 */
@@ -81,33 +90,59 @@ export const lighting = {
 
   uniformTypes: {
     enabled: 'i32',
+    lightType: 'i32',
+
+    directionalLightCount: 'i32',
+    pointLightCount: 'i32',
+
     ambientLightColor: 'vec3<f32>',
-    numberOfLights: 'i32', // , array: MAX_LIGHTS,
-    lightType: 'i32', // , array: MAX_LIGHTS,
-    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: {
     enabled: 1,
-    ambientLightColor: [0.1, 0.1, 0.1],
-    numberOfLights: 0,
     lightType: LIGHT_TYPE.POINT,
-    lightColor: [1, 1, 1],
-    lightPosition: [1, 1, 2],
+
+    directionalLightCount: 0,
+    pointLightCount: 0,
+
+    ambientLightColor: [0.1, 0.1, 0.1],
+    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]
   },
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
   fs: lightingUniformsGLSL,
 
   getUniforms
-} as const satisfies ShaderModule<LightingProps, LightingUniforms>;
+} as const satisfies ShaderModule<LightingProps, LightingUniforms, {}>;
 
 function getUniforms(
   props?: LightingProps,
@@ -155,43 +190,37 @@ 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++;
   }
 
-  lightSourceUniforms.numberOfLights = currentLight;
+  if (currentLight > MAX_LIGHTS) {
+    log.warn('MAX_LIGHTS exceeded')();
+  }
+
+  lightSourceUniforms.directionalLightCount = directionalLights.length;
+  lightSourceUniforms.pointLightCount = pointLights.length;
 
   return lightSourceUniforms;
 }
@@ -221,8 +250,8 @@ function extractLightTypes(lights: Light[]): LightingProps {
 
 /** Take color 0-255 and intensity as input and output 0.0-1.0 range */
 function convertColor(
-  colorDef: {color?: Readonly<NumberArray>; intensity?: number} = {}
-): NumberArray {
+  colorDef: {color?: Readonly<NumberArray3>; intensity?: number} = {}
+): NumberArray3 {
   const {color = [0, 0, 0], intensity = 1.0} = colorDef;
-  return color.map(component => (component * intensity) / COLOR_FACTOR);
+  return color.map(component => (component * intensity) / COLOR_FACTOR) as NumberArray3;
 }

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

@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Vector3Like, TypedArray} from '@math.gl/core';
+import type {Vector3Like} from '@math.gl/core';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
 export type DirlightProps = {
-  lightDirection?: Vector3Like | TypedArray;
+  lightDirection?: Vector3Like;
 };
 
 export type DirlightUniforms = DirlightProps;
@@ -85,7 +85,7 @@ export const dirlight = {
     lightDirection: 'vec3<f32>'
   },
   defaultUniforms: {
-    lightDirection: new Float32Array([1, 1, 2])
+    lightDirection: [1, 1, 2]
   },
   getUniforms
 } as const satisfies ShaderModule<DirlightProps, DirlightUniforms>;

package/src/modules/lighting/pbr-material/pbr-fragment-glsl.ts

@@ -13,12 +13,7 @@
 export const fs = /* glsl */ `\
 precision highp float;
 
-uniform Projection {
-  // Projection
-  uniform vec3 u_Camera;
-};
-
-uniform pbrMaterial {
+uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -50,40 +45,40 @@ uniform pbrMaterial {
   vec4 scaleDiffBaseMR;
   vec4 scaleFGDSpec;
   // #endif
-} u_pbrMaterial;
+} pbrMaterial;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_metallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
+uniform sampler2D pbr_occlusionSampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
 
 // Inputs from vertex shader
 
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+in mat3 pbr_vTBN;
 #else
-varying vec3 pbr_vNormal;
+in vec3 pbr_vNormal;
 #endif
 #endif
 
@@ -151,8 +146,8 @@ vec3 getNormal()
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -170,22 +165,22 @@ vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
   float mipCount = 9.0; // resolution of 512x512
   float lod = (pbrInfo.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
     vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 
   vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
   vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
-  specular *= u_pbrMaterial.scaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -277,32 +272,32 @@ vec4 pbr_filterColor(vec4 colorUnused)
 {
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-  vec4 baseColor = u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_pbrMaterial.alphaCutoff) {
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(u_pbrMaterial.unlit){
+  if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
   else{
     // Metallic and Roughness material properties are packed together
     // In glTF, these factors can be specified by fixed scalar values
     // or from a metallic-roughness map
-    float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;
-    float metallic = u_pbrMaterial.metallicRoughnessValues.x;
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -329,7 +324,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
 
     vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
 
     float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     vec3 reflection = -normalize(reflect(v, n));
@@ -351,47 +346,48 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
+
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // Apply directional light
-    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-      if (i < lighting_uDirectionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
-        color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);
+    for(int i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
       }
     }
 
     // Apply point light
-    for(int i = 0; i < lighting_uPointLightCount; i++) {
-      if (i < lighting_uPointLightCount) {
-        PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);
+    for(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
       }
     }
 #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-    if (u_pbrMateral.IBLEnabled) {
+    if (pbrMaterial.IBLenabled) {
       color += getIBLContribution(pbrInfo, n, reflection);
     }
 #endif
 
-    // Apply optional PBR terms for additional (optional) shading
+ // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-    if (u_pbrMaterial.occlusionMapEnabled) {
-      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
-      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    if (u_pbrMaterial.emmissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
 #endif
@@ -401,15 +397,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef PBR_DEBUG
     // TODO: Figure out how to debug multiple lights
 
-    // color = mix(color, F, u_ScaleFGDSpec.x);
-    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
-    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
-    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
-    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
 #endif
 
   }

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

@@ -4,61 +4,36 @@
 
 /* eslint-disable camelcase */
 
-import type {NumberArray} from '@math.gl/types';
 import type {Texture} from '@luma.gl/core';
-import type {Vector2, Vector3, Vector4} from '@math.gl/core';
+import type {
+  Vector2,
+  Vector3,
+  Vector4,
+  NumberArray2,
+  NumberArray3,
+  NumberArray4
+} from '@math.gl/core';
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
 
 import {vs} from './pbr-vertex-glsl';
 import {fs} from './pbr-fragment-glsl';
-
-export type PBRMaterialProps = PBRMaterialBindings & {
-  unlit?: boolean;
-
-  // Base color map
-  baseColorMapEnabled?: boolean;
-  baseColorFactor?: Readonly<Vector4 | NumberArray>;
-
-  normalMapEnabled?: boolean;
-  normalScale?: number; // #ifdef HAS_NORMALMAP
-
-  emissiveMapEnabled?: boolean;
-  emissiveFactor?: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
-
-  metallicRoughnessValues?: Readonly<Vector2 | NumberArray>;
-  metallicRoughnessMapEnabled?: boolean;
-
-  occlusionMapEnabled?: boolean;
-  occlusionStrength?: number; // #ifdef HAS_OCCLUSIONMAP
-
-  alphaCutoffEnabled?: boolean;
-  alphaCutoff?: number; // #ifdef ALPHA_CUTOFF
-
-  // IBL
-  IBLenabled?: boolean;
-  scaleIBLAmbient?: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
-
-  // debugging flags used for shader output of intermediate PBR variables
-  // #ifdef PBR_DEBUG
-  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray>;
-  scaleFGDSpec?: Readonly<Vector4 | NumberArray>;
-};
+import {pbrProjection} from './pbr-projection';
 
 /** Non-uniform block bindings for pbr module */
-type PBRMaterialBindings = {
+export type PBRMaterialBindings = {
   // Samplers
-  baseColorSampler?: Texture | null; // #ifdef HAS_BASECOLORMAP
-  normalSampler?: Texture | null; // #ifdef HAS_NORMALMAP
-  emissiveSampler?: Texture | null; // #ifdef HAS_EMISSIVEMAP
-  metallicRoughnessSampler?: Texture | null; // #ifdef HAS_METALROUGHNESSMAP
-  occlusionSampler?: Texture | null; // #ifdef HAS_OCCLUSIONMAP
+  pbr_baseColorSampler?: Texture | null; // #ifdef HAS_BASECOLORMAP
+  pbr_normalSampler?: Texture | null; // #ifdef HAS_NORMALMAP
+  pbr_emissiveSampler?: Texture | null; // #ifdef HAS_EMISSIVEMAP
+  pbr_metallicRoughnessSampler?: Texture | null; // #ifdef HAS_METALROUGHNESSMAP
+  pbr_occlusionSampler?: Texture | null; // #ifdef HAS_OCCLUSIONMAP
 
   // IBL Samplers
-  diffuseEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
-  specularEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
-  brdfLUT?: Texture | null; // #ifdef USE_IBL
+  pbr_diffuseEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
+  pbr_specularEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
+  pbr_BrdfLUT?: Texture | null; // #ifdef USE_IBL
 };
 
 export type PBRMaterialUniforms = {
@@ -66,15 +41,15 @@ export type PBRMaterialUniforms = {
 
   // Base color map
   baseColorMapEnabled?: boolean;
-  baseColorFactor?: Readonly<Vector4 | NumberArray>;
+  baseColorFactor?: Readonly<Vector4 | NumberArray4>;
 
   normalMapEnabled?: boolean;
   normalScale?: number; // #ifdef HAS_NORMALMAP
 
   emissiveMapEnabled?: boolean;
-  emissiveFactor?: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
+  emissiveFactor?: Readonly<Vector3 | NumberArray3>; // #ifdef HAS_EMISSIVEMAP
 
-  metallicRoughnessValues?: Readonly<Vector2 | NumberArray>;
+  metallicRoughnessValues?: Readonly<Vector2 | NumberArray2>;
   metallicRoughnessMapEnabled?: boolean;
 
   occlusionMapEnabled?: boolean;
@@ -85,14 +60,16 @@ export type PBRMaterialUniforms = {
 
   // IBL
   IBLenabled?: boolean;
-  scaleIBLAmbient?: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
+  scaleIBLAmbient?: Readonly<Vector2 | NumberArray2>; // #ifdef USE_IBL
 
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
-  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray>;
-  scaleFGDSpec?: Readonly<Vector4 | NumberArray>;
+  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray4>;
+  scaleFGDSpec?: Readonly<Vector4 | NumberArray4>;
 };
 
+export type PBRMaterialProps = PBRMaterialBindings & PBRMaterialUniforms;
+
 /**
  * An implementation of PBR (Physically-Based Rendering).
  * Physically Based Shading of a microfacet surface defined by a glTF material.
@@ -101,23 +78,24 @@ export const pbrMaterial = {
   props: {} as PBRMaterialProps,
   uniforms: {} as PBRMaterialUniforms,
 
-  name: 'pbr',
-  dependencies: [lighting],
+  name: 'pbrMaterial',
+  dependencies: [lighting, pbrProjection],
   vs,
   fs,
 
   defines: {
-    LIGHTING_FRAGMENT: 1,
-    HAS_NORMALMAP: 0,
-    HAS_EMISSIVEMAP: 0,
-    HAS_OCCLUSIONMAP: 0,
-    HAS_BASECOLORMAP: 0,
-    HAS_METALROUGHNESSMAP: 0,
-    ALPHA_CUTOFF: 0,
-    USE_IBL: 0,
-    PBR_DEBUG: 0
+    LIGHTING_FRAGMENT: 1
+    // TODO defining these as 0 breaks shader
+    // HAS_NORMALMAP: 0
+    // HAS_EMISSIVEMAP: 0,
+    // HAS_OCCLUSIONMAP: 0,
+    // HAS_BASECOLORMAP: 0,
+    // HAS_METALROUGHNESSMAP: 0,
+    // ALPHA_CUTOFF: 0
+    // USE_IBL: 0
+    // PBR_DEBUG: 0
   },
-
+  getUniforms: props => props,
   uniformTypes: {
     // Material is unlit
     unlit: 'i32',
@@ -149,17 +127,5 @@ export const pbrMaterial = {
     // #ifdef PBR_DEBUG
     scaleDiffBaseMR: 'vec4<f32>',
     scaleFGDSpec: 'vec4<f32>'
-  },
-
-  bindings: {
-    baseColorSampler: {type: 'texture', location: 8}, // #ifdef HAS_BASECOLORMAP
-    normalSampler: {type: 'texture', location: 9}, // #ifdef HAS_NORMALMAP
-    emissiveSampler: {type: 'texture', location: 10}, // #ifdef HAS_EMISSIVEMAP
-    metallicRoughnessSampler: {type: 'texture', location: 11}, // #ifdef HAS_METALROUGHNESSMAP
-    occlusionSampler: {type: 'texture', location: 12}, // #ifdef HAS_OCCLUSIONMAP
-    // IBL Samplers
-    diffuseEnvSampler: {type: 'texture', location: 13}, // #ifdef USE_IBL (samplerCube)
-    specularEnvSampler: {type: 'texture', location: 14}, // #ifdef USE_IBL (samplerCube)
-    brdfLUT: {type: 'texture', location: 15} // #ifdef USE_IBL
   }
-} as const satisfies ShaderModule<PBRMaterialProps, PBRMaterialUniforms>;
+} as const satisfies ShaderModule<PBRMaterialProps, PBRMaterialUniforms, PBRMaterialBindings>;