@luma.gl/shadertools 9.1.0-alpha.10 → 9.1.0-alpha.13

package/dist/dist.dev.js

@@ -683,14 +683,14 @@ ${DECLARATION_INJECT_MARKER}
         mainInjections[key] = [injection];
       }
     }
-    const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
+    const modulesToInject = modules;
     for (const module of modulesToInject) {
       if (log2) {
         checkShaderModuleDeprecations(module, coreSource, log2);
       }
-      const moduleSource = getShaderModuleSource(module, stage);
+      const moduleSource = getShaderModuleSource(module, "wgsl");
       assembledSource += moduleSource;
-      const injections = module.injections[stage];
+      const injections = module.injections?.[stage] || {};
       for (const key in injections) {
         const match = /^(v|f)s:#([\w-]+)$/.exec(key);
         if (match) {
@@ -857,12 +857,16 @@ ${getApplicationDefines(allDefines)}
       throw new Error("Shader module must have a name");
     }
     const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-    return `// ----- MODULE ${module.name} ---------------
-
-#define MODULE_${moduleName}
-${moduleSource}
+    let source = `// ----- MODULE ${module.name} ---------------
 
 `;
+    if (stage !== "wgsl") {
+      source += `#define MODULE_${moduleName}
+`;
+    }
+    source += `${moduleSource}
+`;
+    return source;
   }
 
   // src/lib/preprocessor/preprocessor.ts
@@ -6845,7 +6849,7 @@ vec4 picking_filterColor(vec4 color) {
   }
 
   // src/modules/lighting/lights/lighting-uniforms-glsl.ts
-  var lightingUniforms = (
+  var lightingUniformsGLSL = (
     /* glsl */
     `precision highp int;
 
@@ -6901,6 +6905,63 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
   );
 
+  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
+  var lightingUniformsWGSL = (
+    /* wgsl */
+    `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  poightCount: i32,
+  directionalLightCount: i32,
+
+  ambientColor: vec3<f32>,
+
+  // TODO - support multiple lights by uncommenting arrays below
+  lightType: i32,
+  lightColor: vec3<f32>,
+  lightDirection: vec3<f32>,
+  lightPosition: vec3<f32>,
+  lightAttenuation: vec3<f32>,
+
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
+};
+
+// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
+@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+}
+
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
+
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+`
+  );
+
   // src/modules/lighting/lights/lighting.ts
   var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
@@ -6939,8 +7000,9 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
       lightDirection: [1, 1, 1],
       lightAttenuation: [1, 1, 1]
     },
-    vs: lightingUniforms,
-    fs: lightingUniforms,
+    source: lightingUniformsWGSL,
+    vs: lightingUniformsGLSL,
+    fs: lightingUniformsGLSL,
     getUniforms: getUniforms2
   };
   function getUniforms2(props, prevUniforms = {}) {
@@ -7021,6 +7083,36 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   }
 
   // src/modules/lighting/no-material/dirlight.ts
+  var SOURCE_WGSL = (
+    /* WGSL */
+    `  
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
+
+alias DirlightNormal = vec3<f32>;
+
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
+
+@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
+
+// Returns color attenuated by angle from light source
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
+  return vec4<f32>(color.rgb * d, color.a);
+}
+`
+  );
   var VS_GLSL = (
     /* glsl */
     `out vec3 dirlight_vNormal;
@@ -7050,6 +7142,7 @@ vec4 dirlight_filterColor(vec4 color) {
     uniforms: {},
     name: "dirlight",
     dependencies: [],
+    source: SOURCE_WGSL,
     vs: VS_GLSL,
     fs: FS_GLSL,
     // fragmentInputs: [
@@ -7200,6 +7293,97 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     }
   };
 
+  // src/modules/lighting/phong-material/phong-shaders-wgsl.ts
+  var PHONG_WGSL = (
+    /* wgsl */
+    `struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      }
+    }
+  }
+  return lightColor;
+}
+`
+  );
+
   // src/modules/lighting/phong-material/phong-shaders-glsl.ts
   var PHONG_VS = (
     /* glsl */
@@ -7307,6 +7491,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     name: "phong-lighting",
     dependencies: [lighting],
     // Note these are switched between phong and gouraud
+    source: PHONG_WGSL,
     vs: PHONG_VS,
     fs: PHONG_FS,
     defines: {