@luma.gl/shadertools 9.0.21 → 9.0.24

package/dist/index.cjs

@@ -1820,7 +1820,7 @@ var gouraudMaterial = {
     if (uniforms.specularColor) {
       uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
     }
-    return { ...gouraudMaterial.defaultUniforms, ...props };
+    return { ...gouraudMaterial.defaultUniforms, ...uniforms };
   }
 };
 
@@ -1851,38 +1851,32 @@ var phongMaterial = {
     if (uniforms.specularColor) {
       uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
     }
-    return { ...phongMaterial.defaultUniforms, ...props };
+    return { ...phongMaterial.defaultUniforms, ...uniforms };
   }
 };
 
 // dist/modules/lighting/pbr-material/pbr-vertex-glsl.js
-var vs2 = `uniform projection {
-mat4 u_MVPMatrix;
-mat4 u_ModelMatrix;
-mat4 u_NormalMatrix;
-vec3 u_Camera;
-}
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+var vs2 = `out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+out mat3 pbr_vTBN;
 # else
-varying vec3 pbr_vNormal;
+out vec3 pbr_vNormal;
 # endif
 #endif
 void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
 {
-vec4 pos = u_ModelMatrix * position;
+vec4 pos = pbrProjection.modelMatrix * position;
 pbr_vPosition = vec3(pos.xyz) / pos.w;
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
+vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
 vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
 pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else
-pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 #ifdef HAS_UV
@@ -1895,10 +1889,7 @@ pbr_vUV = vec2(0.,0.);
 
 // dist/modules/lighting/pbr-material/pbr-fragment-glsl.js
 var fs3 = `precision highp float;
-uniform Projection {
-uniform vec3 u_Camera;
-};
-uniform pbrMaterial {
+uniform pbrMaterialUniforms {
 bool unlit;
 bool baseColorMapEnabled;
 vec4 baseColorFactor;
@@ -1916,34 +1907,34 @@ bool IBLenabled;
 vec2 scaleIBLAmbient;
 vec4 scaleDiffBaseMR;
 vec4 scaleFGDSpec;
-} u_pbrMaterial;
+} pbrMaterial;
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_metallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
+uniform sampler2D pbr_occlusionSampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+in mat3 pbr_vTBN;
 #else
-varying vec3 pbr_vNormal;
+in vec3 pbr_vNormal;
 #endif
 #endif
 struct PBRInfo {
@@ -1998,8 +1989,8 @@ mat3 tbn = mat3(t, b, ng);
 mat3 tbn = pbr_vTBN;
 #endif
 #ifdef HAS_NORMALMAP
-vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
-n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));
+vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #else
 vec3 n = normalize(tbn[2].xyz);
 #endif
@@ -2010,18 +2001,18 @@ vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
 {
 float mipCount = 9.0;
 float lod = (pbrInfo.perceptualRoughness * mipCount);
-vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
 vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 #ifdef USE_TEX_LOD
-vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
 vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
-diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
-specular *= u_pbrMaterial.scaleIBLAmbient.y;
+diffuse *= pbrMaterial.scaleIBLAmbient.x;
+specular *= pbrMaterial.scaleIBLAmbient.y;
 return diffuse + specular;
 }
 #endif
@@ -2081,24 +2072,24 @@ return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 vec4 pbr_filterColor(vec4 colorUnused)
 {
 #ifdef HAS_BASECOLORMAP
-vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
+vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-vec4 baseColor = u_pbrMaterial.baseColorFactor;
+vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 #ifdef ALPHA_CUTOFF
-if (baseColor.a < u_pbrMaterial.alphaCutoff) {
+if (baseColor.a < pbrMaterial.alphaCutoff) {
 discard;
 }
 #endif
 vec3 color = vec3(0, 0, 0);
-if(u_pbrMaterial.unlit){
+if(pbrMaterial.unlit){
 color.rgb = baseColor.rgb;
 }
 else{
-float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;
-float metallic = u_pbrMaterial.metallicRoughnessValues.x;
+float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+float metallic = pbrMaterial.metallicRoughnessValues.x;
 #ifdef HAS_METALROUGHNESSMAP
-vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
 perceptualRoughness = mrSample.g * perceptualRoughness;
 metallic = mrSample.b * metallic;
 #endif
@@ -2114,7 +2105,7 @@ float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
 vec3 specularEnvironmentR0 = specularColor.rgb;
 vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
 vec3 n = getNormal();
-vec3 v = normalize(u_Camera - pbr_vPosition);
+vec3 v = normalize(pbrProjection.camera - pbr_vPosition);
 float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
 vec3 reflection = -normalize(reflect(v, n));
 PBRInfo pbrInfo = PBRInfo(
@@ -2135,64 +2126,88 @@ v
 );
 #ifdef USE_LIGHTS
 PBRInfo_setAmbientLight(pbrInfo);
-color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
-for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-if (i < lighting_uDirectionalLightCount) {
-PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
-color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);
+color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+for(int i = 0; i < lighting.directionalLightCount; i++) {
+if (i < lighting.directionalLightCount) {
+PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
 }
 }
-for(int i = 0; i < lighting_uPointLightCount; i++) {
-if (i < lighting_uPointLightCount) {
-PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
-float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);
+for(int i = 0; i < lighting.pointLightCount; i++) {
+if (i < lighting.pointLightCount) {
+PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
 }
 }
 #endif
 #ifdef USE_IBL
-if (u_pbrMateral.IBLEnabled) {
+if (pbrMaterial.IBLenabled) {
 color += getIBLContribution(pbrInfo, n, reflection);
 }
 #endif
 #ifdef HAS_OCCLUSIONMAP
-if (u_pbrMaterial.occlusionMapEnabled) {
-float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
-color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
+if (pbrMaterial.occlusionMapEnabled) {
+float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+color = mix(color, color * ao, pbrMaterial.occlusionStrength);
 }
 #endif
 #ifdef HAS_EMISSIVEMAP
-if (u_pbrMaterial.emmissiveMapEnabled) {
-vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
+if (pbrMaterial.emissiveMapEnabled) {
+vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
 color += emissive;
 }
 #endif
 #ifdef PBR_DEBUG
-color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);
-color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
-color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);
+color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
 #endif
 }
 return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
 `;
 
+// dist/modules/lighting/pbr-material/pbr-projection.js
+var uniformBlock = `uniform pbrProjectionUniforms {
+mat4 modelViewProjectionMatrix;
+mat4 modelMatrix;
+mat4 normalMatrix;
+vec3 camera;
+} pbrProjection;
+`;
+var pbrProjection = {
+  name: "pbrProjection",
+  vs: uniformBlock,
+  fs: uniformBlock,
+  // TODO why is this needed?
+  getUniforms: (props) => props,
+  uniformTypes: {
+    modelViewProjectionMatrix: "mat4x4<f32>",
+    modelMatrix: "mat4x4<f32>",
+    normalMatrix: "mat4x4<f32>",
+    camera: "vec3<i32>"
+  }
+};
+
 // dist/modules/lighting/pbr-material/pbr-material.js
 var pbrMaterial = {
-  name: "pbr",
+  name: "pbrMaterial",
   vs: vs2,
   fs: fs3,
   defines: {
-    LIGHTING_FRAGMENT: 1,
-    HAS_NORMALMAP: 0,
-    HAS_EMISSIVEMAP: 0,
-    HAS_OCCLUSIONMAP: 0,
-    HAS_BASECOLORMAP: 0,
-    HAS_METALROUGHNESSMAP: 0,
-    ALPHA_CUTOFF: 0,
-    USE_IBL: 0,
-    PBR_DEBUG: 0
+    LIGHTING_FRAGMENT: 1
+    // TODO defining these as 0 breaks shader
+    // HAS_NORMALMAP: 0
+    // HAS_EMISSIVEMAP: 0,
+    // HAS_OCCLUSIONMAP: 0,
+    // HAS_BASECOLORMAP: 0,
+    // HAS_METALROUGHNESSMAP: 0,
+    // ALPHA_CUTOFF: 0
+    // USE_IBL: 0
+    // PBR_DEBUG: 0
   },
+  getUniforms: (props) => props,
   uniformTypes: {
     // Material is unlit
     unlit: "i32",
@@ -2222,7 +2237,7 @@ var pbrMaterial = {
     scaleDiffBaseMR: "vec4<f32>",
     scaleFGDSpec: "vec4<f32>"
   },
-  dependencies: [lighting]
+  dependencies: [lighting, pbrProjection]
 };
 
 // dist/modules/postprocessing/image-adjust-filters/brightnesscontrast.js