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

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

@@ -5,25 +5,81 @@
 import type {ShaderModule} from './shader-module';
 import {assert} from '../utils/assert';
 
+/**
+ * Shader stages supported by shader-module uniform-layout validation helpers.
+ */
 export type ShaderModuleUniformLayoutStage = 'vertex' | 'fragment' | 'wgsl';
 
+/**
+ * Describes the result of comparing declared `uniformTypes` with the fields
+ * found in a shader uniform block.
+ */
 export type ShaderModuleUniformLayoutValidationResult = {
+  /** Name of the shader module being validated. */
   moduleName: string;
+  /** Expected block name derived from the shader module name. */
   uniformBlockName: string;
+  /** Shader stage that was inspected. */
   stage: ShaderModuleUniformLayoutStage;
+  /** Field names declared by the module metadata. */
   expectedUniformNames: string[];
+  /** Field names parsed from the shader source. */
   actualUniformNames: string[];
+  /** Whether the declared and parsed field lists match exactly. */
   matches: boolean;
 };
 
+/**
+ * Parsed information about one GLSL uniform block declaration.
+ */
+export type GLSLUniformBlockInfo = {
+  /** Declared block type name. */
+  blockName: string;
+  /** Optional instance name that follows the block declaration. */
+  instanceName: string | null;
+  /** Raw layout qualifier text, if present. */
+  layoutQualifier: string | null;
+  /** Whether any explicit layout qualifier was present. */
+  hasLayoutQualifier: boolean;
+  /** Whether the block explicitly declares `layout(std140)`. */
+  isStd140: boolean;
+  /** Raw source text inside the block braces. */
+  body: string;
+};
+
+/**
+ * Logging surface used by validation and warning helpers.
+ */
 type Logger = {
+  /** Error logger compatible with luma's deferred log API. */
   error?: (...args: unknown[]) => () => unknown;
+  /** Warning logger compatible with luma's deferred log API. */
+  warn?: (...args: unknown[]) => () => unknown;
 };
 
+/**
+ * Matches one field declaration inside a GLSL uniform block body.
+ */
+const GLSL_UNIFORM_BLOCK_FIELD_REGEXP =
+  /^(?:uniform\s+)?(?:(?:lowp|mediump|highp)\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/;
+/**
+ * Matches full GLSL uniform block declarations, including optional layout qualifiers.
+ */
+const GLSL_UNIFORM_BLOCK_REGEXP =
+  /((?:layout\s*\([^)]*\)\s*)*)uniform\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}\s*([A-Za-z_][A-Za-z0-9_]*)?\s*;/g;
+
+/**
+ * Returns the uniform block type name expected for the supplied shader module.
+ */
 export function getShaderModuleUniformBlockName(module: ShaderModule): string {
   return `${module.name}Uniforms`;
 }
 
+/**
+ * Returns the ordered field names parsed from a shader module's uniform block.
+ *
+ * @returns `null` when the stage has no source or the expected block is absent.
+ */
 export function getShaderModuleUniformBlockFields(
   module: ShaderModule,
   stage: ShaderModuleUniformLayoutStage
@@ -43,6 +99,12 @@ export function getShaderModuleUniformBlockFields(
   );
 }
 
+/**
+ * Computes the validation result for a shader module's declared and parsed
+ * uniform-block field lists.
+ *
+ * @returns `null` when the module has no declared uniform types or no matching block.
+ */
 export function getShaderModuleUniformLayoutValidationResult(
   module: ShaderModule,
   stage: ShaderModuleUniformLayoutStage
@@ -67,6 +129,12 @@ export function getShaderModuleUniformLayoutValidationResult(
   };
 }
 
+/**
+ * Validates that a shader module's parsed uniform block matches `uniformTypes`.
+ *
+ * When a mismatch is detected, the helper logs a formatted error and optionally
+ * throws via {@link assert}.
+ */
 export function validateShaderModuleUniformLayout(
   module: ShaderModule,
   stage: ShaderModuleUniformLayoutStage,
@@ -90,6 +158,67 @@ export function validateShaderModuleUniformLayout(
   return validationResult;
 }
 
+/**
+ * Parses all GLSL uniform blocks in a shader source string.
+ */
+export function getGLSLUniformBlocks(shaderSource: string): GLSLUniformBlockInfo[] {
+  const blocks: GLSLUniformBlockInfo[] = [];
+  const uncommentedSource = stripShaderComments(shaderSource);
+
+  for (const sourceMatch of uncommentedSource.matchAll(GLSL_UNIFORM_BLOCK_REGEXP)) {
+    const layoutQualifier = sourceMatch[1]?.trim() || null;
+    blocks.push({
+      blockName: sourceMatch[2],
+      body: sourceMatch[3],
+      instanceName: sourceMatch[4] || null,
+      layoutQualifier,
+      hasLayoutQualifier: Boolean(layoutQualifier),
+      isStd140: Boolean(
+        layoutQualifier && /\blayout\s*\([^)]*\bstd140\b[^)]*\)/.exec(layoutQualifier)
+      )
+    });
+  }
+
+  return blocks;
+}
+
+/**
+ * Emits warnings for GLSL uniform blocks that do not explicitly declare
+ * `layout(std140)`.
+ *
+ * @returns The list of parsed blocks that were considered non-compliant.
+ */
+export function warnIfGLSLUniformBlocksAreNotStd140(
+  shaderSource: string,
+  stage: Exclude<ShaderModuleUniformLayoutStage, 'wgsl'>,
+  log?: Logger,
+  context?: {label?: string}
+): GLSLUniformBlockInfo[] {
+  const nonStd140Blocks = getGLSLUniformBlocks(shaderSource).filter(block => !block.isStd140);
+  const seenBlockNames = new Set<string>();
+
+  for (const block of nonStd140Blocks) {
+    if (seenBlockNames.has(block.blockName)) {
+      continue;
+    }
+    seenBlockNames.add(block.blockName);
+
+    const shaderLabel = context?.label ? `${context.label} ` : '';
+    const actualLayout = block.hasLayoutQualifier
+      ? `declares ${normalizeWhitespace(block.layoutQualifier!)} instead of layout(std140)`
+      : 'does not declare layout(std140)';
+    const message = `${shaderLabel}${stage} shader uniform block ${
+      block.blockName
+    } ${actualLayout}. luma.gl host-side shader block packing assumes explicit layout(std140) for GLSL uniform blocks. Add \`layout(std140)\` to the block declaration.`;
+    log?.warn?.(message, block)();
+  }
+
+  return nonStd140Blocks;
+}
+
+/**
+ * Extracts field names from the named GLSL or WGSL uniform block/struct.
+ */
 function extractShaderUniformBlockFieldNames(
   shaderSource: string,
   language: 'glsl' | 'wgsl',
@@ -115,9 +244,7 @@ function extractShaderUniformBlockFieldNames(
     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*;/
-          );
+        : line.match(GLSL_UNIFORM_BLOCK_FIELD_REGEXP);
 
     if (fieldMatch) {
       fieldNames.push(fieldMatch[1]);
@@ -127,6 +254,9 @@ function extractShaderUniformBlockFieldNames(
   return fieldNames;
 }
 
+/**
+ * Extracts the body of a WGSL struct with the supplied name.
+ */
 function extractWGSLStructBody(shaderSource: string, uniformBlockName: string): string | null {
   const structMatch = new RegExp(`\\bstruct\\s+${uniformBlockName}\\b`, 'm').exec(shaderSource);
   if (!structMatch) {
@@ -158,17 +288,22 @@ function extractWGSLStructBody(shaderSource: string, uniformBlockName: string):
   return null;
 }
 
+/**
+ * Extracts the body of a named GLSL uniform block from shader source.
+ */
 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')
+  const block = getGLSLUniformBlocks(shaderSource).find(
+    candidate => candidate.blockName === uniformBlockName
   );
-
-  return sourceMatch?.[1] || null;
+  return block?.body || null;
 }
 
+/**
+ * Returns `true` when the two arrays contain the same strings in the same order.
+ */
 function areStringArraysEqual(leftValues: string[], rightValues: string[]): boolean {
   if (leftValues.length !== rightValues.length) {
     return false;
@@ -183,12 +318,103 @@ function areStringArraysEqual(leftValues: string[], rightValues: string[]): bool
   return true;
 }
 
+/**
+ * Formats the standard validation error message for a shader-module layout mismatch.
+ */
 function formatShaderModuleUniformLayoutError(
   validationResult: ShaderModuleUniformLayoutValidationResult
 ): string {
+  const {expectedUniformNames, actualUniformNames} = validationResult;
+  const missingUniformNames = expectedUniformNames.filter(
+    uniformName => !actualUniformNames.includes(uniformName)
+  );
+  const unexpectedUniformNames = actualUniformNames.filter(
+    uniformName => !expectedUniformNames.includes(uniformName)
+  );
+  const mismatchDetails = [
+    `Expected ${expectedUniformNames.length} fields, found ${actualUniformNames.length}.`
+  ];
+  const firstMismatchDescription = getFirstUniformMismatchDescription(
+    expectedUniformNames,
+    actualUniformNames
+  );
+  if (firstMismatchDescription) {
+    mismatchDetails.push(firstMismatchDescription);
+  }
+  if (missingUniformNames.length) {
+    mismatchDetails.push(
+      `Missing from shader block (${missingUniformNames.length}): ${formatUniformNameList(
+        missingUniformNames
+      )}.`
+    );
+  }
+  if (unexpectedUniformNames.length) {
+    mismatchDetails.push(
+      `Unexpected in shader block (${unexpectedUniformNames.length}): ${formatUniformNameList(
+        unexpectedUniformNames
+      )}.`
+    );
+  }
+  if (
+    expectedUniformNames.length <= 12 &&
+    actualUniformNames.length <= 12 &&
+    (missingUniformNames.length || unexpectedUniformNames.length)
+  ) {
+    mismatchDetails.push(`Expected: ${expectedUniformNames.join(', ')}.`);
+    mismatchDetails.push(`Actual: ${actualUniformNames.join(', ')}.`);
+  }
+
   return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${
     validationResult.uniformBlockName
-  } does not match module.uniformTypes.\nExpected: ${validationResult.expectedUniformNames.join(
-    ', '
-  )}\nActual: ${validationResult.actualUniformNames.join(', ')}`;
+  } does not match module.uniformTypes. ${mismatchDetails.join(' ')}`;
+}
+
+/**
+ * Removes line and block comments from shader source before lightweight parsing.
+ */
+function stripShaderComments(shaderSource: string): string {
+  return shaderSource.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+}
+
+/**
+ * Collapses repeated whitespace in a layout qualifier for log-friendly output.
+ */
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function getFirstUniformMismatchDescription(
+  expectedUniformNames: string[],
+  actualUniformNames: string[]
+): string | null {
+  const minimumLength = Math.min(expectedUniformNames.length, actualUniformNames.length);
+  for (let index = 0; index < minimumLength; index++) {
+    if (expectedUniformNames[index] !== actualUniformNames[index]) {
+      return `First mismatch at field ${index + 1}: expected ${
+        expectedUniformNames[index]
+      }, found ${actualUniformNames[index]}.`;
+    }
+  }
+
+  if (expectedUniformNames.length > actualUniformNames.length) {
+    return `Shader block ends after field ${actualUniformNames.length}; expected next field ${
+      expectedUniformNames[actualUniformNames.length]
+    }.`;
+  }
+  if (actualUniformNames.length > expectedUniformNames.length) {
+    return `Shader block has extra field ${actualUniformNames.length}: ${
+      actualUniformNames[expectedUniformNames.length]
+    }.`;
+  }
+
+  return null;
+}
+
+function formatUniformNameList(uniformNames: string[], maxNames = 8): string {
+  if (uniformNames.length <= maxNames) {
+    return uniformNames.join(', ');
+  }
+
+  const remainingCount = uniformNames.length - maxNames;
+  return `${uniformNames.slice(0, maxNames).join(', ')}, ... (${remainingCount} more)`;
 }

package/src/modules/color/float-colors.ts

@@ -0,0 +1,99 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../lib/shader-module/shader-module';
+
+export type FloatColorsProps = {
+  /**
+   * When true, semantic colors are interpreted as 0-255 byte-style values and normalized in shader code.
+   * When false, semantic colors are interpreted directly as floats.
+   */
+  useByteColors?: boolean;
+};
+
+export type FloatColorsUniforms = {
+  /** Controls whether shader helpers normalize semantic colors from byte space. */
+  useByteColors: boolean;
+};
+
+const GLSL_UNIFORMS = /* glsl */ `\
+layout(std140) uniform floatColorsUniforms {
+  float useByteColors;
+} floatColors;
+
+vec3 floatColors_normalize(vec3 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_normalize(vec4 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_premultiplyAlpha(vec4 inputColor) {
+  return vec4(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+vec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {
+  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
+}
+
+vec4 floatColors_premultiply_alpha(vec4 inputColor) {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+vec4 floatColors_unpremultiply_alpha(vec4 inputColor) {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`;
+
+const WGSL_UNIFORMS = /* wgsl */ `\
+struct floatColorsUniforms {
+  useByteColors: f32
+};
+
+@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;
+
+fn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(
+    vec4<f32>(0.0),
+    vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
+    inputColor.a > 0.0
+  );
+}
+
+fn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+fn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`;
+
+export const floatColors = {
+  name: 'floatColors',
+  props: {} as FloatColorsProps,
+  uniforms: {} as FloatColorsUniforms,
+  vs: GLSL_UNIFORMS,
+  fs: GLSL_UNIFORMS,
+  source: WGSL_UNIFORMS,
+  uniformTypes: {
+    useByteColors: 'f32'
+  },
+  defaultUniforms: {
+    useByteColors: true
+  }
+} as const satisfies ShaderModule<FloatColorsProps, FloatColorsUniforms>;

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

@@ -4,6 +4,7 @@
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import type {NumberArray3, NumberArray4} from '@math.gl/core';
+import {normalizeByteColor4, resolveUseByteColors} from '../../../lib/color/normalize-byte-colors';
 
 // cyan color
 const DEFAULT_HIGHLIGHT_COLOR: NumberArray4 = [0, 1, 1, 1];
@@ -22,8 +23,8 @@ export type PickingProps = {
   highlightedObjectColor?: NumberArray3 | null;
   /** Color of visual highlight of "selected" item */
   highlightColor?: NumberArray3 | NumberArray4;
-  /** Color range 0-1 or 0-255 */
-  useFloatColors?: boolean;
+  /** Interpret highlight colors as byte-style 0-255 values. */
+  useByteColors?: boolean;
 };
 
 /**
@@ -39,8 +40,8 @@ export type PickingUniforms = {
   isActive?: boolean;
   /** Set to true when picking an attribute value instead of object index */
   isAttribute?: boolean;
-  /** Color range 0-1 or 0-255 */
-  useFloatColors?: boolean;
+  /** Interpret highlight colors as byte-style 0-255 values. */
+  useByteColors?: boolean;
   /** Do we have a highlighted item? */
   isHighlightActive?: boolean;
   /** Set to a picking color to visually highlight that item */
@@ -50,11 +51,11 @@ export type PickingUniforms = {
 };
 
 const vs = /* glsl */ `\
-uniform pickingUniforms {
+layout(std140) uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -63,12 +64,12 @@ out vec4 picking_vRGBcolor_Avalid;
 
 // Normalize unsigned byte color to 0-1 range
 vec3 picking_normalizeColor(vec3 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 // Normalize unsigned byte color to 0-1 range
 vec4 picking_normalizeColor(vec4 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 bool picking_isColorZero(vec3 color) {
@@ -124,11 +125,11 @@ void picking_setPickingAttribute(vec3 value) {
 `;
 
 const fs = /* glsl */ `\
-uniform pickingUniforms {
+layout(std140) uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -202,7 +203,7 @@ export const picking = {
     isActive: 'f32',
     isAttribute: 'f32',
     isHighlightActive: 'f32',
-    useFloatColors: 'f32',
+    useByteColors: 'f32',
     highlightedObjectColor: 'vec3<f32>',
     highlightColor: 'vec4<f32>'
   },
@@ -210,7 +211,7 @@ export const picking = {
     isActive: false,
     isAttribute: false,
     isHighlightActive: false,
-    useFloatColors: true,
+    useByteColors: true,
     highlightedObjectColor: [0, 0, 0],
     highlightColor: DEFAULT_HIGHLIGHT_COLOR
   },
@@ -222,6 +223,7 @@ export const picking = {
 
 function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): PickingUniforms {
   const uniforms = {} as PickingUniforms;
+  const useByteColors = resolveUseByteColors(opts.useByteColors, true);
 
   if (opts.highlightedObjectColor === undefined) {
     // Unless highlightedObjectColor explicitly null or set, do not update state
@@ -234,11 +236,7 @@ function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): P
   }
 
   if (opts.highlightColor) {
-    const color = Array.from(opts.highlightColor, x => x / 255);
-    if (!Number.isFinite(color[3])) {
-      color[3] = 1;
-    }
-    uniforms.highlightColor = color as NumberArray4;
+    uniforms.highlightColor = normalizeByteColor4(opts.highlightColor, useByteColors);
   }
 
   if (opts.isActive !== undefined) {
@@ -246,8 +244,8 @@ function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): P
     uniforms.isAttribute = Boolean(opts.isAttribute);
   }
 
-  if (opts.useFloatColors !== undefined) {
-    uniforms.useFloatColors = Boolean(opts.useFloatColors);
+  if (opts.useByteColors !== undefined) {
+    uniforms.useByteColors = Boolean(opts.useByteColors);
   }
 
   return uniforms;

package/src/modules/engine/project/project.ts

@@ -78,7 +78,7 @@ varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
 
 // Project uniform block
-uniform Project {
+layout(std140) uniform Project {
   mat4 viewMatrix;
   mat4 projectionMatrix;
   mat4 viewProjectionMatrix;

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

@@ -25,7 +25,7 @@ fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
 
 export const vs = /* glsl */ `\
 
-uniform skinUniforms {
+layout(std140) uniform skinUniforms {
   mat4 jointMatrix[SKIN_MAX_JOINTS];
 } skin;
 

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

@@ -7,6 +7,7 @@ import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
 import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
 import {PHONG_WGSL} from '../phong-material/phong-shaders-wgsl';
+import {normalizeByteColor3, resolveUseByteColors} from '../../../lib/color/normalize-byte-colors';
 
 export type GouraudMaterialProps = {
   unlit?: boolean;
@@ -15,6 +16,7 @@ export type GouraudMaterialProps = {
   /** Specularity exponent */
   shininess?: number;
   specularColor?: [number, number, number];
+  useByteColors?: boolean;
 };
 
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
@@ -36,20 +38,25 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
-    specularColor: 'vec3<f32>'
+    specularColor: 'vec3<f32>',
+    useByteColors: 'i32'
   },
   defaultUniforms: {
     unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
-    specularColor: [0.15, 0.15, 0.15]
+    specularColor: [0.15, 0.15, 0.15],
+    useByteColors: true
   },
 
   getUniforms(props: GouraudMaterialProps) {
     const uniforms = {...props};
     if (uniforms.specularColor) {
-      uniforms.specularColor = uniforms.specularColor.map(x => x / 255) as NumberArray3;
+      uniforms.specularColor = normalizeByteColor3(
+        uniforms.specularColor,
+        resolveUseByteColors(uniforms.useByteColors, true)
+      ) as NumberArray3;
     }
     return {...gouraudMaterial.defaultUniforms, ...uniforms};
   }

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

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 export const LAMBERT_VS = /* glsl */ `\
-uniform lambertMaterialUniforms {
+layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -11,7 +11,7 @@ uniform lambertMaterialUniforms {
 `;
 
 export const LAMBERT_FS = /* glsl */ `\
-uniform lambertMaterialUniforms {
+layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;

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

@@ -37,7 +37,7 @@ struct UniformLight {
   vec2 coneCos;
 };
 
-uniform lightingUniforms {
+layout(std140) uniform lightingUniforms {
   int enabled;
   int directionalLightCount;
   int pointLightCount;