@luma.gl/shadertools 9.2.6 → 9.3.0-alpha.2

package/dist/index.cjs

@@ -45,7 +45,6 @@ __export(dist_exports, {
   getPassthroughFS: () => getPassthroughFS,
   getQualifierDetails: () => getQualifierDetails,
   getShaderInfo: () => getShaderInfo,
-  getShaderLayoutFromWGSL: () => getShaderLayoutFromWGSL,
   getShaderModuleDependencies: () => getShaderModuleDependencies,
   getShaderModuleSource: () => getShaderModuleSource,
   getShaderModuleUniforms: () => getShaderModuleUniforms,
@@ -310,15 +309,15 @@ function getShaderModuleUniforms(module2, props, oldUniforms) {
   }
   return getValidatedProperties(props, (_a = module2.instance) == null ? void 0 : _a.propValidators, module2.name);
 }
-function checkShaderModuleDeprecations(shaderModule, shaderSource, log3) {
+function checkShaderModuleDeprecations(shaderModule, shaderSource, log2) {
   var _a;
   (_a = shaderModule.deprecations) == null ? void 0 : _a.forEach((def) => {
     var _a2;
     if ((_a2 = def.regex) == null ? void 0 : _a2.test(shaderSource)) {
       if (def.deprecated) {
-        log3.deprecated(def.old, def.new)();
+        log2.deprecated(def.old, def.new)();
       } else {
-        log3.removed(def.old, def.new)();
+        log2.removed(def.old, def.new)();
       }
     }
   });
@@ -613,7 +612,7 @@ function assembleShaderWGSL(platformInfo, options) {
     // defines = {},
     hookFunctions = [],
     inject = {},
-    log: log3
+    log: log2
   } = options;
   assert(typeof source3 === "string", "shader source must be a string");
   const coreSource = source3;
@@ -643,8 +642,8 @@ function assembleShaderWGSL(platformInfo, options) {
   }
   const modulesToInject = modules;
   for (const module2 of modulesToInject) {
-    if (log3) {
-      checkShaderModuleDeprecations(module2, coreSource, log3);
+    if (log2) {
+      checkShaderModuleDeprecations(module2, coreSource, log2);
     }
     const moduleSource = getShaderModuleSource(module2, "wgsl");
     assembledSource += moduleSource;
@@ -671,7 +670,7 @@ function assembleShaderWGSL(platformInfo, options) {
 }
 function assembleShaderGLSL(platformInfo, options) {
   var _a;
-  const { source: source3, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
+  const { source: source3, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
   assert(typeof source3 === "string", "shader source must be a string");
   const sourceVersion = language === "glsl" ? getShaderInfo(source3).version : -1;
   const targetVersion = platformInfo.shaderLanguageVersion;
@@ -728,8 +727,8 @@ ${getApplicationDefines(allDefines)}
     }
   }
   for (const module2 of modules) {
-    if (log3) {
-      checkShaderModuleDeprecations(module2, coreSource, log3);
+    if (log2) {
+      checkShaderModuleDeprecations(module2, coreSource, log2);
     }
     const moduleSource = getShaderModuleSource(module2, stage);
     assembledSource += moduleSource;
@@ -1135,97 +1134,15 @@ function generateShaderForModule(module2, options) {
   }
 }
 
-// dist/lib/wgsl/get-shader-layout-wgsl.js
-var import_core = require("@luma.gl/core");
-var import_wgsl_reflect = require("wgsl_reflect");
-function getShaderLayoutFromWGSL(source3) {
-  var _a;
-  const shaderLayout = { attributes: [], bindings: [] };
-  let parsedWGSL;
-  try {
-    parsedWGSL = parseWGSL(source3);
-  } catch (error) {
-    import_core.log.error(error.message)();
-    return shaderLayout;
-  }
-  for (const uniform of parsedWGSL.uniforms) {
-    const members = [];
-    for (const attribute of ((_a = uniform.type) == null ? void 0 : _a.members) || []) {
-      members.push({
-        name: attribute.name,
-        type: getType(attribute.type)
-      });
-    }
-    shaderLayout.bindings.push({
-      type: "uniform",
-      name: uniform.name,
-      group: uniform.group,
-      location: uniform.binding,
-      // @ts-expect-error TODO - unused for now but needs fixing
-      members
-    });
-  }
-  for (const texture of parsedWGSL.textures) {
-    shaderLayout.bindings.push({
-      type: "texture",
-      name: texture.name,
-      group: texture.group,
-      location: texture.binding
-    });
-  }
-  for (const sampler of parsedWGSL.samplers) {
-    shaderLayout.bindings.push({
-      type: "sampler",
-      name: sampler.name,
-      group: sampler.group,
-      location: sampler.binding
-    });
-  }
-  const vertex = parsedWGSL.entry.vertex[0];
-  const attributeCount = (vertex == null ? void 0 : vertex.inputs.length) || 0;
-  for (let i = 0; i < attributeCount; i++) {
-    const wgslAttribute = vertex.inputs[i];
-    if (wgslAttribute.locationType === "location") {
-      const type = getType(wgslAttribute.type);
-      shaderLayout.attributes.push({
-        name: wgslAttribute.name,
-        location: Number(wgslAttribute.location),
-        type
-      });
-    }
-  }
-  return shaderLayout;
-}
-function getType(type) {
-  return (type == null ? void 0 : type.format) ? `${type.name}<${type.format.name}>` : type.name;
-}
-function parseWGSL(source3) {
-  try {
-    return new import_wgsl_reflect.WgslReflect(source3);
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-    let message = "WGSL parse error";
-    if (typeof error === "object" && (error == null ? void 0 : error.message)) {
-      message += `: ${error.message} `;
-    }
-    if (typeof error === "object" && (error == null ? void 0 : error.token)) {
-      message += error.token.line || "";
-    }
-    throw new Error(message, { cause: error });
-  }
-}
-
 // dist/modules/math/fp16/fp16-utils.js
-var import_core2 = require("@math.gl/core");
+var import_core = require("@math.gl/core");
 var float16Tables = null;
 var buffer = new ArrayBuffer(4);
 var floatView = new Float32Array(buffer);
 var uint32View = new Uint32Array(buffer);
 function toHalfFloat(val) {
   float16Tables ||= generateFloat16Tables();
-  val = (0, import_core2.clamp)(val, -65504, 65504);
+  val = (0, import_core.clamp)(val, -65504, 65504);
   floatView[0] = val;
   const f = uint32View[0];
   const e = f >> 23 & 511;
@@ -2571,7 +2488,7 @@ function getUniforms(opts = {}, prevUniforms) {
 }
 
 // dist/modules/lighting/lights/lighting.js
-var import_core3 = require("@luma.gl/core");
+var import_core2 = require("@luma.gl/core");
 
 // dist/modules/lighting/lights/lighting-glsl.js
 var lightingUniformsGLSL = (
@@ -2814,7 +2731,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLig
     currentLight++;
   }
   if (currentLight > MAX_LIGHTS) {
-    import_core3.log.warn("MAX_LIGHTS exceeded")();
+    import_core2.log.warn("MAX_LIGHTS exceeded")();
   }
   lightSourceUniforms.directionalLightCount = directionalLights.length;
   lightSourceUniforms.pointLightCount = pointLights.length;
@@ -3212,6 +3129,40 @@ uniform pbrMaterialUniforms {
   
   bool alphaCutoffEnabled;
   float alphaCutoff; // #ifdef ALPHA_CUTOFF
+
+  vec3 specularColorFactor;
+  float specularIntensityFactor;
+  bool specularColorMapEnabled;
+  bool specularIntensityMapEnabled;
+
+  float ior;
+
+  float transmissionFactor;
+  bool transmissionMapEnabled;
+
+  float thicknessFactor;
+  float attenuationDistance;
+  vec3 attenuationColor;
+
+  float clearcoatFactor;
+  float clearcoatRoughnessFactor;
+  bool clearcoatMapEnabled;
+
+  vec3 sheenColorFactor;
+  float sheenRoughnessFactor;
+  bool sheenColorMapEnabled;
+
+  float iridescenceFactor;
+  float iridescenceIor;
+  vec2 iridescenceThicknessRange;
+  bool iridescenceMapEnabled;
+
+  float anisotropyStrength;
+  float anisotropyRotation;
+  vec2 anisotropyDirection;
+  bool anisotropyMapEnabled;
+
+  float emissiveStrength;
   
   // IBL
   bool IBLenabled;
@@ -3240,6 +3191,29 @@ uniform sampler2D pbr_metallicRoughnessSampler;
 #ifdef HAS_OCCLUSIONMAP
 uniform sampler2D pbr_occlusionSampler;
 #endif
+#ifdef HAS_SPECULARCOLORMAP
+uniform sampler2D pbr_specularColorSampler;
+#endif
+#ifdef HAS_SPECULARINTENSITYMAP
+uniform sampler2D pbr_specularIntensitySampler;
+#endif
+#ifdef HAS_TRANSMISSIONMAP
+uniform sampler2D pbr_transmissionSampler;
+#endif
+#ifdef HAS_CLEARCOATMAP
+uniform sampler2D pbr_clearcoatSampler;
+uniform sampler2D pbr_clearcoatRoughnessSampler;
+#endif
+#ifdef HAS_SHEENCOLORMAP
+uniform sampler2D pbr_sheenColorSampler;
+uniform sampler2D pbr_sheenRoughnessSampler;
+#endif
+#ifdef HAS_IRIDESCENCEMAP
+uniform sampler2D pbr_iridescenceSampler;
+#endif
+#ifdef HAS_ANISOTROPYMAP
+uniform sampler2D pbr_anisotropySampler;
+#endif
 #ifdef USE_IBL
 uniform samplerCube pbr_diffuseEnvSampler;
 uniform samplerCube pbr_specularEnvSampler;
@@ -3607,23 +3581,23 @@ var fragmentInputs: PBRFragmentInputs;
 fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
 {
   var pos: vec4f = pbrProjection.modelMatrix * position;
-  pbr_vPosition = vec3(pos.xyz) / pos.w;
+  fragmentInputs.pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
   let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
   let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
   let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
-  fragmentInputs,pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+  fragmentInputs.pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
   fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
 #ifdef HAS_UV
-  pbr_vUV = uv;
+  fragmentInputs.pbr_vUV = uv;
 #else
-  pbr_vUV = vec2(0.,0.);
+  fragmentInputs.pbr_vUV = vec2(0.,0.);
 #endif
 }
 
@@ -3659,9 +3633,9 @@ struct pbrMaterialUniforms {
   scaleDiffBaseMR: vec4f,
   scaleFGDSpec: vec4f
   // #endif
-} 
-  
-@binding(2) @group(0) var<uniform> material : pbrMaterialUniforms;
+}
+
+@binding(2) @group(0) var<uniform> pbrMaterial : pbrMaterialUniforms;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
@@ -3729,14 +3703,14 @@ fn getNormal() -> vec3f
 {
   // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
-  var pos_dx: vec3f = dFdx(pbr_vPosition);
-  var pos_dy: vec3f = dFdy(pbr_vPosition);
-  var tex_dx: vec3f = dFdx(vec3(pbr_vUV, 0.0));
-  var tex_dy: vec3f = dFdy(vec3(pbr_vUV, 0.0));
+  var pos_dx: vec3f = dFdx(fragmentInputs.pbr_vPosition);
+  var pos_dy: vec3f = dFdy(fragmentInputs.pbr_vPosition);
+  var tex_dx: vec3f = dFdx(vec3(fragmentInputs.pbr_vUV, 0.0));
+  var tex_dy: vec3f = dFdy(vec3(fragmentInputs.pbr_vUV, 0.0));
   var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
 
 #ifdef HAS_NORMALS
-  var ng: vec3f = normalize(pbr_vNormal);
+  var ng: vec3f = normalize(fragmentInputs.pbr_vNormal);
 #else
   var ng: vec3f = cross(pos_dx, pos_dy);
 #endif
@@ -3745,11 +3719,11 @@ fn getNormal() -> vec3f
   var b: vec3f = normalize(cross(ng, t));
   var tbn: mat3f = mat3f(t, b, ng);
 #else // HAS_TANGENTS
-  var tbn: mat3f = pbr_vTBN;
+  var tbn: mat3f = fragmentInputs.pbr_vTBN;
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  vec3 n = texture(pbr_normalSampler, fragmentInputs.pbr_vUV).rgb;
   n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
@@ -3793,7 +3767,7 @@ fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
 // Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
 // See also [1], Equation 1
 fn diffuse(pbrInfo: PBRInfo) -> vec3<f32> {
-  return pbrInfo.diffuseColor / PI;
+  return pbrInfo.diffuseColor / M_PI;
 }
 
 // The following equation models the Fresnel reflectance term of the spec equation (aka F())
@@ -3850,7 +3824,7 @@ fn PBRInfo_setDirectionalLight(pbrInfo: ptr<function, PBRInfo>, lightDirection:
 }
 
 fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight) {
-  let light_direction = normalize(pointLight.position - pbr_vPosition);
+  let light_direction = normalize(pointLight.position - fragmentInputs.pbr_vPosition);
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
@@ -3871,7 +3845,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // The albedo may be defined from a base texture or a flat color
   var baseColor: vec4<f32>;
   #ifdef HAS_BASECOLORMAP
-  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, fragmentInputs.pbr_vUV)) * pbrMaterial.baseColorFactor;
   #else
   baseColor = pbrMaterial.baseColorFactor;
   #endif
@@ -3895,7 +3869,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, pbr_vUV);
+    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, fragmentInputs.pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
     #endif
@@ -3922,7 +3896,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
 
     let n = getNormal();                          // normal at surface point
-    let v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+    let v = normalize(pbrProjection.camera - fragmentInputs.pbr_vPosition);  // Vector from surface point to camera
 
     let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     let reflection = -normalize(reflect(v, n));
@@ -3961,7 +3935,10 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     for (var i = 0; i < lighting.pointLightCount; i++) {
       if (i < lighting.pointLightCount) {
         PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
-        let attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        let attenuation = getPointLightAttenuation(
+          lighting_getPointLight(i),
+          distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
+        );
         color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
       }
     }
@@ -3977,14 +3954,14 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled) {
-      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, pbr_vUV).r;
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, fragmentInputs.pbr_vUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
     #endif
 
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, fragmentInputs.pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
     #endif
@@ -4052,6 +4029,13 @@ var pbrMaterial = {
     HAS_OCCLUSIONMAP: false,
     HAS_BASECOLORMAP: false,
     HAS_METALROUGHNESSMAP: false,
+    HAS_SPECULARCOLORMAP: false,
+    HAS_SPECULARINTENSITYMAP: false,
+    HAS_TRANSMISSIONMAP: false,
+    HAS_CLEARCOATMAP: false,
+    HAS_SHEENCOLORMAP: false,
+    HAS_IRIDESCENCEMAP: false,
+    HAS_ANISOTROPYMAP: false,
     ALPHA_CUTOFF: false,
     USE_IBL: false,
     PBR_DEBUG: false
@@ -4084,7 +4068,32 @@ var pbrMaterial = {
     // debugging flags used for shader output of intermediate PBR variables
     // #ifdef PBR_DEBUG
     scaleDiffBaseMR: "vec4<f32>",
-    scaleFGDSpec: "vec4<f32>"
+    scaleFGDSpec: "vec4<f32>",
+    specularColorFactor: "vec3<f32>",
+    specularIntensityFactor: "f32",
+    specularColorMapEnabled: "i32",
+    specularIntensityMapEnabled: "i32",
+    ior: "f32",
+    transmissionFactor: "f32",
+    transmissionMapEnabled: "i32",
+    thicknessFactor: "f32",
+    attenuationDistance: "f32",
+    attenuationColor: "vec3<f32>",
+    clearcoatFactor: "f32",
+    clearcoatRoughnessFactor: "f32",
+    clearcoatMapEnabled: "i32",
+    sheenColorFactor: "vec3<f32>",
+    sheenRoughnessFactor: "f32",
+    sheenColorMapEnabled: "i32",
+    iridescenceFactor: "f32",
+    iridescenceIor: "f32",
+    iridescenceThicknessRange: "vec2<f32>",
+    iridescenceMapEnabled: "i32",
+    anisotropyStrength: "f32",
+    anisotropyRotation: "f32",
+    anisotropyDirection: "vec2<f32>",
+    anisotropyMapEnabled: "i32",
+    emissiveStrength: "f32"
   }
 };
 //# sourceMappingURL=index.cjs.map