@luma.gl/shadertools 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/lib/shader-generator/glsl/generate-glsl.ts

@@ -32,7 +32,13 @@ function generateGLSLUniformDeclarations(
   }
 
   for (const [uniformName, uniformFormat] of Object.entries(module.uniformTypes || {})) {
-    const glslUniformType = getGLSLUniformType(uniformFormat);
+    if (typeof uniformFormat !== 'string') {
+      throw new Error(
+        `Composite uniform types are not supported by GLSL shader generation: ${module.name}.${uniformName}`
+      );
+    }
+
+    const glslUniformType = getGLSLUniformType(uniformFormat as UniformFormat);
     switch (options.uniforms) {
       case 'scoped-interface-blocks':
         // => uniform UniformBlockName {

package/src/lib/shader-generator/wgsl/generate-wgsl.ts

@@ -23,6 +23,12 @@ export function generateWGSLUniformDeclarations(
   wgsl.push(`struct ${capitalize(module.name)} {`);
 
   for (const [uniformName, uniformFormat] of Object.entries(module?.uniformTypes || {})) {
+    if (typeof uniformFormat !== 'string') {
+      throw new Error(
+        `Composite uniform types are not supported by WGSL shader generation: ${module.name}.${uniformName}`
+      );
+    }
+
     const wgslUniformType = uniformFormat;
     wgsl.push(`  ${uniformName} : ${wgslUniformType};`);
   }

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

@@ -0,0 +1,194 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from './shader-module';
+import {assert} from '../utils/assert';
+
+export type ShaderModuleUniformLayoutStage = 'vertex' | 'fragment' | 'wgsl';
+
+export type ShaderModuleUniformLayoutValidationResult = {
+  moduleName: string;
+  uniformBlockName: string;
+  stage: ShaderModuleUniformLayoutStage;
+  expectedUniformNames: string[];
+  actualUniformNames: string[];
+  matches: boolean;
+};
+
+type Logger = {
+  error?: (...args: unknown[]) => () => unknown;
+};
+
+export function getShaderModuleUniformBlockName(module: ShaderModule): string {
+  return `${module.name}Uniforms`;
+}
+
+export function getShaderModuleUniformBlockFields(
+  module: ShaderModule,
+  stage: ShaderModuleUniformLayoutStage
+): string[] | null {
+  const shaderSource =
+    stage === 'wgsl' ? module.source : stage === 'vertex' ? module.vs : module.fs;
+
+  if (!shaderSource) {
+    return null;
+  }
+
+  const uniformBlockName = getShaderModuleUniformBlockName(module);
+  return extractShaderUniformBlockFieldNames(
+    shaderSource,
+    stage === 'wgsl' ? 'wgsl' : 'glsl',
+    uniformBlockName
+  );
+}
+
+export function getShaderModuleUniformLayoutValidationResult(
+  module: ShaderModule,
+  stage: ShaderModuleUniformLayoutStage
+): ShaderModuleUniformLayoutValidationResult | null {
+  const expectedUniformNames = Object.keys(module.uniformTypes || {});
+  if (!expectedUniformNames.length) {
+    return null;
+  }
+
+  const actualUniformNames = getShaderModuleUniformBlockFields(module, stage);
+  if (!actualUniformNames) {
+    return null;
+  }
+
+  return {
+    moduleName: module.name,
+    uniformBlockName: getShaderModuleUniformBlockName(module),
+    stage,
+    expectedUniformNames,
+    actualUniformNames,
+    matches: areStringArraysEqual(expectedUniformNames, actualUniformNames)
+  };
+}
+
+export function validateShaderModuleUniformLayout(
+  module: ShaderModule,
+  stage: ShaderModuleUniformLayoutStage,
+  options: {
+    log?: Logger;
+    throwOnError?: boolean;
+  } = {}
+): ShaderModuleUniformLayoutValidationResult | null {
+  const validationResult = getShaderModuleUniformLayoutValidationResult(module, stage);
+  if (!validationResult || validationResult.matches) {
+    return validationResult;
+  }
+
+  const message = formatShaderModuleUniformLayoutError(validationResult);
+  options.log?.error?.(message, validationResult)();
+
+  if (options.throwOnError !== false) {
+    assert(false, message);
+  }
+
+  return validationResult;
+}
+
+function extractShaderUniformBlockFieldNames(
+  shaderSource: string,
+  language: 'glsl' | 'wgsl',
+  uniformBlockName: string
+): string[] | null {
+  const sourceBody =
+    language === 'wgsl'
+      ? extractWGSLStructBody(shaderSource, uniformBlockName)
+      : extractGLSLUniformBlockBody(shaderSource, uniformBlockName);
+
+  if (!sourceBody) {
+    return null;
+  }
+
+  const fieldNames: string[] = [];
+
+  for (const sourceLine of sourceBody.split('\n')) {
+    const line = sourceLine.replace(/\/\/.*$/, '').trim();
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+
+    const fieldMatch =
+      language === 'wgsl'
+        ? line.match(/^([A-Za-z0-9_]+)\s*:/)
+        : line.match(
+            /^(?:uniform\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/
+          );
+
+    if (fieldMatch) {
+      fieldNames.push(fieldMatch[1]);
+    }
+  }
+
+  return fieldNames;
+}
+
+function extractWGSLStructBody(shaderSource: string, uniformBlockName: string): string | null {
+  const structMatch = new RegExp(`\\bstruct\\s+${uniformBlockName}\\b`, 'm').exec(shaderSource);
+  if (!structMatch) {
+    return null;
+  }
+
+  const openBraceIndex = shaderSource.indexOf('{', structMatch.index);
+  if (openBraceIndex < 0) {
+    return null;
+  }
+
+  let braceDepth = 0;
+  for (let index = openBraceIndex; index < shaderSource.length; index++) {
+    const character = shaderSource[index];
+    if (character === '{') {
+      braceDepth++;
+      continue;
+    }
+    if (character !== '}') {
+      continue;
+    }
+
+    braceDepth--;
+    if (braceDepth === 0) {
+      return shaderSource.slice(openBraceIndex + 1, index);
+    }
+  }
+
+  return null;
+}
+
+function extractGLSLUniformBlockBody(
+  shaderSource: string,
+  uniformBlockName: string
+): string | null {
+  const sourceMatch = shaderSource.match(
+    new RegExp(`uniform\\s+${uniformBlockName}\\s*\\{([\\s\\S]*?)\\}\\s*[A-Za-z0-9_]+\\s*;`, 'm')
+  );
+
+  return sourceMatch?.[1] || null;
+}
+
+function areStringArraysEqual(leftValues: string[], rightValues: string[]): boolean {
+  if (leftValues.length !== rightValues.length) {
+    return false;
+  }
+
+  for (let valueIndex = 0; valueIndex < leftValues.length; valueIndex++) {
+    if (leftValues[valueIndex] !== rightValues[valueIndex]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function formatShaderModuleUniformLayoutError(
+  validationResult: ShaderModuleUniformLayoutValidationResult
+): string {
+  return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${
+    validationResult.uniformBlockName
+  } does not match module.uniformTypes.\nExpected: ${validationResult.expectedUniformNames.join(
+    ', '
+  )}\nActual: ${validationResult.actualUniformNames.join(', ')}`;
+}

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

@@ -9,7 +9,7 @@ import {
   makePropValidators,
   getValidatedProperties
 } from '../filters/prop-types';
-import type {UniformSizes, UniformTypes, UniformValue} from '../utils/uniform-types';
+import type {ShaderModuleUniformValue, UniformTypes, UniformValue} from '../utils/uniform-types';
 import {ShaderInjection, normalizeInjections} from '../shader-assembly/shader-injections';
 
 // To avoid dependency on core module, do not import `Binding` type.
@@ -22,6 +22,11 @@ export type UniformInfo = {
   format?: UniformFormat;
 } & PropType;
 
+export type ShaderModuleBindingLayout = {
+  name: string;
+  group: number;
+};
+
 // Helper types
 type BindingKeys<T> = {[K in keyof T]: T[K] extends UniformValue ? never : K}[keyof T];
 type UniformKeys<T> = {[K in keyof T]: T[K] extends UniformValue ? K : never}[keyof T];
@@ -37,7 +42,7 @@ export type PickUniforms<T> = {[K in UniformKeys<Required<T>>]: T[K]};
  */
 export type ShaderModule<
   PropsT extends Record<string, any> = Record<string, any>,
-  UniformsT extends Record<string, UniformValue> = PickUniforms<PropsT>,
+  UniformsT extends Record<string, ShaderModuleUniformValue> = PickUniforms<PropsT>,
   BindingsT extends Record<string, Binding> = PickBindings<PropsT>
 > = {
   /** Used for type inference not for values */
@@ -46,6 +51,10 @@ export type ShaderModule<
   uniforms?: UniformsT;
   /** Used for type inference, not currently used for values */
   bindings?: BindingsT;
+  /** Logical bind-group assignment for bindings declared by this module */
+  bindingLayout?: readonly ShaderModuleBindingLayout[];
+  /** Preferred starting binding slot for this module's WGSL `@binding(auto)` declarations. */
+  firstBindingSlot?: number;
 
   name: string;
 
@@ -58,8 +67,6 @@ export type ShaderModule<
 
   /** Uniform shader types @note: Both order and types MUST match uniform block declarations in shader */
   uniformTypes?: Required<UniformTypes<UniformsT>>; // Record<keyof UniformsT, UniformFormat>;
-  /** Uniform shader array sizes (default 1) */
-  uniformSizes?: Required<UniformSizes<UniformsT>>;
   /** Uniform JS prop types  */
   propTypes?: Record<keyof UniformsT, UniformInfo>;
   /** Default uniform values */
@@ -152,12 +159,15 @@ export function initializeShaderModule(module: ShaderModule): void {
 
 /** Convert module props to uniforms */
 export function getShaderModuleUniforms<
-  ShaderModuleT extends ShaderModule<Record<string, unknown>, Record<string, UniformValue>>
+  ShaderModuleT extends ShaderModule<
+    Record<string, unknown>,
+    Record<string, ShaderModuleUniformValue>
+  >
 >(
   module: ShaderModuleT,
   props?: ShaderModuleT['props'],
   oldUniforms?: ShaderModuleT['uniforms']
-): Record<string, Binding | UniformValue> {
+): Record<string, Binding | ShaderModuleUniformValue> {
   initializeShaderModule(module);
 
   const uniforms = oldUniforms || {...module.defaultUniforms};

package/src/lib/utils/uniform-types.ts

@@ -14,6 +14,8 @@ import type {
   NumberArray16
 } from '@math.gl/core';
 
+import type {CompositeShaderType} from '@luma.gl/core';
+
 /*
  * Allowed types to be used for uniform values
  *
@@ -37,7 +39,18 @@ export type UniformValue = Readonly<
   | Matrix4
 >;
 
-type UniformType<ValueT extends UniformValue> = ValueT extends number | boolean
+export type ShaderModuleUniformValue =
+  | UniformValue
+  | ShaderModuleUniformStruct
+  | ShaderModuleUniformArray;
+
+export type ShaderModuleUniformStruct = {
+  [name: string]: ShaderModuleUniformValue | undefined;
+};
+
+export type ShaderModuleUniformArray = ReadonlyArray<ShaderModuleUniformValue | undefined>;
+
+type UniformLeafType<ValueT extends UniformValue> = ValueT extends number | boolean
   ? 'f32' | 'i32' | 'u32'
   : ValueT extends Readonly<NumberArray2 | Vector2>
     ? 'vec2<f32>' | 'vec2<i32>' | 'vec2<u32>'
@@ -57,14 +70,16 @@ type UniformType<ValueT extends UniformValue> = ValueT extends number | boolean
                   ? 'mat4x4<f32>'
                   : never;
 
-type UniformProps = {
-  [name: string]: UniformValue;
-};
+type UniformType<ValueT> = ValueT extends UniformValue
+  ? UniformLeafType<ValueT>
+  : ValueT extends ReadonlyArray<infer ElementT>
+    ? readonly [UniformType<NonNullable<ElementT>>, number]
+    : ValueT extends Record<string, unknown>
+      ? {[name in keyof ValueT]-?: UniformType<NonNullable<ValueT[name]>>}
+      : never;
 
-export type UniformTypes<PropsT extends UniformProps> = {
-  [name in keyof PropsT]: UniformType<PropsT[name]>;
-};
+type UniformProps = Record<string, unknown>;
 
-export type UniformSizes<PropsT extends UniformProps> = {
-  [name in keyof PropsT]: number;
+export type UniformTypes<PropsT extends UniformProps> = {
+  [name in keyof PropsT]-?: UniformType<NonNullable<PropsT[name]>> & CompositeShaderType;
 };

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

@@ -183,6 +183,9 @@ vec4 picking_filterColor(vec4 color) {
 `;
 
 /**
+ * Deprecated legacy picking module retained for compatibility with existing
+ * shadertools users such as deck.gl. Keep the shader contract stable.
+ *
  * Provides support for color-coding-based picking and highlighting.
  * In particular, supports picking a specific instance in an instanced
  * draw call and highlighting an instance based on its picking color,

package/src/modules/engine/skin/skin.ts

@@ -13,7 +13,7 @@ struct skinUniforms {
   jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
 };
 
-@binding(19) @group(0) var<uniform> skin: skinUniforms;
+@group(0) @binding(auto) var<uniform> skin: skinUniforms;
 
 fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
   return (weights.x * skin.jointMatrix[joints.x])
@@ -54,6 +54,7 @@ export const skin = {
   uniforms: {} as SkinUniforms,
 
   name: 'skin',
+  bindingLayout: [{name: 'skin', group: 0}],
   dependencies: [],
   source,
   vs,
@@ -108,9 +109,6 @@ export const skin = {
   },
 
   uniformTypes: {
-    jointMatrix: 'mat4x4<f32>'
-  },
-  uniformSizes: {
-    jointMatrix: SKIN_MAX_JOINTS
+    jointMatrix: ['mat4x4<f32>', SKIN_MAX_JOINTS]
   }
 } as const satisfies ShaderModule<SkinProps, SkinUniforms>;

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

@@ -9,6 +9,7 @@ import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
 import {PHONG_WGSL} from '../phong-material/phong-shaders-wgsl';
 
 export type GouraudMaterialProps = {
+  unlit?: boolean;
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
@@ -21,6 +22,7 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   props: {} as GouraudMaterialProps,
 
   name: 'gouraudMaterial',
+  bindingLayout: [{name: 'gouraudMaterial', group: 3}],
   // Note these are switched between phong and gouraud
   vs: PHONG_FS.replace('phongMaterial', 'gouraudMaterial'),
   fs: PHONG_VS.replace('phongMaterial', 'gouraudMaterial'),
@@ -30,12 +32,14 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   },
   dependencies: [lighting],
   uniformTypes: {
+    unlit: 'i32',
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
     specularColor: 'vec3<f32>'
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,

package/src/modules/lighting/ibl/ibl.ts

@@ -0,0 +1,44 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Texture} from '@luma.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type IBLBindings = {
+  pbr_diffuseEnvSampler?: Texture | null;
+  pbr_specularEnvSampler?: Texture | null;
+  pbr_brdfLUT?: Texture | null;
+};
+
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+
+export const ibl = {
+  name: 'ibl',
+  firstBindingSlot: 32,
+  bindingLayout: [
+    {name: 'pbr_diffuseEnvSampler', group: 2},
+    {name: 'pbr_specularEnvSampler', group: 2},
+    {name: 'pbr_brdfLUT', group: 2}
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+} as const satisfies ShaderModule<IBLBindings, {}, IBLBindings>;

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

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {LAMBERT_WGSL} from './lambert-shaders-wgsl';
+import {LAMBERT_VS, LAMBERT_FS} from './lambert-shaders-glsl';
+
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+  unlit?: boolean;
+  ambient?: number;
+  diffuse?: number;
+};
+
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export const lambertMaterial: ShaderModule<LambertMaterialProps> = {
+  name: 'lambertMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'lambertMaterial', group: 3}],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: 'i32',
+    ambient: 'f32',
+    diffuse: 'f32'
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props?: LambertMaterialProps) {
+    return {...lambertMaterial.defaultUniforms, ...props};
+  }
+};

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

@@ -0,0 +1,61 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const LAMBERT_VS = /* glsl */ `\
+uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`;
+
+export const LAMBERT_FS = /* glsl */ `\
+uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  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);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`;

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

@@ -0,0 +1,73 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const LAMBERT_WGSL = /* wgsl */ `\
+struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * 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 (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`;