@luma.gl/shadertools 9.3.0 → 9.3.2

package/dist/modules/lighting/gouraud-material/gouraud-material.d.ts

@@ -6,7 +6,6 @@ export type GouraudMaterialProps = {
     /** Specularity exponent */
     shininess?: number;
     specularColor?: [number, number, number];
-    useByteColors?: boolean;
 };
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export declare const gouraudMaterial: ShaderModule<GouraudMaterialProps>;

package/dist/modules/lighting/gouraud-material/gouraud-material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gouraud-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAMtE,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,yIAAyI;AACzI,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CAwC9D,CAAC"}
+{"version":3,"file":"gouraud-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAMtE,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C,CAAC;AAIF,yIAAyI;AACzI,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CA+B9D,CAAC"}

package/dist/modules/lighting/gouraud-material/gouraud-material.js

@@ -1,10 +1,11 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+import { floatColors } from "../../color/float-colors.js";
 import { lighting } from "../lights/lighting.js";
 import { PHONG_VS, PHONG_FS } from "../phong-material/phong-shaders-glsl.js";
 import { PHONG_WGSL } from "../phong-material/phong-shaders-wgsl.js";
-import { normalizeByteColor3, resolveUseByteColors } from "../../../lib/color/normalize-byte-colors.js";
+const DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial = {
     props: {},
@@ -17,29 +18,23 @@ export const gouraudMaterial = {
     defines: {
         LIGHTING_VERTEX: true
     },
-    dependencies: [lighting],
+    dependencies: [lighting, floatColors],
     uniformTypes: {
         unlit: 'i32',
         ambient: 'f32',
         diffuse: 'f32',
         shininess: 'f32',
-        specularColor: 'vec3<f32>',
-        useByteColors: 'i32'
+        specularColor: 'vec3<f32>'
     },
     defaultUniforms: {
         unlit: false,
         ambient: 0.35,
         diffuse: 0.6,
         shininess: 32,
-        specularColor: [0.15, 0.15, 0.15],
-        useByteColors: true
+        specularColor: DEFAULT_SPECULAR_COLOR
     },
     getUniforms(props) {
-        const uniforms = { ...props };
-        if (uniforms.specularColor) {
-            uniforms.specularColor = normalizeByteColor3(uniforms.specularColor, resolveUseByteColors(uniforms.useByteColors, true));
-        }
-        return { ...gouraudMaterial.defaultUniforms, ...uniforms };
+        return { ...gouraudMaterial.defaultUniforms, ...props };
     }
 };
 //# sourceMappingURL=gouraud-material.js.map

package/dist/modules/lighting/gouraud-material/gouraud-material.js.map

@@ -1 +1 @@
-{"version":3,"file":"gouraud-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gDAA6C;AACxE,OAAO,EAAC,UAAU,EAAC,gDAA6C;AAChE,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,oDAAiD;AAYnG,yIAAyI;AACzI,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,KAAK,EAAE,EAA0B;IAEjC,IAAI,EAAE,iBAAiB;IACvB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACpD,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACjE,OAAO,EAAE;QACP,eAAe,EAAE,IAAI;KACtB;IACD,YAAY,EAAE,CAAC,QAAQ,CAAC;IACxB,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;QAC1B,aAAa,EAAE,KAAK;KACrB;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QACjC,aAAa,EAAE,IAAI;KACpB;IAED,WAAW,CAAC,KAA2B;QACrC,MAAM,QAAQ,GAAG,EAAC,GAAG,KAAK,EAAC,CAAC;QAC5B,IAAI,QAAQ,CAAC,aAAa,EAAE,CAAC;YAC3B,QAAQ,CAAC,aAAa,GAAG,mBAAmB,CAC1C,QAAQ,CAAC,aAAa,EACtB,oBAAoB,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,CACnC,CAAC;QACpB,CAAC;QACD,OAAO,EAAC,GAAG,eAAe,CAAC,eAAe,EAAE,GAAG,QAAQ,EAAC,CAAC;IAC3D,CAAC;CACF,CAAC"}
+{"version":3,"file":"gouraud-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,WAAW,EAAC,oCAAiC;AACrD,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gDAA6C;AACxE,OAAO,EAAC,UAAU,EAAC,gDAA6C;AAWhE,MAAM,sBAAsB,GAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEnE,yIAAyI;AACzI,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,KAAK,EAAE,EAA0B;IAEjC,IAAI,EAAE,iBAAiB;IACvB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACpD,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACjE,OAAO,EAAE;QACP,eAAe,EAAE,IAAI;KACtB;IACD,YAAY,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC;IACrC,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC3B;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,sBAAsB;KACtC;IAED,WAAW,CAAC,KAA2B;QACrC,OAAO,EAAC,GAAG,eAAe,CAAC,eAAe,EAAE,GAAG,KAAK,EAAC,CAAC;IACxD,CAAC;CACF,CAAC"}

package/dist/modules/lighting/phong-material/phong-material.d.ts

@@ -7,7 +7,6 @@ export type PhongMaterialProps = {
     /** Specularity exponent */
     shininess?: number;
     specularColor?: NumberArray3;
-    useByteColors?: boolean;
 };
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
 export declare const phongMaterial: ShaderModule<PhongMaterialProps>;

package/dist/modules/lighting/phong-material/phong-material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phong-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-material.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAMtE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,wIAAwI;AACxI,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,kBAAkB,CAsC1D,CAAC"}
+{"version":3,"file":"phong-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-material.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAMtE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,YAAY,CAAC;CAC9B,CAAC;AAIF,wIAAwI;AACxI,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,kBAAkB,CA6B1D,CAAC"}

package/dist/modules/lighting/phong-material/phong-material.js

@@ -1,16 +1,17 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+import { floatColors } from "../../color/float-colors.js";
 import { lighting } from "../lights/lighting.js";
 import { PHONG_WGSL } from "./phong-shaders-wgsl.js";
 import { PHONG_VS, PHONG_FS } from "./phong-shaders-glsl.js";
-import { normalizeByteColor3, resolveUseByteColors } from "../../../lib/color/normalize-byte-colors.js";
+const DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
 export const phongMaterial = {
     name: 'phongMaterial',
     firstBindingSlot: 0,
     bindingLayout: [{ name: 'phongMaterial', group: 3 }],
-    dependencies: [lighting],
+    dependencies: [lighting, floatColors],
     // Note these are switched between phong and gouraud
     source: PHONG_WGSL,
     vs: PHONG_VS,
@@ -23,23 +24,17 @@ export const phongMaterial = {
         ambient: 'f32',
         diffuse: 'f32',
         shininess: 'f32',
-        specularColor: 'vec3<f32>',
-        useByteColors: 'i32'
+        specularColor: 'vec3<f32>'
     },
     defaultUniforms: {
         unlit: false,
         ambient: 0.35,
         diffuse: 0.6,
         shininess: 32,
-        specularColor: [0.15, 0.15, 0.15],
-        useByteColors: true
+        specularColor: DEFAULT_SPECULAR_COLOR
     },
     getUniforms(props) {
-        const uniforms = { ...props };
-        if (uniforms.specularColor) {
-            uniforms.specularColor = normalizeByteColor3(uniforms.specularColor, resolveUseByteColors(uniforms.useByteColors, true));
-        }
-        return { ...phongMaterial.defaultUniforms, ...uniforms };
+        return { ...phongMaterial.defaultUniforms, ...props };
     }
 };
 //# sourceMappingURL=phong-material.js.map

package/dist/modules/lighting/phong-material/phong-material.js.map

@@ -1 +1 @@
-{"version":3,"file":"phong-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,UAAU,EAAC,gCAA6B;AAChD,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gCAA6B;AACxD,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,oDAAiD;AAYnG,wIAAwI;AACxI,MAAM,CAAC,MAAM,aAAa,GAAqC;IAC7D,IAAI,EAAE,eAAe;IACrB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAClD,YAAY,EAAE,CAAC,QAAQ,CAAC;IACxB,oDAAoD;IACpD,MAAM,EAAE,UAAU;IAClB,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,QAAQ;IACZ,OAAO,EAAE;QACP,iBAAiB,EAAE,IAAI;KACxB;IACD,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;QAC1B,aAAa,EAAE,KAAK;KACrB;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QACjC,aAAa,EAAE,IAAI;KACpB;IACD,WAAW,CAAC,KAA0B;QACpC,MAAM,QAAQ,GAAG,EAAC,GAAG,KAAK,EAAC,CAAC;QAC5B,IAAI,QAAQ,CAAC,aAAa,EAAE,CAAC;YAC3B,QAAQ,CAAC,aAAa,GAAG,mBAAmB,CAC1C,QAAQ,CAAC,aAAa,EACtB,oBAAoB,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,CACnC,CAAC;QACpB,CAAC;QACD,OAAO,EAAC,GAAG,aAAa,CAAC,eAAe,EAAE,GAAG,QAAQ,EAAC,CAAC;IACzD,CAAC;CACF,CAAC"}
+{"version":3,"file":"phong-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,WAAW,EAAC,oCAAiC;AACrD,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,UAAU,EAAC,gCAA6B;AAChD,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gCAA6B;AAWxD,MAAM,sBAAsB,GAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEnE,wIAAwI;AACxI,MAAM,CAAC,MAAM,aAAa,GAAqC;IAC7D,IAAI,EAAE,eAAe;IACrB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAClD,YAAY,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC;IACrC,oDAAoD;IACpD,MAAM,EAAE,UAAU;IAClB,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,QAAQ;IACZ,OAAO,EAAE;QACP,iBAAiB,EAAE,IAAI;KACxB;IACD,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC3B;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,sBAAsB;KACtC;IACD,WAAW,CAAC,KAA0B;QACpC,OAAO,EAAC,GAAG,aAAa,CAAC,eAAe,EAAE,GAAG,KAAK,EAAC,CAAC;IACtD,CAAC;CACF,CAAC"}

package/dist/modules/lighting/phong-material/phong-shaders-glsl.d.ts

@@ -1,3 +1,3 @@
 export declare const PHONG_VS = "layout(std140) uniform phongMaterialUniforms {\n  uniform bool unlit;\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
-export declare const PHONG_FS = "layout(std140) uniform phongMaterialUniforms {\n  uniform bool unlit;\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (material.unlit) {\n    return surfaceColor;\n  }\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  for (int i = 0; i < lighting.pointLightCount; i++) {\n    PointLight pointLight = lighting_getPointLight(i);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);\n  }\n\n  for (int i = 0; i < lighting.spotLightCount; i++) {\n    SpotLight spotLight = lighting_getSpotLight(i);\n    vec3 light_position_worldspace = spotLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, spotLight.color / light_attenuation);\n  }\n\n  for (int i = 0; i < lighting.directionalLightCount; i++) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n}\n";
+export declare const PHONG_FS = "layout(std140) uniform phongMaterialUniforms {\n  uniform bool unlit;\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * floatColors_normalize(material.specularColor)) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (material.unlit) {\n    return surfaceColor;\n  }\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  vec3 view_direction = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  for (int i = 0; i < lighting.pointLightCount; i++) {\n    PointLight pointLight = lighting_getPointLight(i);\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);\n  }\n\n  for (int i = 0; i < lighting.spotLightCount; i++) {\n    SpotLight spotLight = lighting_getSpotLight(i);\n    vec3 light_position_worldspace = spotLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, spotLight.color / light_attenuation);\n  }\n\n  for (int i = 0; i < lighting.directionalLightCount; i++) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n}\n";
 //# sourceMappingURL=phong-shaders-glsl.d.ts.map

package/dist/modules/lighting/phong-material/phong-shaders-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,yMAQpB,CAAC;AAEF,eAAO,MAAM,QAAQ,0hFA0DpB,CAAC"}
+{"version":3,"file":"phong-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,yMAQpB,CAAC;AAEF,eAAO,MAAM,QAAQ,ijFA0DpB,CAAC"}

package/dist/modules/lighting/phong-material/phong-shaders-glsl.js

@@ -28,7 +28,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
     specular = pow(specular_angle, material.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+  return (lambertian * material.diffuse * surfaceColor + specular * floatColors_normalize(material.specularColor)) * color;
 }
 
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.d.ts

@@ -1,2 +1,2 @@
-export declare const PHONG_WGSL = "struct phongMaterialUniforms {\n  unlit: u32,\n  ambient: f32,\n  diffuse: f32,\n  shininess: f32,\n  specularColor: vec3<f32>,\n};\n\n@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;\n\nfn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {\n  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);\n  var lambertian: f32 = dot(light_direction, normal_worldspace);\n  var specular: f32 = 0.0;\n  if (lambertian > 0.0) {\n    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, phongMaterial.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * phongMaterial.diffuse * surfaceColor + specular * phongMaterial.specularColor) * color;\n}\n\nfn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {\n  var lightColor: vec3<f32> = surfaceColor;\n\n  if (phongMaterial.unlit != 0u) {\n    return surfaceColor;\n  }\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);\n  lightColor = phongMaterial.ambient * surfaceColor * lighting.ambientColor;\n\n  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {\n    let pointLight: PointLight = lighting_getPointLight(i);\n    let light_position_worldspace: vec3<f32> = pointLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    let light_attenuation = getPointLightAttenuation(\n      pointLight,\n      distance(light_position_worldspace, position_worldspace)\n    );\n    lightColor += lighting_getLightColor(\n      surfaceColor,\n      light_direction,\n      view_direction,\n      normal_worldspace,\n      pointLight.color / light_attenuation\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {\n    let spotLight: SpotLight = lighting_getSpotLight(i);\n    let light_position_worldspace: vec3<f32> = spotLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n    lightColor += lighting_getLightColor(\n      surfaceColor,\n      light_direction,\n      view_direction,\n      normal_worldspace,\n      spotLight.color / light_attenuation\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }  \n  \n  return lightColor;\n}\n\nfn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{\n  var lightColor = vec3<f32>(0, 0, 0);\n  let surfaceColor = vec3<f32>(0, 0, 0);\n\n  if (lighting.enabled != 0) {\n    let view_direction = normalize(cameraPosition - position_worldspace);\n\n    for (var i: i32 = 0; i < lighting.pointLightCount; i++) {\n      let pointLight: PointLight = lighting_getPointLight(i);\n      let light_position_worldspace: vec3<f32> = pointLight.position;\n      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n      let light_attenuation = getPointLightAttenuation(\n        pointLight,\n        distance(light_position_worldspace, position_worldspace)\n      );\n      lightColor += lighting_getLightColor(\n        surfaceColor,\n        light_direction,\n        view_direction,\n        normal_worldspace,\n        pointLight.color / light_attenuation\n      );\n    }\n\n    for (var i: i32 = 0; i < lighting.spotLightCount; i++) {\n      let spotLight: SpotLight = lighting_getSpotLight(i);\n      let light_position_worldspace: vec3<f32> = spotLight.position;\n      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n      let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n      lightColor += lighting_getLightColor(\n        surfaceColor,\n        light_direction,\n        view_direction,\n        normal_worldspace,\n        spotLight.color / light_attenuation\n      );\n    }\n\n    for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n        let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n";
+export declare const PHONG_WGSL = "struct phongMaterialUniforms {\n  unlit: u32,\n  ambient: f32,\n  diffuse: f32,\n  shininess: f32,\n  specularColor: vec3<f32>,\n};\n\n@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;\n\nfn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {\n  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);\n  var lambertian: f32 = dot(light_direction, normal_worldspace);\n  var specular: f32 = 0.0;\n  if (lambertian > 0.0) {\n    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, phongMaterial.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (\n    lambertian * phongMaterial.diffuse * surfaceColor +\n    specular * floatColors_normalize(phongMaterial.specularColor)\n  ) * color;\n}\n\nfn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {\n  var lightColor: vec3<f32> = surfaceColor;\n\n  if (phongMaterial.unlit != 0u) {\n    return surfaceColor;\n  }\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);\n  lightColor = phongMaterial.ambient * surfaceColor * lighting.ambientColor;\n\n  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {\n    let pointLight: PointLight = lighting_getPointLight(i);\n    let light_position_worldspace: vec3<f32> = pointLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    let light_attenuation = getPointLightAttenuation(\n      pointLight,\n      distance(light_position_worldspace, position_worldspace)\n    );\n    lightColor += lighting_getLightColor(\n      surfaceColor,\n      light_direction,\n      view_direction,\n      normal_worldspace,\n      pointLight.color / light_attenuation\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {\n    let spotLight: SpotLight = lighting_getSpotLight(i);\n    let light_position_worldspace: vec3<f32> = spotLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n    lightColor += lighting_getLightColor(\n      surfaceColor,\n      light_direction,\n      view_direction,\n      normal_worldspace,\n      spotLight.color / light_attenuation\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }  \n  \n  return lightColor;\n}\n\nfn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{\n  var lightColor = vec3<f32>(0, 0, 0);\n  let surfaceColor = vec3<f32>(0, 0, 0);\n\n  if (lighting.enabled != 0) {\n    let view_direction = normalize(cameraPosition - position_worldspace);\n\n    for (var i: i32 = 0; i < lighting.pointLightCount; i++) {\n      let pointLight: PointLight = lighting_getPointLight(i);\n      let light_position_worldspace: vec3<f32> = pointLight.position;\n      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n      let light_attenuation = getPointLightAttenuation(\n        pointLight,\n        distance(light_position_worldspace, position_worldspace)\n      );\n      lightColor += lighting_getLightColor(\n        surfaceColor,\n        light_direction,\n        view_direction,\n        normal_worldspace,\n        pointLight.color / light_attenuation\n      );\n    }\n\n    for (var i: i32 = 0; i < lighting.spotLightCount; i++) {\n      let spotLight: SpotLight = lighting_getSpotLight(i);\n      let light_position_worldspace: vec3<f32> = spotLight.position;\n      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n      let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n      lightColor += lighting_getLightColor(\n        surfaceColor,\n        light_direction,\n        view_direction,\n        normal_worldspace,\n        spotLight.color / light_attenuation\n      );\n    }\n\n    for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n        let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n  }\n  return lightColor;\n}\n";
 //# sourceMappingURL=phong-shaders-wgsl.d.ts.map

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phong-shaders-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,2uJAyHtB,CAAC"}
+{"version":3,"file":"phong-shaders-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,ixJA4HtB,CAAC"}

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js

@@ -21,7 +21,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
     specular = pow(specular_angle, phongMaterial.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * phongMaterial.diffuse * surfaceColor + specular * phongMaterial.specularColor) * color;
+  return (
+    lambertian * phongMaterial.diffuse * surfaceColor +
+    specular * floatColors_normalize(phongMaterial.specularColor)
+  ) * color;
 }
 
 fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"phong-shaders-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHpC,CAAC"}
+{"version":3,"file":"phong-shaders-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HpC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.3.0",
+  "version": "9.3.2",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -46,11 +46,11 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "9.3.0-alpha.6"
+    "@luma.gl/core": "~9.3.0"
   },
   "dependencies": {
     "@math.gl/core": "^4.1.0",
     "@math.gl/types": "^4.1.0"
   },
-  "gitHead": "c5e44faacd07b315a8622b5927e724f15a3d40ae"
+  "gitHead": "8f60fca63dc43702af5b16d0381fd97d7ace7dc9"
 }

package/src/modules/lighting/gouraud-material/gouraud-material.ts

@@ -4,10 +4,10 @@
 
 import {NumberArray3} from '@math.gl/types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {floatColors} from '../../color/float-colors';
 import {lighting} from '../lights/lighting';
 import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
 import {PHONG_WGSL} from '../phong-material/phong-shaders-wgsl';
-import {normalizeByteColor3, resolveUseByteColors} from '../../../lib/color/normalize-byte-colors';
 
 export type GouraudMaterialProps = {
   unlit?: boolean;
@@ -16,9 +16,10 @@ export type GouraudMaterialProps = {
   /** Specularity exponent */
   shininess?: number;
   specularColor?: [number, number, number];
-  useByteColors?: boolean;
 };
 
+const DEFAULT_SPECULAR_COLOR: NumberArray3 = [38.25, 38.25, 38.25];
+
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   props: {} as GouraudMaterialProps,
@@ -32,32 +33,23 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   defines: {
     LIGHTING_VERTEX: true
   },
-  dependencies: [lighting],
+  dependencies: [lighting, floatColors],
   uniformTypes: {
     unlit: 'i32',
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
-    specularColor: 'vec3<f32>',
-    useByteColors: 'i32'
+    specularColor: 'vec3<f32>'
   },
   defaultUniforms: {
     unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
-    specularColor: [0.15, 0.15, 0.15],
-    useByteColors: true
+    specularColor: DEFAULT_SPECULAR_COLOR
   },
 
   getUniforms(props: GouraudMaterialProps) {
-    const uniforms = {...props};
-    if (uniforms.specularColor) {
-      uniforms.specularColor = normalizeByteColor3(
-        uniforms.specularColor,
-        resolveUseByteColors(uniforms.useByteColors, true)
-      ) as NumberArray3;
-    }
-    return {...gouraudMaterial.defaultUniforms, ...uniforms};
+    return {...gouraudMaterial.defaultUniforms, ...props};
   }
 };

package/src/modules/lighting/phong-material/phong-material.ts

@@ -4,10 +4,10 @@
 
 import {NumberArray3} from '@math.gl/types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {floatColors} from '../../color/float-colors';
 import {lighting} from '../lights/lighting';
 import {PHONG_WGSL} from './phong-shaders-wgsl';
 import {PHONG_VS, PHONG_FS} from './phong-shaders-glsl';
-import {normalizeByteColor3, resolveUseByteColors} from '../../../lib/color/normalize-byte-colors';
 
 export type PhongMaterialProps = {
   unlit?: boolean;
@@ -16,15 +16,16 @@ export type PhongMaterialProps = {
   /** Specularity exponent */
   shininess?: number;
   specularColor?: NumberArray3;
-  useByteColors?: boolean;
 };
 
+const DEFAULT_SPECULAR_COLOR: NumberArray3 = [38.25, 38.25, 38.25];
+
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
 export const phongMaterial: ShaderModule<PhongMaterialProps> = {
   name: 'phongMaterial',
   firstBindingSlot: 0,
   bindingLayout: [{name: 'phongMaterial', group: 3}],
-  dependencies: [lighting],
+  dependencies: [lighting, floatColors],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
   vs: PHONG_VS,
@@ -37,25 +38,16 @@ export const phongMaterial: ShaderModule<PhongMaterialProps> = {
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
-    specularColor: 'vec3<f32>',
-    useByteColors: 'i32'
+    specularColor: 'vec3<f32>'
   },
   defaultUniforms: {
     unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
-    specularColor: [0.15, 0.15, 0.15],
-    useByteColors: true
+    specularColor: DEFAULT_SPECULAR_COLOR
   },
   getUniforms(props?: PhongMaterialProps) {
-    const uniforms = {...props};
-    if (uniforms.specularColor) {
-      uniforms.specularColor = normalizeByteColor3(
-        uniforms.specularColor,
-        resolveUseByteColors(uniforms.useByteColors, true)
-      ) as NumberArray3;
-    }
-    return {...phongMaterial.defaultUniforms, ...uniforms};
+    return {...phongMaterial.defaultUniforms, ...props};
   }
 };

package/src/modules/lighting/phong-material/phong-shaders-glsl.ts

@@ -30,7 +30,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
     specular = pow(specular_angle, material.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+  return (lambertian * material.diffuse * surfaceColor + specular * floatColors_normalize(material.specularColor)) * color;
 }
 
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {

package/src/modules/lighting/phong-material/phong-shaders-wgsl.ts

@@ -22,7 +22,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
     specular = pow(specular_angle, phongMaterial.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * phongMaterial.diffuse * surfaceColor + specular * phongMaterial.specularColor) * color;
+  return (
+    lambertian * phongMaterial.diffuse * surfaceColor +
+    specular * floatColors_normalize(phongMaterial.specularColor)
+  ) * color;
 }
 
 fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {