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

package/dist/dist.dev.js

@@ -864,6 +864,129 @@ var __exports__ = (() => {
     return typeof value;
   }
 
+  // src/lib/shader-module/shader-module.ts
+  function initializeShaderModules(modules) {
+    modules.map((module) => initializeShaderModule(module));
+  }
+  function initializeShaderModule(module) {
+    if (module.instance) {
+      return;
+    }
+    initializeShaderModules(module.dependencies || []);
+    const { propTypes = {}, deprecations = [] } = module;
+    const instance = {
+      parsedDeprecations: parseDeprecationDefinitions(deprecations),
+      normalizedInjections: { vertex: {}, fragment: {} }
+    };
+    if (propTypes) {
+      instance.propValidators = makePropValidators(propTypes);
+    }
+    module.instance = instance;
+    let defaultProps = {};
+    if (propTypes) {
+      defaultProps = Object.entries(propTypes).reduce(
+        (obj, [key, propType]) => {
+          const value = propType?.value;
+          if (value) {
+            obj[key] = value;
+          }
+          return obj;
+        },
+        {}
+      );
+    }
+    module.defaultUniforms = {
+      ...module.defaultUniforms,
+      ...defaultProps
+    };
+  }
+  function getShaderModuleUniforms(module, props, oldUniforms) {
+    initializeShaderModule(module);
+    const uniforms2 = oldUniforms || { ...module.defaultUniforms };
+    if (props && module.getUniforms) {
+      return module.getUniforms(props, uniforms2);
+    }
+    return getValidatedProperties(props, module.instance?.propValidators, module.name);
+  }
+  function checkShaderModuleDeprecations(shaderModule, shaderSource, log) {
+    shaderModule.deprecations?.forEach((def) => {
+      if (def.regex?.test(shaderSource)) {
+        if (def.deprecated) {
+          log.deprecated(def.old, def.new)();
+        } else {
+          log.removed(def.old, def.new)();
+        }
+      }
+    });
+  }
+  function parseDeprecationDefinitions(deprecations) {
+    deprecations.forEach((def) => {
+      switch (def.type) {
+        case "function":
+          def.regex = new RegExp(`\\b${def.old}\\(`);
+          break;
+        default:
+          def.regex = new RegExp(`${def.type} ${def.old};`);
+      }
+    });
+    return deprecations;
+  }
+
+  // src/lib/shader-module/shader-module-dependencies.ts
+  function getShaderModuleDependencies(modules) {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const result = [];
+    const nameToModule = /* @__PURE__ */ new Map();
+    function checkNameCollision(module) {
+      const existing = nameToModule.get(module.name);
+      if (existing && existing !== module) {
+        throw new Error(
+          `Shader module name collision: Multiple different module objects share the name "${module.name}". Each module object must have a unique name.`
+        );
+      }
+      nameToModule.set(module.name, module);
+    }
+    function visit(module, path) {
+      if (recursionStack.has(module)) {
+        const cyclePath = [...path, module.name].join(" -> ");
+        throw new Error(`Shader module dependency cycle detected: ${cyclePath}`);
+      }
+      if (visited.has(module)) {
+        return;
+      }
+      checkNameCollision(module);
+      recursionStack.add(module);
+      const newPath = [...path, module.name];
+      if (module.dependencies) {
+        for (const dep of module.dependencies) {
+          visit(dep, newPath);
+        }
+      }
+      recursionStack.delete(module);
+      visited.add(module);
+      result.push(module);
+    }
+    for (const module of modules) {
+      visit(module, []);
+    }
+    const interfaceProviders = /* @__PURE__ */ new Set();
+    for (const module of result) {
+      if (module.implements !== void 0) {
+        assert(!interfaceProviders.has(module.implements));
+        interfaceProviders.add(module.implements);
+      }
+    }
+    initializeShaderModules(result);
+    return result;
+  }
+  function getShaderDependencies(modules) {
+    return getShaderModuleDependencies(modules);
+  }
+  function resolveModules(modules) {
+    return getShaderDependencies(modules);
+  }
+
   // src/module-injectors.ts
   var MODULE_INJECTORS_VS = (
     /* glsl */
@@ -906,37 +1029,34 @@ var __exports__ = (() => {
   var REGEX_END_OF_MAIN = /}\n?[^{}]*$/;
   var fragments = [];
   var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__";
-  function normalizeInjections(injections) {
-    const result = { vertex: {}, fragment: {} };
-    for (const hook in injections) {
-      let injection = injections[hook];
-      const stage = getHookStage(hook);
-      if (typeof injection === "string") {
-        injection = {
-          order: 0,
-          injection
-        };
+  function resolveShaderInjections(declarations, language, pluginName) {
+    const resolved = {};
+    for (const declaration of declarations) {
+      const source7 = declaration[language];
+      if (source7 === void 0) continue;
+      if (declaration.stage !== "vertex" && declaration.stage !== "fragment" || declaration.target.includes(":")) {
+        throw new Error("Shader injection targets require an explicit stage and unqualified target");
       }
-      result[stage][hook] = injection;
-    }
-    return result;
-  }
-  function getHookStage(hook) {
-    const type = hook.slice(0, 2);
-    switch (type) {
-      case "vs":
-        return "vertex";
-      case "fs":
-        return "fragment";
-      default:
-        throw new Error(type);
+      const target = `${declaration.stage === "vertex" ? "vs" : "fs"}:${declaration.target}`;
+      if (!/^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][A-Za-z0-9_]*)$/.test(target)) {
+        throw new Error(`Shader injection target "${target}" must be a named shader anchor or hook`);
+      }
+      resolved[target] ||= [];
+      resolved[target].push({
+        injection: source7,
+        order: declaration.order ?? 0,
+        ...pluginName ? { pluginName } : {}
+      });
     }
+    return resolved;
   }
   function injectShader(source7, stage, inject, injectStandardStubs = false, language = "glsl", entryPoints = {}) {
     const isVertex = stage === "vertex";
     for (const key in inject) {
       const fragmentData = inject[key];
-      fragmentData.sort((a, b) => a.order - b.order);
+      fragmentData.sort(
+        (a, b) => a.order - b.order
+      );
       fragments.length = fragmentData.length;
       for (let i = 0, len = fragmentData.length; i < len; ++i) {
         fragments[i] = fragmentData[i].injection;
@@ -1053,134 +1173,6 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
 
-  // src/lib/shader-module/shader-module.ts
-  function initializeShaderModules(modules) {
-    modules.map((module) => initializeShaderModule(module));
-  }
-  function initializeShaderModule(module) {
-    if (module.instance) {
-      return;
-    }
-    initializeShaderModules(module.dependencies || []);
-    const {
-      propTypes = {},
-      deprecations = [],
-      // defines = {},
-      inject = {}
-    } = module;
-    const instance = {
-      normalizedInjections: normalizeInjections(inject),
-      parsedDeprecations: parseDeprecationDefinitions(deprecations)
-    };
-    if (propTypes) {
-      instance.propValidators = makePropValidators(propTypes);
-    }
-    module.instance = instance;
-    let defaultProps = {};
-    if (propTypes) {
-      defaultProps = Object.entries(propTypes).reduce(
-        (obj, [key, propType]) => {
-          const value = propType?.value;
-          if (value) {
-            obj[key] = value;
-          }
-          return obj;
-        },
-        {}
-      );
-    }
-    module.defaultUniforms = {
-      ...module.defaultUniforms,
-      ...defaultProps
-    };
-  }
-  function getShaderModuleUniforms(module, props, oldUniforms) {
-    initializeShaderModule(module);
-    const uniforms2 = oldUniforms || { ...module.defaultUniforms };
-    if (props && module.getUniforms) {
-      return module.getUniforms(props, uniforms2);
-    }
-    return getValidatedProperties(props, module.instance?.propValidators, module.name);
-  }
-  function checkShaderModuleDeprecations(shaderModule, shaderSource, log) {
-    shaderModule.deprecations?.forEach((def) => {
-      if (def.regex?.test(shaderSource)) {
-        if (def.deprecated) {
-          log.deprecated(def.old, def.new)();
-        } else {
-          log.removed(def.old, def.new)();
-        }
-      }
-    });
-  }
-  function parseDeprecationDefinitions(deprecations) {
-    deprecations.forEach((def) => {
-      switch (def.type) {
-        case "function":
-          def.regex = new RegExp(`\\b${def.old}\\(`);
-          break;
-        default:
-          def.regex = new RegExp(`${def.type} ${def.old};`);
-      }
-    });
-    return deprecations;
-  }
-
-  // src/lib/shader-module/shader-module-dependencies.ts
-  function getShaderModuleDependencies(modules) {
-    const visited = /* @__PURE__ */ new Set();
-    const recursionStack = /* @__PURE__ */ new Set();
-    const result = [];
-    const nameToModule = /* @__PURE__ */ new Map();
-    function checkNameCollision(module) {
-      const existing = nameToModule.get(module.name);
-      if (existing && existing !== module) {
-        throw new Error(
-          `Shader module name collision: Multiple different module objects share the name "${module.name}". Each module object must have a unique name.`
-        );
-      }
-      nameToModule.set(module.name, module);
-    }
-    function visit(module, path) {
-      if (recursionStack.has(module)) {
-        const cyclePath = [...path, module.name].join(" -> ");
-        throw new Error(`Shader module dependency cycle detected: ${cyclePath}`);
-      }
-      if (visited.has(module)) {
-        return;
-      }
-      checkNameCollision(module);
-      recursionStack.add(module);
-      const newPath = [...path, module.name];
-      if (module.dependencies) {
-        for (const dep of module.dependencies) {
-          visit(dep, newPath);
-        }
-      }
-      recursionStack.delete(module);
-      visited.add(module);
-      result.push(module);
-    }
-    for (const module of modules) {
-      visit(module, []);
-    }
-    const interfaceProviders = /* @__PURE__ */ new Set();
-    for (const module of result) {
-      if (module.implements !== void 0) {
-        assert(!interfaceProviders.has(module.implements));
-        interfaceProviders.add(module.implements);
-      }
-    }
-    initializeShaderModules(result);
-    return result;
-  }
-  function getShaderDependencies(modules) {
-    return getShaderModuleDependencies(modules);
-  }
-  function resolveModules(modules) {
-    return getShaderDependencies(modules);
-  }
-
   // src/types/shader-type-decoder.ts
   function getVariableShaderTypeInfo(format) {
     const resolvedFormat = resolveVariableShaderTypeAlias(format);
@@ -1382,10 +1374,10 @@ ${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 resolved = {
       modules: [],
+      hooks: [],
       defines: {},
       injections: {},
       vertexInputs: {},
@@ -1450,19 +1442,41 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
       }
       resolved.interStageVariables[name] = normalizedVarying;
     }
-    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] = [];
+    for (const hook of plugin.hooks || []) {
+      const implementation = hook[shaderLanguage];
+      if (!implementation) continue;
+      const target = `${hook.stage === "vertex" ? "vs" : "fs"}:${hook.name}`;
+      if (!/^(vs|fs):[A-Za-z_][A-Za-z0-9_]*$/.test(target)) {
+        throw new Error(`Invalid ShaderPlugin hook ${target}`);
       }
-      const injections = resolved.injections[injection.target];
-      injections.push({
-        pluginName: plugin.name,
-        injection: source7,
-        order: injection.order ?? 0
-      });
+      const existing = resolved.hooks.find(
+        (value) => value.stage === hook.stage && value.name === hook.name
+      );
+      const previous = existing?.[shaderLanguage];
+      if (previous && (previous.parameters !== implementation.parameters || (previous.returnType || "void") !== (implementation.returnType || "void") || previous.header !== implementation.header || previous.footer !== implementation.footer)) {
+        throw new Error(`Conflicting ShaderPlugin hook ${target}`);
+      }
+      if (!existing)
+        resolved.hooks.push({ name: hook.name, stage: hook.stage, [shaderLanguage]: implementation });
+    }
+    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
+        }
+      ];
+    });
+    const selectedInjections = resolveShaderInjections(pluginInjections, shaderLanguage, plugin.name);
+    for (const [target, injections] of Object.entries(selectedInjections)) {
+      resolved.injections[target] ||= [];
+      resolved.injections[target].push(...injections);
     }
   }
   function assertShaderPluginInterfaceName(name, kind) {
@@ -1479,12 +1493,9 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     }
     return { type: varying.type, interpolation };
   }
-  function assertNamedShaderPluginInjectionTarget(target) {
-    if (!SHADER_PLUGIN_INJECTION_TARGET_REGEX.test(target)) {
-      throw new Error(
-        `ShaderPlugin injection target "${target}" must be a named shader anchor or hook`
-      );
-    }
+  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
@@ -2691,8 +2702,10 @@ return ${outputName};
     let result = "";
     for (const hookName in hookFunctions) {
       const hookFunction = hookFunctions[hookName];
-      const functionPrefix = shaderLanguage === "wgsl" ? "fn" : "void";
-      result += `${functionPrefix} ${hookFunction.signature} {
+      const returnType = hookFunction.returnType || "void";
+      const functionPrefix = shaderLanguage === "wgsl" ? "fn" : returnType;
+      const returnSuffix = shaderLanguage === "wgsl" && returnType !== "void" ? ` -> ${returnType}` : "";
+      result += `${functionPrefix} ${hookFunction.signature}${returnSuffix} {
 `;
       if (hookFunction.header) {
         result += `  ${hookFunction.header}`;
@@ -2712,10 +2725,29 @@ return ${outputName};
     }
     return result;
   }
-  function normalizeShaderHooks(hookFunctions) {
+  function normalizeShaderHooks(hookFunctions, pluginHooks = [], language = "glsl") {
     const result = { vertex: {}, fragment: {} };
-    for (const hookFunction of hookFunctions) {
-      addShaderHookToRegistry(result, hookFunction);
+    for (const hook of hookFunctions) {
+      const implementation = hook[language];
+      if (implementation) {
+        const prefix = hook.stage === "vertex" ? "vs" : "fs";
+        result[hook.stage][`${prefix}:${hook.name}`] = {
+          ...implementation,
+          signature: `${hook.name}(${implementation.parameters})`
+        };
+      }
+    }
+    for (const hook of pluginHooks) {
+      const selected = normalizeShaderHooks([hook], [], language);
+      for (const stage of ["vertex", "fragment"]) {
+        for (const [name, declaration] of Object.entries(selected[stage])) {
+          const existing = result[stage][name];
+          if (existing && (existing.signature !== declaration.signature || (existing.returnType || "void") !== (declaration.returnType || "void"))) {
+            throw new Error(`Conflicting ShaderPlugin hook ${name}`);
+          }
+          result[stage][name] = existing || declaration;
+        }
+      }
     }
     return result;
   }
@@ -2739,30 +2771,6 @@ return ${outputName};
       }
     }
   }
-  function addShaderHookToRegistry(registry, hookFunction) {
-    const options = typeof hookFunction === "string" ? {} : hookFunction;
-    const hook = (typeof hookFunction === "string" ? hookFunction : hookFunction.hook).trim();
-    const stageSeparatorIndex = hook.indexOf(":");
-    const shaderStage = hook.slice(0, stageSeparatorIndex);
-    const signature = hook.slice(stageSeparatorIndex + 1);
-    const name = hook.replace(/\(.+/, "");
-    const normalizedHook = {
-      hook: name,
-      signature,
-      header: options.header || "",
-      footer: options.footer || ""
-    };
-    switch (shaderStage) {
-      case "vs":
-        registry.vertex[name] = normalizedHook;
-        break;
-      case "fs":
-        registry.fragment[name] = normalizedHook;
-        break;
-      default:
-        throw new Error(shaderStage);
-    }
-  }
 
   // src/lib/shader-assembly/assemble-wgsl-shaders.ts
   var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
@@ -2812,13 +2820,16 @@ return ${outputName};
     );
     const coreSource = pluginVaryingAssembly.source;
     let assembledSource = "";
-    const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+    const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, "wgsl");
     const hookInjections = {};
     const declInjections = {};
     const mainInjections = {};
     appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
-    for (const key in inject) {
-      const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
+    const applicationInjections = Array.isArray(inject) ? resolveShaderInjections(inject, "wgsl") : {};
+    appendInjections(applicationInjections, hookInjections, declInjections, mainInjections);
+    const injectionMap = Array.isArray(inject) ? {} : inject;
+    for (const key in injectionMap) {
+      const injection = typeof injectionMap[key] === "string" ? { injection: injectionMap[key], order: 0 } : injectionMap[key];
       const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
       if (match) {
         const hash = match[2];
@@ -2872,19 +2883,6 @@ return ${outputName};
         checkShaderModuleDeprecations(module, coreSource, log);
       }
       assembledSource += moduleSource;
-      const injections = getWGSLModuleInjections(module);
-      for (const key in injections) {
-        const match = /^(v|f)s:#([\w-]+)$/.exec(key);
-        if (match) {
-          const name = match[2];
-          const injectionType = name === "decl" ? declInjections : mainInjections;
-          injectionType[key] = injectionType[key] || [];
-          injectionType[key].push(injections[key]);
-        } else if (isShaderHookRegistered(hookFunctionMap, key)) {
-          hookInjections[key] = hookInjections[key] || [];
-          hookInjections[key].push(injections[key]);
-        }
-      }
     }
     assembledSource += INJECT_SHADER_DECLARATIONS;
     assembledSource = injectShader(
@@ -2944,12 +2942,6 @@ return ${outputName};
       });
     }
   }
-  function getWGSLModuleInjections(module) {
-    return {
-      ...module.instance?.normalizedInjections.vertex || {},
-      ...module.instance?.normalizedInjections.fragment || {}
-    };
-  }
   function getWGSLDeclarationInjections(declarationInjections) {
     const unifiedDeclarations = [
       ...declarationInjections["vs:#decl"] || [],
@@ -3470,13 +3462,16 @@ ${getApplicationDefines(allDefines)}
 `;
         break;
     }
-    const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+    const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, "glsl");
     const hookInjections = {};
     const declInjections = {};
     const mainInjections = {};
     appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
-    for (const key in inject) {
-      const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
+    const applicationInjections = Array.isArray(inject) ? resolveShaderInjections(inject, "glsl") : {};
+    appendInjections(applicationInjections, hookInjections, declInjections, mainInjections);
+    const injectionMap = Array.isArray(inject) ? {} : inject;
+    for (const key in injectionMap) {
+      const injection = typeof injectionMap[key] === "string" ? { injection: injectionMap[key], order: 0 } : injectionMap[key];
       const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
       if (match) {
         const hash = match[2];
@@ -3521,19 +3516,6 @@ ${getApplicationDefines(allDefines)}
       }
       const moduleSource = getShaderModuleSource(module, stage, log);
       assembledSource += moduleSource;
-      const injections = module.instance?.normalizedInjections[stage] || {};
-      for (const key in injections) {
-        const match = /^(v|f)s:#([\w-]+)$/.exec(key);
-        if (match) {
-          const name = match[2];
-          const injectionType = name === "decl" ? declInjections : mainInjections;
-          injectionType[key] = injectionType[key] || [];
-          injectionType[key].push(injections[key]);
-        } else {
-          hookInjections[key] = hookInjections[key] || [];
-          hookInjections[key].push(injections[key]);
-        }
-      }
     }
     validateShaderHookInjections(hookFunctionMap, hookInjections, stage);
     assembledSource += "// ----- MAIN SHADER SOURCE -------------------------";
@@ -3638,11 +3620,10 @@ ${getApplicationDefines(allDefines)}
     }
     /**
      * Register a shader hook
-     * @param hook Stage-prefixed hook signature, such as `vs:OFFSET_POSITION(inout vec4 position)`.
-     * @param options Optional hook metadata such as always-on header and footer source.
+     * @param hook Shared stage and name with language-specific parameters, return type, and source.
      */
-    addShaderHook(hook, options) {
-      this._hookFunctions.push(options ? { ...options, hook } : hook);
+    addShaderHook(hook) {
+      this._hookFunctions.push(hook);
     }
     /**
      * Remove all registered shader hooks, for example before re-registering hooks for a new
@@ -11673,7 +11654,8 @@ fn filter_isVisible(value: f32) -> bool {
     },
     injections: [
       {
-        target: "vs:FILTER_POSITION",
+        stage: "vertex",
+        target: "FILTER_POSITION",
         glsl: `if (!filter_isVisible(filterValues)) {
   position = vec4(2.0, 2.0, 2.0, 1.0);
 }`,
@@ -11774,7 +11756,8 @@ fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
     },
     injections: [
       {
-        target: "vs:CLIP_POSITION",
+        stage: "vertex",
+        target: "CLIP_POSITION",
         glsl: `clipCoordinates = geometryCoordinates;
 if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_INSTANCE} &&
     !clip_isInBounds(instanceCoordinates)) {
@@ -11787,7 +11770,8 @@ if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_INSTANCE} &&
 }`
       },
       {
-        target: "fs:CLIP_COLOR",
+        stage: "fragment",
+        target: "CLIP_COLOR",
         glsl: `if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
     !clip_isInBounds(clipCoordinates)) {
   discard;
@@ -15589,7 +15573,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);
         }
       }
@@ -15877,7 +15861,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,
@@ -17406,7 +17390,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);
         }
       }
@@ -17766,7 +17750,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,