@luma.gl/shaders 10.0.0-alpha.6 → 10.0.0-alpha.8

package/src/index.ts

@@ -20,13 +20,14 @@ export {
 export type {ShaderModule} from './lib/shader-module/shader-module';
 export type {
   ResolvedShaderPlugins,
-  ResolvedShaderPluginVarying,
+  ResolvedShaderPluginInterStageVariable,
   ShaderPlugin,
+  ShaderPluginHook,
+  ShaderPluginTarget,
   ShaderPluginInjection,
   ShaderPluginInjectionTarget,
-  ShaderPluginVarying,
-  ShaderPluginVaryingInterpolation,
-  ShaderPluginVariant
+  ShaderPluginInterStageVariable,
+  ShaderPluginInterStageVariableInterpolation
 } from './lib/shader-plugin';
 export type {
   ShaderPass,

package/src/lib/glsl-shader-assembler.ts

@@ -23,7 +23,7 @@ export class GLSLShaderAssembler extends ShaderAssembler {
     modules: ShaderModule[];
   } {
     const modules = this._getModuleList(props.modules); // Combine with default modules
-    const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions
+    const hookFunctions = [...this._hookFunctions, ...(props.hookFunctions || [])];
     const vertex = this._transpileShader(props, modules, props.vs, 'vertex');
     const fragment = this._transpileShader(props, modules, props.fs, 'fragment');
     const assembled = assembleGLSLShaderPair({

package/src/lib/preprocessor/preprocessor.ts

@@ -104,6 +104,31 @@ function evaluateIfExpression(
     return false;
   }
 
+  const operandPattern = '(?:[A-Za-z_][A-Za-z0-9_]*|[+-]?\\d+(?:\\.\\d+)?)';
+  const comparison = trimmedExpression.match(
+    new RegExp(`^(${operandPattern})\\s*(==|!=|<=|>=|<|>)\\s*(${operandPattern})$`)
+  );
+  if (comparison) {
+    const resolveOperand = (operand: string) =>
+      /^[A-Za-z_]/.test(operand) ? Number(defines[operand] ?? 0) : Number(operand);
+    const left = resolveOperand(comparison[1]);
+    const right = resolveOperand(comparison[3]);
+    switch (comparison[2]) {
+      case '==':
+        return left === right;
+      case '!=':
+        return left !== right;
+      case '<=':
+        return left <= right;
+      case '>=':
+        return left >= right;
+      case '<':
+        return left < right;
+      case '>':
+        return left > right;
+    }
+  }
+
   const negatedDefineMatch = trimmedExpression.match(new RegExp(`^!\\s*${DEFINE_NAME_PATTERN}$`));
   if (negatedDefineMatch) {
     return !Boolean(defines[negatedDefineMatch[1]]);

package/src/lib/shader-assembly/assemble-glsl-shaders.ts

@@ -24,12 +24,12 @@ import {
 } from './shader-hooks';
 import {type ShaderInjection, injectShader} from './shader-injections';
 import {type AttributeShaderType} from '../../types';
-import {type ResolvedShaderPluginVarying} from '../shader-plugin';
+import {type ResolvedShaderPluginInterStageVariable} from '../shader-plugin';
 import {assert} from '../utils/assert';
 import {getShaderInfo} from '../glsl-utils/get-shader-info';
 import {getPlatformShaderDefines} from './platform-defines';
 import {getShaderPluginVertexInputDeclarationsGLSL} from './shader-plugin-vertex-inputs';
-import {assembleShaderPluginVaryingsGLSL} from './shader-plugin-varyings';
+import {assembleShaderPluginInterStageVariablesGLSL} from './shader-plugin-varyings';
 import {transpileGLSLShader} from '../shader-transpiler/transpile-glsl-shader';
 import {warnIfGLSLUniformBlocksAreNotStd140} from '../shader-module/shader-module-uniform-layout';
 
@@ -94,10 +94,11 @@ export function assembleShaderGLSL(
     modules: ShaderModule[];
     defines?: Record<string, boolean | number>;
     hookFunctions?: readonly (ShaderHook | string)[];
+    pluginHooks?: readonly ShaderHook[];
     inject?: Record<string, string | ShaderInjection>;
     pluginInjections?: Record<string, ShaderInjection[]>;
     pluginVertexInputs?: Record<string, AttributeShaderType>;
-    pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
+    pluginInterStageVariables?: Record<string, ResolvedShaderPluginInterStageVariable>;
     prologue?: boolean;
     log?: ShaderAssemblyLog;
   }
@@ -112,7 +113,7 @@ export function assembleShaderGLSL(
     inject = {},
     pluginInjections = {},
     pluginVertexInputs = {},
-    pluginVaryings = {},
+    pluginInterStageVariables = {},
     prologue = true,
     log
   } = options;
@@ -163,7 +164,7 @@ ${getApplicationDefines(allDefines)}
       break;
   }
 
-  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+  const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, 'glsl');
 
   // Add source of dependent modules in resolved order
   const hookInjections: Record<string, ShaderInjection[]> = {};
@@ -181,36 +182,31 @@ ${getApplicationDefines(allDefines)}
       const name = match[3];
       if (hash) {
         if (name === 'decl') {
-          declInjections[key] = [injection];
+          declInjections[key] = [...(declInjections[key] || []), injection];
         } else {
-          mainInjections[key] = [injection];
+          mainInjections[key] = [...(mainInjections[key] || []), injection];
         }
       } else {
-        hookInjections[key] = [injection];
+        hookInjections[key] = [...(hookInjections[key] || []), injection];
       }
     } else {
       // Regex injection
-      mainInjections[key] = [injection];
+      mainInjections[key] = [...(mainInjections[key] || []), injection];
     }
   }
+  // Module helpers may access plugin inputs and varyings. GLSL requires these
+  // interface declarations before the helpers, unlike ordinary #decl injections.
   if (stage === 'vertex') {
     const declarations = getShaderPluginVertexInputDeclarationsGLSL(coreSource, pluginVertexInputs);
-    if (declarations) {
-      declInjections['vs:#decl'] = declInjections['vs:#decl'] || [];
-      declInjections['vs:#decl'].push({
-        injection: declarations,
-        order: Number.MIN_SAFE_INTEGER
-      });
-    }
+    if (declarations) assembledSource += `${declarations}\n`;
   }
-  const pluginVaryingAssembly = assembleShaderPluginVaryingsGLSL(coreSource, stage, pluginVaryings);
+  const pluginVaryingAssembly = assembleShaderPluginInterStageVariablesGLSL(
+    coreSource,
+    stage,
+    pluginInterStageVariables
+  );
   if (pluginVaryingAssembly.declarations) {
-    const declarationTarget = stage === 'vertex' ? 'vs:#decl' : 'fs:#decl';
-    declInjections[declarationTarget] = declInjections[declarationTarget] || [];
-    declInjections[declarationTarget].push({
-      injection: pluginVaryingAssembly.declarations,
-      order: Number.MIN_SAFE_INTEGER
-    });
+    assembledSource += `${pluginVaryingAssembly.declarations}\n`;
   }
   if (pluginVaryingAssembly.initialization) {
     mainInjections['vs:#main-start'] = mainInjections['vs:#main-start'] || [];

package/src/lib/shader-assembly/assemble-wgsl-shaders.ts

@@ -26,7 +26,7 @@ import {PlatformInfo} from './platform-info';
 import {assert} from '../utils/assert';
 import {preprocess} from '../preprocessor/preprocessor';
 import {assembleShaderPluginVertexInputsWGSL} from './shader-plugin-vertex-inputs';
-import {assembleShaderPluginVaryingsWGSL} from './shader-plugin-varyings';
+import {assembleShaderPluginInterStageVariablesWGSL} from './shader-plugin-varyings';
 import {
   normalizeShaderHooks,
   validateShaderHookInjections,
@@ -113,7 +113,7 @@ export function assembleShaderWGSL(
     inject = {},
     pluginInjections = {},
     pluginVertexInputs = {},
-    pluginVaryings = {},
+    pluginInterStageVariables = {},
     vertexEntryPoint = 'vertexMain',
     fragmentEntryPoint = 'fragmentMain',
     log
@@ -130,11 +130,11 @@ export function assembleShaderWGSL(
     vertexEntryPoint,
     pluginVertexInputs
   );
-  const pluginVaryingAssembly = assembleShaderPluginVaryingsWGSL(
+  const pluginVaryingAssembly = assembleShaderPluginInterStageVariablesWGSL(
     pluginVertexInputAssembly.source,
     vertexEntryPoint,
     fragmentEntryPoint,
-    pluginVaryings
+    pluginInterStageVariables
   );
   const coreSource = pluginVaryingAssembly.source;
 
@@ -159,7 +159,7 @@ export function assembleShaderWGSL(
   // `
   // `;
 
-  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+  const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, 'wgsl');
 
   // Add source of dependent modules in resolved order
   const hookInjections: Record<string, ShaderInjection[]> = {};
@@ -177,16 +177,16 @@ export function assembleShaderWGSL(
       const name = match[3];
       if (hash) {
         if (name === 'decl') {
-          declInjections[key] = [injection];
+          declInjections[key] = [...(declInjections[key] || []), injection];
         } else {
-          mainInjections[key] = [injection];
+          mainInjections[key] = [...(mainInjections[key] || []), injection];
         }
       } else {
-        hookInjections[key] = [injection];
+        hookInjections[key] = [...(hookInjections[key] || []), injection];
       }
     } else {
       // Regex injection
-      mainInjections[key] = [injection];
+      mainInjections[key] = [...(mainInjections[key] || []), injection];
     }
   }
   appendGeneratedVertexInputInjections(

package/src/lib/shader-assembly/shader-assembly-types.ts

@@ -7,7 +7,7 @@ import {type ShaderModule} from '../shader-module/shader-module';
 import {type ShaderHook} from './shader-hooks';
 import {type ShaderInjection} from './shader-injections';
 import {type AttributeShaderType} from '../../types';
-import {type ResolvedShaderPluginVarying} from '../shader-plugin';
+import {type ResolvedShaderPluginInterStageVariable} from '../shader-plugin';
 
 export type ShaderAssemblyLog = {
   deprecated?: (...args: unknown[]) => () => unknown;
@@ -44,16 +44,18 @@ export type AssembleShaderOptions = {
   defines?: Record<string, boolean | number>;
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
-  /** Hook functions */
+  /** Per-call hooks, appended after registered assembler hooks; matching names override for this call. */
   hookFunctions?: readonly (ShaderHook | string)[];
+  /** Hook declarations contributed by resolved plugins. */
+  pluginHooks?: readonly ShaderHook[];
   /** Code injections */
   inject?: Record<string, string | ShaderInjection>;
   /** Ordered code injections contributed by ShaderPlugin descriptors. */
   pluginInjections?: Record<string, ShaderInjection[]>;
   /** Vertex inputs contributed by ShaderPlugin descriptors. */
   pluginVertexInputs?: Record<string, AttributeShaderType>;
-  /** Cross-stage varyings contributed by ShaderPlugin descriptors. */
-  pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
+  /** Inter-stage variables contributed by ShaderPlugin descriptors. */
+  pluginInterStageVariables?: Record<string, ResolvedShaderPluginInterStageVariable>;
   /** WGSL vertex entry point selected by the render pipeline. */
   vertexEntryPoint?: string;
   /** Whether WGSL interface scanning should include vertex attributes. */
@@ -78,16 +80,18 @@ export type AssembleStageOptions = {
   defines?: Record<string, boolean | number>;
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
-  /** Hook functions */
+  /** Per-call hooks, appended after registered assembler hooks; matching names override for this call. */
   hookFunctions?: readonly (ShaderHook | string)[];
+  /** Hook declarations contributed by resolved plugins. */
+  pluginHooks?: readonly ShaderHook[];
   /** Code injections */
   inject?: Record<string, string | ShaderInjection>;
   /** Ordered code injections contributed by ShaderPlugin descriptors. */
   pluginInjections?: Record<string, ShaderInjection[]>;
   /** Vertex inputs contributed by ShaderPlugin descriptors. */
   pluginVertexInputs?: Record<string, AttributeShaderType>;
-  /** Cross-stage varyings contributed by ShaderPlugin descriptors. */
-  pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
+  /** Inter-stage variables contributed by ShaderPlugin descriptors. */
+  pluginInterStageVariables?: Record<string, ResolvedShaderPluginInterStageVariable>;
   /** WGSL vertex entry point selected by the render pipeline. */
   vertexEntryPoint?: string;
   /** WGSL fragment entry point selected by the render pipeline. */

package/src/lib/shader-assembly/shader-hooks.ts

@@ -71,14 +71,38 @@ export function getShaderHooks(
  * A later declaration of the same stage-prefixed hook name replaces an earlier one.
  */
 export function normalizeShaderHooks(
-  hookFunctions: readonly (ShaderHook | string)[]
+  hookFunctions: readonly (ShaderHook | string)[],
+  pluginHooks: readonly ShaderHook[] = [],
+  language?: 'glsl' | 'wgsl'
 ): ShaderHookRegistry {
   const result: ShaderHookRegistry = {vertex: {}, fragment: {}};
 
   for (const hookFunction of hookFunctions) {
-    addShaderHookToRegistry(result, hookFunction);
+    const text = typeof hookFunction === 'string' ? hookFunction : hookFunction.hook;
+    const qualified = /^(glsl|wgsl):([\s\S]+)$/.exec(text);
+    if (qualified && qualified[1] !== language) continue;
+    addShaderHookToRegistry(
+      result,
+      qualified
+        ? typeof hookFunction === 'string'
+          ? qualified[2]
+          : {...hookFunction, hook: qualified[2]}
+        : hookFunction
+    );
   }
 
+  for (const hook of pluginHooks) {
+    const normalized = normalizeShaderHooks([hook]);
+    for (const stage of ['vertex', 'fragment'] as const) {
+      for (const [name, declaration] of Object.entries(normalized[stage])) {
+        const existing = result[stage][name];
+        if (existing && existing.signature !== declaration.signature) {
+          throw new Error(`Conflicting ShaderPlugin hook ${name}`);
+        }
+        result[stage][name] = existing || declaration;
+      }
+    }
+  }
   return result;
 }
 
@@ -106,7 +130,12 @@ export function validateShaderHookInjections(
 
     if (!isShaderHookRegistered(registry, hookName)) {
       // The injection targets a hook that was not declared for this stage.
-      throw new Error(`Unknown shader hook ${hookName}`);
+      const pluginNames = [
+        ...new Set(hookInjections[hookName].map(injection => injection.pluginName).filter(Boolean))
+      ];
+      throw new Error(
+        `Unknown shader hook ${hookName}${pluginNames.length ? ` (plugins: ${pluginNames.join(', ')})` : ''}`
+      );
     }
   }
 }
@@ -120,7 +149,7 @@ function addShaderHookToRegistry(
   const stageSeparatorIndex = hook.indexOf(':');
   const shaderStage = hook.slice(0, stageSeparatorIndex);
   const signature = hook.slice(stageSeparatorIndex + 1);
-  const name = hook.replace(/\(.+/, '');
+  const name = hook.split('(')[0].trim();
   const normalizedHook: Required<ShaderHook> = {
     hook: name,
     signature,

package/src/lib/shader-assembly/shader-injections.ts

@@ -21,6 +21,8 @@ export const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__';
  *
  */
 export type ShaderInjection = {
+  /** Plugin responsible for this injection, when supplied by a ShaderPlugin. */
+  pluginName?: string;
   injection: string;
   order: number;
 };

package/src/lib/shader-assembly/shader-plugin-varyings.ts

@@ -3,10 +3,11 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 import {shaderTypeDecoder} from '../../types';
-import type {ResolvedShaderPluginVarying} from '../shader-plugin';
+import type {ResolvedShaderPluginInterStageVariable} from '../shader-plugin';
 import {getGLSLAttributeType} from './shader-plugin-vertex-inputs';
+import {maskWGSLComments} from './wgsl-binding-scan';
 
-export type ShaderPluginVaryingAssembly = {
+export type ShaderPluginInterStageVariableAssembly = {
   source: string;
   declarations: string;
   vertexInitialization: string;
@@ -14,14 +15,14 @@ export type ShaderPluginVaryingAssembly = {
 };
 
 /** Generate one stage of the GLSL interface contributed by shader plugins. */
-export function assembleShaderPluginVaryingsGLSL(
+export function assembleShaderPluginInterStageVariablesGLSL(
   source: string,
   stage: 'vertex' | 'fragment',
-  varyings: Record<string, ResolvedShaderPluginVarying>
+  interStageVariables: Record<string, ResolvedShaderPluginInterStageVariable>
 ): {declarations: string; initialization: string} {
   const declarations: string[] = [];
   const initialization: string[] = [];
-  for (const [name, varying] of Object.entries(varyings)) {
+  for (const [name, varying] of Object.entries(interStageVariables)) {
     assertGLSLVaryingIsNew(source, name);
     const qualifier = varying.interpolation === 'flat' ? 'flat ' : '';
     const direction = stage === 'vertex' ? 'out' : 'in';
@@ -33,14 +34,14 @@ export function assembleShaderPluginVaryingsGLSL(
   return {declarations: declarations.join('\n'), initialization: initialization.join('\n')};
 }
 
-/** Add plugin varyings to selected WGSL vertex and fragment entry points. */
-export function assembleShaderPluginVaryingsWGSL(
+/** Add plugin interStageVariables to selected WGSL vertex and fragment entry points. */
+export function assembleShaderPluginInterStageVariablesWGSL(
   source: string,
   vertexEntryPoint: string,
   fragmentEntryPoint: string,
-  varyings: Record<string, ResolvedShaderPluginVarying>
-): ShaderPluginVaryingAssembly {
-  const entries = Object.entries(varyings);
+  interStageVariables: Record<string, ResolvedShaderPluginInterStageVariable>
+): ShaderPluginInterStageVariableAssembly {
+  const entries = Object.entries(interStageVariables);
   if (entries.length === 0) {
     return {
       source,
@@ -56,19 +57,23 @@ export function assembleShaderPluginVaryingsWGSL(
   let fragmentFunction = getWGSLFunctionRange(transformedSource, fragmentEntryPoint, 'fragment');
   const fragmentInput = getWGSLFragmentStructInput(transformedSource, fragmentFunction);
   const vertexOutputStruct = getWGSLStructRange(transformedSource, vertexOutputType);
-  const fragmentInputStruct = getWGSLStructRange(transformedSource, fragmentInput.type);
+  const fragmentInputStruct = fragmentInput
+    ? getWGSLStructRange(transformedSource, fragmentInput.type)
+    : null;
 
   const interfaceNames = new Set([
     ...getWGSLDeclaredNames(vertexFunction.parameters),
     ...getWGSLDeclaredNames(vertexOutputStruct.body),
     ...getWGSLDeclaredNames(fragmentFunction.parameters),
-    ...getWGSLDeclaredNames(fragmentInputStruct.body)
+    ...getWGSLDeclaredNames(fragmentInputStruct?.body || '')
   ]);
   const usedLocations = new Set([
     ...getWGSLLocations(vertexOutputStruct.body),
-    ...getWGSLLocations(fragmentInputStruct.body)
+    ...getWGSLLocations(fragmentInputStruct?.body || ''),
+    ...getWGSLLocations(fragmentFunction.parameters)
   ]);
   const fields: string[] = [];
+  const fragmentParameters: string[] = [];
   const declarations: string[] = [];
   const vertexInitialization: string[] = [];
   const fragmentInitialization: string[] = [];
@@ -85,7 +90,20 @@ export function assembleShaderPluginVaryingsWGSL(
     fields.push(`  @location(${location})${interpolation} ${name}: ${varying.type},`);
     declarations.push(`var<private> ${name}: ${varying.type};`);
     vertexInitialization.push(`${name} = ${getWGSLZeroValue(varying.type)};`);
-    fragmentInitialization.push(`${name} = ${fragmentInput.name}.${name};`);
+    if (fragmentInput) {
+      fragmentInitialization.push(`${name} = ${fragmentInput.name}.${name};`);
+    } else {
+      const parameterName = `_luma_${name}`;
+      if (interfaceNames.has(parameterName)) {
+        throw new Error(
+          `ShaderPlugin varying "${name}" conflicts with a generated fragment parameter`
+        );
+      }
+      fragmentParameters.push(
+        `@location(${location})${interpolation} ${parameterName}: ${varying.type}`
+      );
+      fragmentInitialization.push(`${name} = ${parameterName};`);
+    }
   }
 
   assertWGSLStructConstructorsAreLocal(
@@ -108,7 +126,7 @@ export function assembleShaderPluginVaryingsWGSL(
   );
 
   const structNames =
-    vertexOutputType === fragmentInput.type
+    !fragmentInput || vertexOutputType === fragmentInput.type
       ? [vertexOutputType]
       : [vertexOutputType, fragmentInput.type];
   const structInsertions = structNames
@@ -122,9 +140,20 @@ export function assembleShaderPluginVaryingsWGSL(
   }
 
   fragmentFunction = getWGSLFunctionRange(transformedSource, fragmentEntryPoint, 'fragment');
-  const fragmentInputPattern = new RegExp(`\\b${escapeRegExp(fragmentInput.name)}\\s*:`);
-  if (!fragmentInputPattern.test(fragmentFunction.parameters)) {
-    throw new Error(`Unable to preserve WGSL fragment input "${fragmentInput.name}"`);
+  if (fragmentParameters.length) {
+    let parameters = fragmentFunction.parameters;
+    const parameterTokens = maskWGSLComments(parameters).trimEnd();
+    if (parameterTokens.trim() && !parameterTokens.endsWith(',')) {
+      const insertionIndex = parameterTokens.length;
+      parameters = `${parameters.slice(0, insertionIndex)},${parameters.slice(insertionIndex)}`;
+    }
+    transformedSource =
+      transformedSource.slice(0, fragmentFunction.openParenthesis + 1) +
+      parameters +
+      '\n  ' +
+      fragmentParameters.join(',\n  ') +
+      '\n' +
+      transformedSource.slice(fragmentFunction.closeParenthesis);
   }
 
   return {
@@ -157,7 +186,9 @@ function getWGSLFunctionRange(
   const functionPattern = new RegExp(`\\bfn\\s+${escapeRegExp(entryPoint)}\\s*\\(`, 'g');
   const match = functionPattern.exec(source);
   if (!match) {
-    throw new Error(`ShaderPlugin varyings require WGSL ${stage} entry point "${entryPoint}"`);
+    throw new Error(
+      `ShaderPlugin interStageVariables require WGSL ${stage} entry point "${entryPoint}"`
+    );
   }
   const openParenthesis = source.indexOf('(', match.index);
   const closeParenthesis = findMatchingDelimiter(source, openParenthesis, '(', ')');
@@ -180,7 +211,7 @@ function getWGSLNamedReturnType(source: string, functionRange: WGSLFunctionRange
   const match = /->\s*([A-Za-z_][\w]*)\s*$/.exec(resultSource.trim());
   if (!match || getWGSLStructRangeOrNull(source, match[1]) === null) {
     throw new Error(
-      'ShaderPlugin varyings require the WGSL vertex entry point to return a named struct'
+      'ShaderPlugin interStageVariables require the WGSL vertex entry point to return a named struct'
     );
   }
   return match[1];
@@ -189,9 +220,9 @@ function getWGSLNamedReturnType(source: string, functionRange: WGSLFunctionRange
 function getWGSLFragmentStructInput(
   source: string,
   functionRange: WGSLFunctionRange
-): {name: string; type: string} {
+): {name: string; type: string} | null {
   const candidates: {name: string; type: string}[] = [];
-  for (const parameter of splitTopLevel(functionRange.parameters, ',')) {
+  for (const parameter of splitTopLevel(maskWGSLComments(functionRange.parameters), ',')) {
     const match =
       /(?:@[A-Za-z_][\w]*(?:\([^)]*\))?\s*)*([A-Za-z_][\w]*)\s*:\s*([A-Za-z_][\w]*)\s*$/.exec(
         parameter.trim()
@@ -200,12 +231,12 @@ function getWGSLFragmentStructInput(
       candidates.push({name: match[1], type: match[2]});
     }
   }
-  if (candidates.length !== 1) {
+  if (candidates.length > 1) {
     throw new Error(
-      `ShaderPlugin varyings require exactly one named WGSL fragment input struct; found ${candidates.length}`
+      `ShaderPlugin interStageVariables require exactly one named WGSL fragment input struct; found ${candidates.length}`
     );
   }
-  return candidates[0];
+  return candidates[0] || null;
 }
 
 function getWGSLStructRange(source: string, structName: string): WGSLStructRange {
@@ -440,13 +471,13 @@ function getFirstUnusedLocation(usedLocations: Set<number>): number {
   return location;
 }
 
-function getGLSLZeroValue(type: ResolvedShaderPluginVarying['type']): string {
+function getGLSLZeroValue(type: ResolvedShaderPluginInterStageVariable['type']): string {
   const {primitiveType, components} = shaderTypeDecoder.getAttributeShaderTypeInfo(type);
   const scalar = primitiveType === 'u32' ? '0u' : primitiveType === 'i32' ? '0' : '0.0';
   return components === 1 ? scalar : `${getGLSLAttributeType(type)}(${scalar})`;
 }
 
-function getWGSLZeroValue(type: ResolvedShaderPluginVarying['type']): string {
+function getWGSLZeroValue(type: ResolvedShaderPluginInterStageVariable['type']): string {
   const {primitiveType, components} = shaderTypeDecoder.getAttributeShaderTypeInfo(type);
   const scalar = `${primitiveType}(0)`;
   return components === 1 ? scalar : `${type}(${scalar})`;

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

@@ -3,7 +3,7 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 import {UniformFormat} from '../../../types';
-import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {ShaderModule} from '../../shader-module/shader-module';
 import {capitalize} from '../utils/capitalize';
 
 export type GLSLGenerationOptions = {

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
-import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {ShaderModule} from '../../shader-module/shader-module';
 import {capitalize} from '../utils/capitalize';
 
 export type WGSLGenerationOptions = {

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

@@ -5,7 +5,7 @@
 import {ShaderModule, initializeShaderModules} from './shader-module';
 import {assert} from '../utils/assert';
 
-// import type {ShaderModule} from '../shader-module/shader-module';
+// import type {ShaderModule} from './shader-module';
 
 type AbstractModule = {
   name: string;