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

package/dist/dist.dev.js

@@ -1386,6 +1386,7 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
   function resolveShaderPlugins(plugins = [], shaderLanguage) {
     const resolved = {
       modules: [],
+      hooks: [],
       defines: {},
       injections: {},
       vertexInputs: {},
@@ -1450,14 +1451,45 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
       }
       resolved.interStageVariables[name] = normalizedVarying;
     }
-    for (const injection of plugin.injections || []) {
+    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;
-      assertNamedShaderPluginInjectionTarget(injection.target);
-      if (!resolved.injections[injection.target]) {
-        resolved.injections[injection.target] = [];
+      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({
         pluginName: plugin.name,
         injection: source7,
@@ -1486,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*;/;
@@ -2712,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;
   }
@@ -2745,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,
@@ -2812,7 +2872,7 @@ 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 = {};
@@ -3470,7 +3530,7 @@ ${getApplicationDefines(allDefines)}
 `;
         break;
     }
-    const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+    const hookFunctionMap = normalizeShaderHooks(hookFunctions, options.pluginHooks, "glsl");
     const hookInjections = {};
     const declInjections = {};
     const mainInjections = {};
@@ -11673,7 +11733,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 +11835,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 +11849,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 +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);
         }
       }
@@ -15877,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,
@@ -17406,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);
         }
       }
@@ -17766,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,