@luma.gl/shaders 10.0.0-alpha.5 → 10.0.0-alpha.7

package/LICENSE

@@ -0,0 +1,38 @@
+luma.gl is provided under the MIT license
+
+Copyright (c) 2020 vis.gl contributors
+
+This software includes parts initially developed by Uber and open sourced under MIT license.
+Copyright (c) 2015 Uber Technologies, Inc.
+
+This software includes parts of PhiloGL (https://github.com/philogb/philogl)
+under MIT license. PhiloGL parts Copyright © 2013 Sencha Labs.
+
+This software includes adaptations of some postprocessing code from 
+THREE.js (https://github.com/mrdoob/three.js/) under MIT license. 
+THREE.js parts Copyright © 2010-2018 three.js authors. 
+
+This software includes adaptations of Gaussian-splat rendering and
+level-of-detail behavior from Spark (https://github.com/sparkjsdev/spark)
+under MIT license.
+Spark parts Copyright © 2025 WORLD LABS TECHNOLOGIES, INC.
+
+Additional attribution given in specific source files. 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/dist.dev.js

@@ -1384,47 +1384,52 @@ ${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: [],
+      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;
-    }
-    if (variant.modules?.length) {
-      resolved.modules.push(...variant.modules);
+  function appendShaderPlugin(resolved, plugin, shaderLanguage) {
+    if (plugin.module) {
+      resolved.modules.push(plugin.module);
     }
-    if (variant.defines) {
-      Object.assign(resolved.defines, variant.defines);
+    if (plugin.defines) {
+      Object.assign(resolved.defines, plugin.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 +1439,28 @@ ${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;
+      resolved.interStageVariables[name] = normalizedVarying;
     }
-    for (const injection of variant.injections || []) {
+    for (const injection of plugin.injections || []) {
+      const source7 = injection[shaderLanguage];
+      if (source7 === void 0) continue;
       assertNamedShaderPluginInjectionTarget(injection.target);
       if (!resolved.injections[injection.target]) {
         resolved.injections[injection.target] = [];
       }
       const injections = resolved.injections[injection.target];
       injections.push({
-        injection: injection.injection,
+        pluginName: plugin.name,
+        injection: source7,
         order: injection.order ?? 0
       });
     }
@@ -1462,7 +1470,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");
@@ -1973,6 +1981,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 +2256,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 +2270,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 +2286,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 +2315,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 +2348,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 +2375,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 +2399,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 +2414,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);
@@ -2677,7 +2730,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(", ")})` : ""}`
+        );
       }
     }
   }
@@ -2734,7 +2792,7 @@ return ${outputName};
       inject = {},
       pluginInjections = {},
       pluginVertexInputs = {},
-      pluginVaryings = {},
+      pluginInterStageVariables = {},
       vertexEntryPoint = "vertexMain",
       fragmentEntryPoint = "fragmentMain",
       log
@@ -2746,11 +2804,11 @@ return ${outputName};
       vertexEntryPoint,
       pluginVertexInputs
     );
-    const pluginVaryingAssembly = assembleShaderPluginVaryingsWGSL(
+    const pluginVaryingAssembly = assembleShaderPluginInterStageVariablesWGSL(
       pluginVertexInputAssembly.source,
       vertexEntryPoint,
       fragmentEntryPoint,
-      pluginVaryings
+      pluginInterStageVariables
     );
     const coreSource = pluginVaryingAssembly.source;
     let assembledSource = "";
@@ -2767,15 +2825,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 +3434,7 @@ return ${outputName};
       inject = {},
       pluginInjections = {},
       pluginVertexInputs = {},
-      pluginVaryings = {},
+      pluginInterStageVariables = {},
       prologue = true,
       log
     } = options;
@@ -3425,35 +3483,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 +3688,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 +3714,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 +11667,21 @@ 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: [
+      {
+        target: "vs: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 +11768,36 @@ 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: [
+      {
+        target: "vs: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} &&
+      },
+      {
+        target: "fs: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