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

package/dist/dist.dev.js

@@ -1384,47 +1384,53 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
   // src/lib/shader-plugin.ts
   var SHADER_PLUGIN_INJECTION_TARGET_REGEX = /^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][\w-]*)$/;
   function resolveShaderPlugins(plugins = [], shaderLanguage) {
-    const modules = [];
-    const defines = {};
-    const injections = {};
-    const vertexInputs = {};
-    const varyings = {};
+    const resolved = {
+      modules: [],
+      hooks: [],
+      defines: {},
+      injections: {},
+      vertexInputs: {},
+      interStageVariables: {}
+    };
     for (const plugin of plugins) {
-      appendShaderPluginVariant({ modules, defines, injections, vertexInputs, varyings }, plugin);
-      appendShaderPluginVariant(
-        { modules, defines, injections, vertexInputs, varyings },
-        plugin[shaderLanguage]
-      );
+      appendShaderPlugin(resolved, plugin, shaderLanguage);
     }
-    for (const name of Object.keys(varyings)) {
+    const { vertexInputs, interStageVariables } = resolved;
+    for (const name of Object.keys(interStageVariables)) {
       if (vertexInputs[name]) {
         throw new Error(`ShaderPlugin name "${name}" cannot be both a vertex input and a varying`);
       }
     }
-    return { modules, defines, injections, vertexInputs, varyings };
+    return resolved;
   }
-  function mergeShaderPluginModules(modules = [], pluginModules = []) {
+  function mergeShaderPluginModules(modules = [], pluginModules = [], options = {}) {
     const mergedModules = [...modules];
-    const seenModuleNames = new Set(mergedModules.map((module) => module.name));
+    const selectedModules = /* @__PURE__ */ new Map();
+    for (const module of mergedModules) {
+      const selected = selectedModules.get(module.name);
+      if (selected && selected !== module) options.onConflict?.(module.name, selected, module);
+      if (!selected) selectedModules.set(module.name, module);
+    }
     for (const pluginModule of pluginModules) {
-      if (!seenModuleNames.has(pluginModule.name)) {
+      const selected = selectedModules.get(pluginModule.name);
+      if (selected && selected !== pluginModule) {
+        options.onConflict?.(pluginModule.name, selected, pluginModule);
+      }
+      if (!selected) {
         mergedModules.push(pluginModule);
-        seenModuleNames.add(pluginModule.name);
+        selectedModules.set(pluginModule.name, pluginModule);
       }
     }
     return mergedModules;
   }
-  function appendShaderPluginVariant(resolved, variant) {
-    if (!variant) {
-      return;
+  function appendShaderPlugin(resolved, plugin, shaderLanguage) {
+    if (plugin.module) {
+      resolved.modules.push(plugin.module);
     }
-    if (variant.modules?.length) {
-      resolved.modules.push(...variant.modules);
+    if (plugin.defines) {
+      Object.assign(resolved.defines, plugin.defines);
     }
-    if (variant.defines) {
-      Object.assign(resolved.defines, variant.defines);
-    }
-    for (const [name, type] of Object.entries(variant.vertexInputs || {})) {
+    for (const [name, type] of Object.entries(plugin.vertexInputs || {})) {
       assertShaderPluginInterfaceName(name, "vertex input");
       const existingType = resolved.vertexInputs[name];
       if (existingType && existingType !== type) {
@@ -1434,25 +1440,59 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
       }
       resolved.vertexInputs[name] = type;
     }
-    for (const [name, varying] of Object.entries(variant.varyings || {})) {
+    for (const [name, varying] of Object.entries(plugin.interStageVariables || {})) {
       assertShaderPluginInterfaceName(name, "varying");
-      const normalizedVarying = normalizeShaderPluginVarying(name, varying);
-      const existingVarying = resolved.varyings[name];
+      const normalizedVarying = normalizeShaderPluginInterStageVariable(name, varying);
+      const existingVarying = resolved.interStageVariables[name];
       if (existingVarying && (existingVarying.type !== normalizedVarying.type || existingVarying.interpolation !== normalizedVarying.interpolation)) {
         throw new Error(
           `ShaderPlugin varying "${name}" has conflicting declarations "${existingVarying.type}/${existingVarying.interpolation}" and "${normalizedVarying.type}/${normalizedVarying.interpolation}"`
         );
       }
-      resolved.varyings[name] = normalizedVarying;
-    }
-    for (const injection of variant.injections || []) {
-      assertNamedShaderPluginInjectionTarget(injection.target);
-      if (!resolved.injections[injection.target]) {
-        resolved.injections[injection.target] = [];
+      resolved.interStageVariables[name] = normalizedVarying;
+    }
+    for (const hook of plugin.hooks || []) {
+      const declarationSource = typeof hook === "string" ? selectShaderLanguage(hook, shaderLanguage) : void 0;
+      if (typeof hook === "string" && declarationSource === void 0) continue;
+      const signature = typeof hook === "string" ? declarationSource.slice(declarationSource.indexOf("(")) : hook[shaderLanguage];
+      if (signature === void 0) continue;
+      const target = typeof hook === "string" ? declarationSource.split("(")[0] : getShaderPluginTarget(hook);
+      if (!/^(vs|fs):[A-Za-z_][A-Za-z0-9_]*$/.test(target) || !/^\([^]*\)$/.test(signature.trim())) {
+        throw new Error(`Invalid ShaderPlugin hook ${target}`);
+      }
+      const declaration = { hook: `${target}${signature.trim()}` };
+      const existing = resolved.hooks.find((value) => value.hook.split("(")[0] === target);
+      if (existing && existing.hook !== declaration.hook) {
+        throw new Error(`Conflicting ShaderPlugin hook ${target}`);
+      }
+      if (!existing) resolved.hooks.push(declaration);
+    }
+    const pluginInjections = Array.isArray(plugin.injections) ? plugin.injections : Object.entries(plugin.injections || {}).flatMap(([key, source7]) => {
+      const target = selectShaderLanguage(key, shaderLanguage);
+      if (target === void 0) return [];
+      const [stage, ...name] = target.split(":");
+      if (stage !== "vs" && stage !== "fs")
+        throw new Error(`Invalid ShaderPlugin injection ${key}`);
+      return [
+        {
+          stage: stage === "vs" ? "vertex" : "fragment",
+          target: name.join(":"),
+          [shaderLanguage]: source7
+        }
+      ];
+    });
+    for (const injection of pluginInjections) {
+      const source7 = injection[shaderLanguage];
+      if (source7 === void 0) continue;
+      const target = getShaderPluginTarget(injection);
+      assertNamedShaderPluginInjectionTarget(target);
+      if (!resolved.injections[target]) {
+        resolved.injections[target] = [];
       }
-      const injections = resolved.injections[injection.target];
+      const injections = resolved.injections[target];
       injections.push({
-        injection: injection.injection,
+        pluginName: plugin.name,
+        injection: source7,
         order: injection.order ?? 0
       });
     }
@@ -1462,7 +1502,7 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
       throw new Error(`ShaderPlugin ${kind} "${name}" must be a valid non-reserved identifier`);
     }
   }
-  function normalizeShaderPluginVarying(name, varying) {
+  function normalizeShaderPluginInterStageVariable(name, varying) {
     const { primitiveType } = shaderTypeDecoder.getAttributeShaderTypeInfo(varying.type);
     const integerType = primitiveType === "i32" || primitiveType === "u32";
     const interpolation = varying.interpolation || (integerType ? "flat" : "smooth");
@@ -1478,6 +1518,16 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
       );
     }
   }
+  function getShaderPluginTarget(value) {
+    if (value.stage !== "vertex" && value.stage !== "fragment" || value.target.includes(":")) {
+      throw new Error("ShaderPlugin object targets require an explicit stage and unqualified target");
+    }
+    return `${value.stage === "vertex" ? "vs" : "fs"}:${value.target}`;
+  }
+  function selectShaderLanguage(value, language) {
+    const match = /^(glsl|wgsl):([\s\S]+)$/.exec(value);
+    return match ? match[1] === language ? match[2] : void 0 : value;
+  }
 
   // src/lib/shader-module/shader-module-uniform-layout.ts
   var GLSL_UNIFORM_BLOCK_FIELD_REGEXP = /^(?:uniform\s+)?(?:(?:lowp|mediump|highp)\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/;
@@ -1973,6 +2023,29 @@ ${DECLARATION_INJECT_MARKER}
     if (trimmedExpression === "false") {
       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) => /^[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]]);
@@ -2225,10 +2298,10 @@ ${DECLARATION_INJECT_MARKER}
   }
 
   // src/lib/shader-assembly/shader-plugin-varyings.ts
-  function assembleShaderPluginVaryingsGLSL(source7, stage, varyings) {
+  function assembleShaderPluginInterStageVariablesGLSL(source7, stage, interStageVariables) {
     const declarations = [];
     const initialization = [];
-    for (const [name, varying] of Object.entries(varyings)) {
+    for (const [name, varying] of Object.entries(interStageVariables)) {
       assertGLSLVaryingIsNew(source7, name);
       const qualifier = varying.interpolation === "flat" ? "flat " : "";
       const direction = stage === "vertex" ? "out" : "in";
@@ -2239,8 +2312,8 @@ ${DECLARATION_INJECT_MARKER}
     }
     return { declarations: declarations.join("\n"), initialization: initialization.join("\n") };
   }
-  function assembleShaderPluginVaryingsWGSL(source7, vertexEntryPoint, fragmentEntryPoint, varyings) {
-    const entries = Object.entries(varyings);
+  function assembleShaderPluginInterStageVariablesWGSL(source7, vertexEntryPoint, fragmentEntryPoint, interStageVariables) {
+    const entries = Object.entries(interStageVariables);
     if (entries.length === 0) {
       return {
         source: source7,
@@ -2255,18 +2328,20 @@ ${DECLARATION_INJECT_MARKER}
     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 = /* @__PURE__ */ new Set([
       ...getWGSLDeclaredNames2(vertexFunction.parameters),
       ...getWGSLDeclaredNames2(vertexOutputStruct.body),
       ...getWGSLDeclaredNames2(fragmentFunction.parameters),
-      ...getWGSLDeclaredNames2(fragmentInputStruct.body)
+      ...getWGSLDeclaredNames2(fragmentInputStruct?.body || "")
     ]);
     const usedLocations = /* @__PURE__ */ new Set([
       ...getWGSLLocations2(vertexOutputStruct.body),
-      ...getWGSLLocations2(fragmentInputStruct.body)
+      ...getWGSLLocations2(fragmentInputStruct?.body || ""),
+      ...getWGSLLocations2(fragmentFunction.parameters)
     ]);
     const fields = [];
+    const fragmentParameters = [];
     const declarations = [];
     const vertexInitialization = [];
     const fragmentInitialization = [];
@@ -2282,7 +2357,20 @@ ${DECLARATION_INJECT_MARKER}
       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(
       transformedSource,
@@ -2302,16 +2390,21 @@ ${DECLARATION_INJECT_MARKER}
       vertexFunction,
       entries.map(([name]) => name)
     );
-    const structNames = vertexOutputType === fragmentInput.type ? [vertexOutputType] : [vertexOutputType, fragmentInput.type];
+    const structNames = !fragmentInput || vertexOutputType === fragmentInput.type ? [vertexOutputType] : [vertexOutputType, fragmentInput.type];
     const structInsertions = structNames.map((structName) => getWGSLStructRange(transformedSource, structName).closeBrace).sort((left, right) => right - left);
     for (const insertionIndex of structInsertions) {
       transformedSource = transformedSource.slice(0, insertionIndex) + `${fields.join("\n")}
 ` + transformedSource.slice(insertionIndex);
     }
     fragmentFunction = getWGSLFunctionRange(transformedSource, fragmentEntryPoint, "fragment");
-    const fragmentInputPattern = new RegExp(`\\b${escapeRegExp3(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 {
       source: transformedSource,
@@ -2324,7 +2417,9 @@ ${DECLARATION_INJECT_MARKER}
     const functionPattern = new RegExp(`\\bfn\\s+${escapeRegExp3(entryPoint)}\\s*\\(`, "g");
     const match = functionPattern.exec(source7);
     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 = source7.indexOf("(", match.index);
     const closeParenthesis = findMatchingDelimiter2(source7, openParenthesis, "(", ")");
@@ -2346,14 +2441,14 @@ ${DECLARATION_INJECT_MARKER}
     const match = /->\s*([A-Za-z_][\w]*)\s*$/.exec(resultSource.trim());
     if (!match || getWGSLStructRangeOrNull(source7, 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];
   }
   function getWGSLFragmentStructInput(source7, functionRange) {
     const candidates = [];
-    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()
       );
@@ -2361,12 +2456,12 @@ ${DECLARATION_INJECT_MARKER}
         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(source7, structName) {
     const range = getWGSLStructRangeOrNull(source7, structName);
@@ -2659,10 +2754,28 @@ return ${outputName};
     }
     return result;
   }
-  function normalizeShaderHooks(hookFunctions) {
+  function normalizeShaderHooks(hookFunctions, pluginHooks = [], language) {
     const result = { 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"]) {
+        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;
   }
@@ -2677,7 +2790,12 @@ return ${outputName};
         continue;
       }
       if (!isShaderHookRegistered(registry, hookName)) {
-        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(", ")})` : ""}`
+        );
       }
     }
   }
@@ -2687,7 +2805,7 @@ return ${outputName};
     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 = {
       hook: name,
       signature,
@@ -2734,7 +2852,7 @@ return ${outputName};
       inject = {},
       pluginInjections = {},
       pluginVertexInputs = {},
-      pluginVaryings = {},
+      pluginInterStageVariables = {},
       vertexEntryPoint = "vertexMain",
       fragmentEntryPoint = "fragmentMain",
       log
@@ -2746,15 +2864,15 @@ return ${outputName};
       vertexEntryPoint,
       pluginVertexInputs
     );
-    const pluginVaryingAssembly = assembleShaderPluginVaryingsWGSL(
+    const pluginVaryingAssembly = assembleShaderPluginInterStageVariablesWGSL(
       pluginVertexInputAssembly.source,
       vertexEntryPoint,
       fragmentEntryPoint,
-      pluginVaryings
+      pluginInterStageVariables
     );
     const coreSource = pluginVaryingAssembly.source;
     let assembledSource = "";
-    const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+    const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, "wgsl");
     const hookInjections = {};
     const declInjections = {};
     const mainInjections = {};
@@ -2767,15 +2885,15 @@ return ${outputName};
         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 {
-        mainInjections[key] = [injection];
+        mainInjections[key] = [...mainInjections[key] || [], injection];
       }
     }
     appendGeneratedVertexInputInjections(
@@ -3376,7 +3494,7 @@ return ${outputName};
       inject = {},
       pluginInjections = {},
       pluginVertexInputs = {},
-      pluginVaryings = {},
+      pluginInterStageVariables = {},
       prologue = true,
       log
     } = options;
@@ -3412,7 +3530,7 @@ ${getApplicationDefines(allDefines)}
 `;
         break;
     }
-    const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+    const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, "glsl");
     const hookInjections = {};
     const declInjections = {};
     const mainInjections = {};
@@ -3425,35 +3543,30 @@ ${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 {
-        mainInjections[key] = [injection];
+        mainInjections[key] = [...mainInjections[key] || [], injection];
       }
     }
     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}
+`;
     }
-    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}
+`;
     }
     if (pluginVaryingAssembly.initialization) {
       mainInjections["vs:#main-start"] = mainInjections["vs:#main-start"] || [];
@@ -3635,7 +3748,7 @@ ${getApplicationDefines(allDefines)}
      */
     assembleGLSLShaderPair(props) {
       const modules = this._getModuleList(props.modules);
-      const hookFunctions = this._hookFunctions;
+      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({
@@ -3661,7 +3774,7 @@ ${getApplicationDefines(allDefines)}
      */
     assembleWGSLShader(props) {
       const modules = this._getModuleList(props.modules);
-      const hookFunctions = this._hookFunctions;
+      const hookFunctions = [...this._hookFunctions, ...props.hookFunctions || []];
       const translated = this._transpileShader(
         props,
         modules,
@@ -11614,30 +11727,22 @@ fn filter_isVisible(value: f32) -> bool {
   };
   var filterShaderPlugin = {
     name: "filter",
-    modules: [filterShaderModule],
+    module: filterShaderModule,
     vertexInputs: {
       filterValues: "f32"
     },
-    glsl: {
-      injections: [
-        {
-          target: "vs:FILTER_POSITION",
-          injection: `if (!filter_isVisible(filterValues)) {
+    injections: [
+      {
+        stage: "vertex",
+        target: "FILTER_POSITION",
+        glsl: `if (!filter_isVisible(filterValues)) {
   position = vec4(2.0, 2.0, 2.0, 1.0);
-}`
-        }
-      ]
-    },
-    wgsl: {
-      injections: [
-        {
-          target: "vs:FILTER_POSITION",
-          injection: `if (!filter_isVisible(filterValues)) {
+}`,
+        wgsl: `if (!filter_isVisible(filterValues)) {
   *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
 }`
-        }
-      ]
-    }
+      }
+    ]
   };
 
   // src/modules/engine/clip/clip.ts
@@ -11724,48 +11829,38 @@ fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
   };
   var clipShaderPlugin = {
     name: "clip",
-    modules: [clipShaderModule],
-    varyings: {
+    module: clipShaderModule,
+    interStageVariables: {
       clipCoordinates: { type: "vec2<f32>", interpolation: "smooth" }
     },
-    glsl: {
-      injections: [
-        {
-          target: "vs:CLIP_POSITION",
-          injection: `clipCoordinates = geometryCoordinates;
+    injections: [
+      {
+        stage: "vertex",
+        target: "CLIP_POSITION",
+        glsl: `clipCoordinates = geometryCoordinates;
 if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_INSTANCE} &&
     !clip_isInBounds(instanceCoordinates)) {
   position = vec4(2.0, 2.0, 2.0, 1.0);
-}`
-        },
-        {
-          target: "fs:CLIP_COLOR",
-          injection: `if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
-    !clip_isInBounds(clipCoordinates)) {
-  discard;
-}`
-        }
-      ]
-    },
-    wgsl: {
-      injections: [
-        {
-          target: "vs:CLIP_POSITION",
-          injection: `clipCoordinates = geometryCoordinates;
+}`,
+        wgsl: `clipCoordinates = geometryCoordinates;
 if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_INSTANCE} &&
     !clip_isInBounds(instanceCoordinates)) {
   *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
 }`
-        },
-        {
-          target: "fs:CLIP_COLOR",
-          injection: `if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_GEOMETRY} &&
+      },
+      {
+        stage: "fragment",
+        target: "CLIP_COLOR",
+        glsl: `if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`,
+        wgsl: `if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_GEOMETRY} &&
     !clip_isInBounds(clipCoordinates)) {
   discard;
 }`
-        }
-      ]
-    }
+      }
+    ]
   };
 
   // src/modules/engine/skin/skin.ts
@@ -15557,7 +15652,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
       for(int i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
-          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
           color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
         }
       }
@@ -15845,7 +15940,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     // Apply directional light
     for(int i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
           lighting_getDirectionalLight(i).color,
@@ -17374,7 +17469,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       for (var i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
-          PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+          PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
           color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
         }
       }
@@ -17734,7 +17829,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     // Apply directional light
     for (var i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
-        PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+        PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
           lighting_getDirectionalLight(i).color,