@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/modules/engine/picking/picking.js

@@ -1,100 +1,137 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 // cyan color
 const DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
-const vs = `\
+const vs = /* glsl */ `\
 uniform pickingUniforms {
-float isActive;
-float isAttribute;
-float isHighlightActive;
-float useFloatColors;
-vec3 highlightedObjectColor;
-vec4 highlightColor;
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
 } picking;
+
 out vec4 picking_vRGBcolor_Avalid;
+
+// Normalize unsigned byte color to 0-1 range
 vec3 picking_normalizeColor(vec3 color) {
-return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
 }
+
+// Normalize unsigned byte color to 0-1 range
 vec4 picking_normalizeColor(vec4 color) {
-return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
 }
+
 bool picking_isColorZero(vec3 color) {
-return dot(color, vec3(1.0)) < 0.00001;
+  return dot(color, vec3(1.0)) < 0.00001;
 }
+
 bool picking_isColorValid(vec3 color) {
-return dot(color, vec3(1.0)) > 0.00001;
+  return dot(color, vec3(1.0)) > 0.00001;
 }
+
+// Check if this vertex is highlighted 
 bool isVertexHighlighted(vec3 vertexColor) {
-vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
-return
-bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+  return
+    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
 }
+
+// Set the current picking color
 void picking_setPickingColor(vec3 pickingColor) {
-pickingColor = picking_normalizeColor(pickingColor);
-if (bool(picking.isActive)) {
-picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
-if (!bool(picking.isAttribute)) {
-picking_vRGBcolor_Avalid.rgb = pickingColor;
-}
-} else {
-picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
-}
+  pickingColor = picking_normalizeColor(pickingColor);
+
+  if (bool(picking.isActive)) {
+    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
+    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
+
+    if (!bool(picking.isAttribute)) {
+      // Stores the picking color so that the fragment shader can render it during picking
+      picking_vRGBcolor_Avalid.rgb = pickingColor;
+    }
+  } else {
+    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
+    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
+  }
 }
+
 void picking_setPickingAttribute(float value) {
-if (bool(picking.isAttribute)) {
-picking_vRGBcolor_Avalid.r = value;
-}
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.r = value;
+  }
 }
+
 void picking_setPickingAttribute(vec2 value) {
-if (bool(picking.isAttribute)) {
-picking_vRGBcolor_Avalid.rg = value;
-}
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rg = value;
+  }
 }
+
 void picking_setPickingAttribute(vec3 value) {
-if (bool(picking.isAttribute)) {
-picking_vRGBcolor_Avalid.rgb = value;
-}
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rgb = value;
+  }
 }
 `;
-const fs = `\
+const fs = /* glsl */ `\
 uniform pickingUniforms {
-float isActive;
-float isAttribute;
-float isHighlightActive;
-float useFloatColors;
-vec3 highlightedObjectColor;
-vec4 highlightColor;
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
 } picking;
+
 in vec4 picking_vRGBcolor_Avalid;
+
+/*
+ * Returns highlight color if this item is selected.
+ */
 vec4 picking_filterHighlightColor(vec4 color) {
-if (picking.isActive > 0.5) {
-return color;
-}
-bool selected = bool(picking_vRGBcolor_Avalid.a);
-if (selected) {
-float highLightAlpha = picking.highlightColor.a;
-float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
-float highLightRatio = highLightAlpha / blendedAlpha;
-vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
-return vec4(blendedRGB, blendedAlpha);
-} else {
-return color;
-}
-}
+  // If we are still picking, we don't highlight
+  if (picking.isActive > 0.5) {
+    return color;
+  }
+
+  bool selected = bool(picking_vRGBcolor_Avalid.a);
+
+  if (selected) {
+    // Blend in highlight color based on its alpha value
+    float highLightAlpha = picking.highlightColor.a;
+    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+    float highLightRatio = highLightAlpha / blendedAlpha;
+
+    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+    return vec4(blendedRGB, blendedAlpha);
+  } else {
+    return color;
+  }
+}
+
+/*
+ * Returns picking color if picking enabled else unmodified argument.
+ */
 vec4 picking_filterPickingColor(vec4 color) {
-if (bool(picking.isActive)) {
-if (picking_vRGBcolor_Avalid.a == 0.0) {
-discard;
-}
-return picking_vRGBcolor_Avalid;
-}
-return color;
-}
+  if (bool(picking.isActive)) {
+    if (picking_vRGBcolor_Avalid.a == 0.0) {
+      discard;
+    }
+    return picking_vRGBcolor_Avalid;
+  }
+  return color;
+}
+
+/*
+ * Returns picking color if picking is enabled if not
+ * highlight color if this item is selected, otherwise unmodified argument.
+ */
 vec4 picking_filterColor(vec4 color) {
-vec4 highlightColor = picking_filterHighlightColor(color);
-return picking_filterPickingColor(highlightColor);
+  vec4 highlightColor = picking_filterHighlightColor(color);
+  return picking_filterPickingColor(highlightColor);
 }
 `;
 /**
@@ -105,6 +142,8 @@ return picking_filterPickingColor(highlightColor);
  * primitives with the same picking color in non-instanced draw-calls
  */
 export const picking = {
+    props: {},
+    uniforms: {},
     name: 'picking',
     uniformTypes: {
         isActive: 'f32',
@@ -124,8 +163,6 @@ export const picking = {
     },
     vs,
     fs,
-    props: {},
-    uniforms: {},
     getUniforms
 };
 function getUniforms(opts = {}, prevUniforms) {

package/dist/modules/engine/project/project.d.ts

@@ -31,8 +31,8 @@ export declare const projection: {
         readonly cameraPositionWorld: "vec3<f32>";
     };
     readonly getUniforms: typeof getUniforms;
-    readonly vs: string;
-    readonly fs: string;
+    readonly vs: "varying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\n// Project uniform block\nuniform Project {\n  mat4 viewMatrix;\n  mat4 projectionMatrix;\n  mat4 viewProjectionMatrix;\n  vec3 cameraPositionWorld;\n} project;\n\nstruct World {\n  vec3 position;\n  vec3 normal;\n};\n\nWorld world;\n\nvoid project_setPosition(vec4 position) {\n  project_vPositionWorld = position;\n}\n\nvoid project_setNormal(vec3 normal) {\n  project_vNormalWorld = normal;\n}\n\nvoid project_setPositionAndNormal_World(vec3 position, vec3 normal) {\n  world.position = position;\n  world.normal = normal;\n}\n\nvoid project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {\n  world.position = (modelMatrix * vec4(position, 1.)).xyz;\n  world.normal = mat3(modelMatrix) * normal;\n}\n\nvec4 project_model_to_clipspace(vec4 position) {\n  return project.viewProjectionMatrix * position;\n}\n\nvec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {\n  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);\n}\n\nvec4 project_world_to_clipspace(vec3 position) {\n  return project.viewProjectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_view_to_clipspace(vec3 position) {\n  return project.projectionMatrix * vec4(position, 1.);\n}\n\nvec4 project_to_clipspace(vec3 position) {\n  return project.viewProjectionMatrix * vec4(position, 1.);\n}\n";
+    readonly fs: "varying vec4 project_vPositionWorld;\nvarying vec3 project_vNormalWorld;\n\nvec4 project_getPosition_World() {\n  return project_vPositionWorld;\n}\n\nvec3 project_getNormal_World() {\n  return project_vNormalWorld;\n}\n";
 };
 export {};
 //# sourceMappingURL=project.d.ts.map

package/dist/modules/engine/project/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/project/project.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,IAAI,WAAW,EAAE,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAM5E;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACnD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;CACvD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACnD,oBAAoB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACvD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;CACvD,CAAC;AASF,iBAAS,WAAW,CAClB,IAAI,GAAE,eAAwC,EAC9C,YAAY,GAAE,kBAAuB,GACpC,kBAAkB,CAuBpB;AAmFD;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;CAY+C,CAAC"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/project/project.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,IAAI,WAAW,EAAE,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAK5E;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACnD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;CACvD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACnD,oBAAoB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;IACvD,mBAAmB,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;CACvD,CAAC;AASF,iBAAS,WAAW,CAClB,IAAI,GAAE,eAAwC,EAC9C,YAAY,GAAE,kBAAuB,GACpC,kBAAkB,CAuBpB;AAmFD;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;CAY+C,CAAC"}

package/dist/modules/engine/project/project.js

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { Matrix4 } from '@math.gl/core';
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 const DEFAULT_MODULE_OPTIONS = {
     viewMatrix: IDENTITY_MATRIX,
@@ -36,62 +35,77 @@ function getUniforms(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
  * @note varyings must match vertex shader
  * @note project module uses unprefixed uniforms to match conventions
  */
-const vs = `\
+const vs = /* glsl */ `\
 varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
+
+// Project uniform block
 uniform Project {
-mat4 viewMatrix;
-mat4 projectionMatrix;
-mat4 viewProjectionMatrix;
-vec3 cameraPositionWorld;
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+  mat4 viewProjectionMatrix;
+  vec3 cameraPositionWorld;
 } project;
+
 struct World {
-vec3 position;
-vec3 normal;
+  vec3 position;
+  vec3 normal;
 };
+
 World world;
+
 void project_setPosition(vec4 position) {
-project_vPositionWorld = position;
+  project_vPositionWorld = position;
 }
+
 void project_setNormal(vec3 normal) {
-project_vNormalWorld = normal;
+  project_vNormalWorld = normal;
 }
+
 void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
-world.position = position;
-world.normal = normal;
+  world.position = position;
+  world.normal = normal;
 }
+
 void project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {
-world.position = (modelMatrix * vec4(position, 1.)).xyz;
-world.normal = mat3(modelMatrix) * normal;
+  world.position = (modelMatrix * vec4(position, 1.)).xyz;
+  world.normal = mat3(modelMatrix) * normal;
 }
+
 vec4 project_model_to_clipspace(vec4 position) {
-return project.viewProjectionMatrix * position;
+  return project.viewProjectionMatrix * position;
 }
+
 vec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {
-return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);
+  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);
 }
+
 vec4 project_world_to_clipspace(vec3 position) {
-return project.viewProjectionMatrix * vec4(position, 1.);
+  return project.viewProjectionMatrix * vec4(position, 1.);
 }
+
 vec4 project_view_to_clipspace(vec3 position) {
-return project.projectionMatrix * vec4(position, 1.);
+  return project.projectionMatrix * vec4(position, 1.);
 }
+
 vec4 project_to_clipspace(vec3 position) {
-return project.viewProjectionMatrix * vec4(position, 1.);
+  return project.viewProjectionMatrix * vec4(position, 1.);
 }
 `;
 /**
  * Functions to get the position and normal from the vertex shader
  * @note varyings must match vertex shader
  */
-const fs = `\
+const fs = /* glsl */ `\
 varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
+
 vec4 project_getPosition_World() {
-return project_vPositionWorld;
+  return project_vPositionWorld;
 }
+
 vec3 project_getNormal_World() {
-return project_vNormalWorld;
+  return project_vNormalWorld;
 }
 `;
 /**

package/dist/modules/engine/transform/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/transform/transform.ts"],"names":[],"mappings":"AA+CA,gDAAgD;AAChD,eAAO,MAAM,SAAS;;;CAGrB,CAAC"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/transform/transform.ts"],"names":[],"mappings":"AA6CA,gDAAgD;AAChD,eAAO,MAAM,SAAS;;;CAGrB,CAAC"}

package/dist/modules/engine/transform/transform.js

@@ -1,32 +1,44 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const vs = `\
+const vs = /* glsl */ `\
 attribute float transform_elementID;
+
+// returns half of pixel size, used to move the pixel position to center of the pixel.
 vec2 transform_getPixelSizeHalf(vec2 size) {
-return vec2(1.) / (2. * size);
+  return vec2(1.) / (2. * size);
 }
+
+// returns current elements pixel indeces [x, y],
+// where x ranges in [0 to texSize-1] and y ranges in [0 to texSize-1]
 vec2 transform_getPixelIndices(vec2 texSize, vec2 pixelSizeHalf) {
-float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);
-float xIndex = transform_elementID - (yIndex * texSize[0]);
-return vec2(xIndex, yIndex);
+  // Add safe offset (half of pixel height) before doing floor
+  float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);
+  float xIndex = transform_elementID - (yIndex * texSize[0]);
+  return vec2(xIndex, yIndex);
 }
+
+// returns current elementID's texture co-ordianate
 vec2 transform_getTexCoord(vec2 size) {
-vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);
-vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);
-vec2 coord = indices / size + pixelSizeHalf;
-return coord;
+  vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);
+  vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);
+  vec2 coord = indices / size + pixelSizeHalf;
+  return coord;
 }
+
+// returns current elementID's position
 vec2 transform_getPos(vec2 size) {
-vec2 texCoord = transform_getTexCoord(size);
-vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);
-return pos;
+  vec2 texCoord = transform_getTexCoord(size);
+  // Change from [0 1] range to [-1 1]
+  vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);
+  return pos;
 }
+
+// returns current elementID's pixel value
 vec4 transform_getInput(sampler2D texSampler, vec2 size) {
-vec2 texCoord = transform_getTexCoord(size);
-vec4 textureColor = texture2D(texSampler, texCoord);
-return textureColor;
+  vec2 texCoord = transform_getTexCoord(size);
+  vec4 textureColor = texture2D(texSampler, texCoord);
+  return textureColor;
 }
 `;
 /** Private shader module used by `Transform` */

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

@@ -8,13 +8,17 @@ export type GouraudMaterialUniforms = {
 };
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export declare const gouraudMaterial: {
+    readonly props: GouraudMaterialProps;
+    readonly uniforms: GouraudMaterialUniforms;
     readonly name: "gouraud-lighting";
-    readonly vs: string;
-    readonly fs: string;
+    readonly vs: "uniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
+    readonly fs: "uniform materialUniforms {\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 (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n    if (lighting.lightType == 0) {\n      PointLight pointLight = lighting_getPointLight(0);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    } else if (lighting.lightType == 1) {\n      DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    /*\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting.pointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting.directionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    */\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n";
     readonly defines: {
         readonly LIGHTING_VERTEX: 1;
     };
     readonly dependencies: [{
+        readonly props: import("../lights/lighting").LightingProps;
+        readonly uniforms: import("../lights/lighting").LightingUniforms;
         readonly name: "lighting";
         readonly defines: {
             readonly MAX_LIGHTS: 5;
@@ -39,11 +43,10 @@ export declare const gouraudMaterial: {
             readonly lightDirection: readonly [1, 1, 1];
             readonly lightAttenuation: readonly [1, 1, 1];
         };
-        readonly vs: string;
-        readonly fs: string;
-        readonly props: Required<import("../lights/lighting").LightingProps>;
-        readonly uniforms: import("../lights/lighting").LightingUniforms;
-        readonly getUniforms: (props?: import("../lights/lighting").LightingProps | undefined, prevUniforms?: Partial<import("../lights/lighting").LightingUniforms>) => import("../lights/lighting").LightingUniforms;
+        readonly source: "// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  color: vec3<f32>,\n};\n\nstruct PointLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  color: vec3<f32>,\n  direction: vec3<f32>,\n};\n\nstruct lightingUniforms {\n  enabled: i32,\n  poightCount: i32,\n  directionalLightCount: i32,\n\n  ambientColor: vec3<f32>,\n\n  // TODO - support multiple lights by uncommenting arrays below\n  lightType: i32,\n  lightColor: vec3<f32>,\n  lightDirection: vec3<f32>,\n  lightPosition: vec3<f32>,\n  lightAttenuation: vec3<f32>,\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n};\n\n// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)\n@binding(1) @group(0) var<uniform> lighting : lightingUniforms;\n\nfn lighting_getPointLight(index: i32) -> PointLight {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nfn lighting_getDirectionalLight(index: i32) -> DirectionalLight {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n";
+        readonly vs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int pointLightCount;\n  int directionalLightCount;\n\n  vec3 ambientColor;\n\n  int lightType;\n  vec3 lightColor;\n  vec3 lightDirection;\n  vec3 lightPosition;\n  vec3 lightAttenuation;\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n";
+        readonly fs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int pointLightCount;\n  int directionalLightCount;\n\n  vec3 ambientColor;\n\n  int lightType;\n  vec3 lightColor;\n  vec3 lightDirection;\n  vec3 lightPosition;\n  vec3 lightAttenuation;\n\n  // AmbientLight ambientLight;\n  // PointLight pointLight[MAX_LIGHTS];\n  // DirectionalLight directionalLight[MAX_LIGHTS];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  return DirectionalLight(lighting.lightColor, lighting.lightDirection);\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n";
+        readonly getUniforms: (props?: import("../lights/lighting").LightingProps, prevUniforms?: Partial<import("../lights/lighting").LightingUniforms>) => import("../lights/lighting").LightingUniforms;
     }];
     readonly uniformTypes: {
         readonly ambient: "f32";

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":"AAQA,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,CAAC;AAE3D,MAAM,MAAM,uBAAuB,GAAG;IACpC,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;AAEF,yIAAyI;AACzI,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAqBP,oBAAoB,KAAG,uBAAuB;CAGa,CAAC"}
+{"version":3,"file":"gouraud-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,CAAC;AAE3D,MAAM,MAAM,uBAAuB,GAAG;IACpC,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;AAEF,yIAAyI;AACzI,eAAO,MAAM,eAAe;oBACb,oBAAoB;uBACjB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAuBpB,oBAAoB,KAAG,uBAAuB;CAGa,CAAC"}

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

@@ -5,6 +5,8 @@ import { lighting } from "../lights/lighting.js";
 import { GOURAUD_VS, GOURAUD_FS } from "./gouraud-shaders-glsl.js";
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial = {
+    props: {},
+    uniforms: {},
     name: 'gouraud-lighting',
     // Note these are switched between phong and gouraud
     vs: GOURAUD_VS,

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

@@ -1,5 +1,5 @@
-export declare const GOURAUD_VS: string;
-export declare const GOURAUD_FS: string;
+export declare const GOURAUD_VS = "uniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
+export declare const GOURAUD_FS = "uniform materialUniforms {\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 (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n    if (lighting.lightType == 0) {\n      PointLight pointLight = lighting_getPointLight(0);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    } else if (lighting.lightType == 1) {\n      DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    /*\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting.pointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting.directionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    */\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n";
 /**
     for (int i = 0; i < MAX_LIGHTS; i++) {
       if (i >= lighting.pointLightCount) {

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

@@ -1 +1 @@
-{"version":3,"file":"gouraud-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU,QAOtB,CAAC;AAEF,eAAO,MAAM,UAAU,QAkFtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}
+{"version":3,"file":"gouraud-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,8JAOtB,CAAC;AAEF,eAAO,MAAM,UAAU,ihHAkFtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}