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

package/dist/index.cjs

@@ -620,6 +620,7 @@ function assembleGLSLShaderPair(options) {
   };
 }
 function assembleShaderWGSL(platformInfo, options) {
+  var _a;
   const {
     // id,
     source,
@@ -656,14 +657,14 @@ function assembleShaderWGSL(platformInfo, options) {
       mainInjections[key] = [injection];
     }
   }
-  const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
+  const modulesToInject = modules;
   for (const module2 of modulesToInject) {
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
     }
-    const moduleSource = getShaderModuleSource(module2, stage);
+    const moduleSource = getShaderModuleSource(module2, "wgsl");
     assembledSource += moduleSource;
-    const injections = module2.injections[stage];
+    const injections = ((_a = module2.injections) == null ? void 0 : _a[stage]) || {};
     for (const key in injections) {
       const match = /^(v|f)s:#([\w-]+)$/.exec(key);
       if (match) {
@@ -821,12 +822,16 @@ function getShaderModuleSource(module2, stage) {
     throw new Error("Shader module must have a name");
   }
   const moduleName = module2.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-  return `// ----- MODULE ${module2.name} ---------------
-
-#define MODULE_${moduleName}
-${moduleSource}
+  let source = `// ----- MODULE ${module2.name} ---------------
 
 `;
+  if (stage !== "wgsl") {
+    source += `#define MODULE_${moduleName}
+`;
+  }
+  source += `${moduleSource}
+`;
+  return source;
 }
 
 // dist/lib/preprocessor/preprocessor.js
@@ -1690,7 +1695,7 @@ function getUniforms(opts = {}, prevUniforms) {
 }
 
 // dist/modules/lighting/lights/lighting-uniforms-glsl.js
-var lightingUniforms = (
+var lightingUniformsGLSL = (
   /* glsl */
   `precision highp int;
 
@@ -1746,6 +1751,63 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
 );
 
+// dist/modules/lighting/lights/lighting-uniforms-wgsl.js
+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;
+}
+`
+);
+
 // dist/modules/lighting/lights/lighting.js
 var MAX_LIGHTS = 5;
 var COLOR_FACTOR = 255;
@@ -1789,8 +1851,9 @@ var lighting = {
     lightDirection: [1, 1, 1],
     lightAttenuation: [1, 1, 1]
   },
-  vs: lightingUniforms,
-  fs: lightingUniforms,
+  source: lightingUniformsWGSL,
+  vs: lightingUniformsGLSL,
+  fs: lightingUniformsGLSL,
   getUniforms: getUniforms2
 };
 function getUniforms2(props, prevUniforms = {}) {
@@ -1868,6 +1931,36 @@ function convertColor(colorDef = {}) {
 }
 
 // dist/modules/lighting/no-material/dirlight.js
+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;
@@ -1897,6 +1990,7 @@ var dirlight = {
   uniforms: {},
   name: "dirlight",
   dependencies: [],
+  source: SOURCE_WGSL,
   vs: VS_GLSL,
   fs: FS_GLSL,
   // fragmentInputs: [
@@ -2047,6 +2141,97 @@ var gouraudMaterial = {
   }
 };
 
+// dist/modules/lighting/phong-material/phong-shaders-wgsl.js
+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;
+}
+`
+);
+
 // dist/modules/lighting/phong-material/phong-shaders-glsl.js
 var PHONG_VS = (
   /* glsl */
@@ -2154,6 +2339,7 @@ var phongMaterial = {
   name: "phong-lighting",
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
+  source: PHONG_WGSL,
   vs: PHONG_VS,
   fs: PHONG_FS,
   defines: {