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

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,9 @@ 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 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"}

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

@@ -1,69 +1,95 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-export const GOURAUD_VS = `\
+export const GOURAUD_VS = /* glsl */ `\
 uniform materialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
 } material;
 `;
-export const GOURAUD_FS = `\
+export const GOURAUD_FS = /* glsl */ `\
 uniform materialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
 } material;
+
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-vec3 halfway_direction = normalize(light_direction + view_direction);
-float lambertian = dot(light_direction, normal_worldspace);
-float specular = 0.0;
-if (lambertian > 0.0) {
-float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-specular = pow(specular_angle, material.shininess);
-}
-lambertian = max(lambertian, 0.0);
-return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+  vec3 halfway_direction = normalize(light_direction + view_direction);
+  float lambertian = dot(light_direction, normal_worldspace);
+  float specular = 0.0;
+  if (lambertian > 0.0) {
+    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
 }
+
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-vec3 lightColor = surfaceColor;
-if (lighting.enabled) {
-vec3 view_direction = normalize(cameraPosition - position_worldspace);
-lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-if (lighting.lightType == 0) {
-PointLight pointLight = lighting_getPointLight(0);
-vec3 light_position_worldspace = pointLight.position;
-vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-} else if (lighting.lightType == 1) {
-DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-}
-}
-return lightColor;
+  vec3 lightColor = surfaceColor;
+
+  if (lighting.enabled) {
+    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+    lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+    if (lighting.lightType == 0) {
+      PointLight pointLight = lighting_getPointLight(0);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    } else if (lighting.lightType == 1) {
+      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+    /*
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting.pointLight[i];
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      DirectionalLight directionalLight = lighting.directionalLight[i];
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+    */
+  }
+  return lightColor;
 }
+
 vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-vec3 lightColor = vec3(0, 0, 0);
-vec3 surfaceColor = vec3(0, 0, 0);
-if (lighting.enabled) {
-vec3 view_direction = normalize(cameraPosition - position_worldspace);
-switch (lighting.lightType) {
-case 0:
-PointLight pointLight = lighting_getPointLight(0);
-vec3 light_position_worldspace = pointLight.position;
-vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-break;
-case 1:
-DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-break;
-}
-}
-return lightColor;
+  vec3 lightColor = vec3(0, 0, 0);
+  vec3 surfaceColor = vec3(0, 0, 0);
+
+  if (lighting.enabled) {
+    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0:
+        PointLight pointLight = lighting_getPointLight(0);
+        vec3 light_position_worldspace = pointLight.position;
+        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+        break;
+
+      case 1:
+        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+        break;
+    }
+  }
+  return lightColor;
 }
 `;
 // TODO - handle multiple lights

package/dist/modules/lighting/lights/lighting-uniforms-glsl.d.ts

@@ -1,2 +1,2 @@
-export declare const lightingUniforms: string;
+export declare const lightingUniforms = "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";
 //# sourceMappingURL=lighting-uniforms-glsl.d.ts.map

package/dist/modules/lighting/lights/lighting-uniforms-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lighting-uniforms-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,QAoD5B,CAAC"}
+{"version":3,"file":"lighting-uniforms-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-uniforms-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,6wCAoD5B,CAAC"}

package/dist/modules/lighting/lights/lighting-uniforms-glsl.js

@@ -1,41 +1,56 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-export const lightingUniforms = `\
+export const lightingUniforms = /* glsl */ `\
 precision highp int;
+
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 struct AmbientLight {
-vec3 color;
+  vec3 color;
 };
+
 struct PointLight {
-vec3 color;
-vec3 position;
-vec3 attenuation;
+  vec3 color;
+  vec3 position;
+  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
+
 struct DirectionalLight {
-vec3 color;
-vec3 direction;
+  vec3 color;
+  vec3 direction;
 };
+
 uniform lightingUniforms {
-int enabled;
-int pointLightCount;
-int directionalLightCount;
-vec3 ambientColor;
-int lightType;
-vec3 lightColor;
-vec3 lightDirection;
-vec3 lightPosition;
-vec3 lightAttenuation;
+  int enabled;
+  int pointLightCount;
+  int directionalLightCount;
+
+  vec3 ambientColor;
+
+  int lightType;
+  vec3 lightColor;
+  vec3 lightDirection;
+  vec3 lightPosition;
+  vec3 lightAttenuation;
+
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
 } lighting;
+
 PointLight lighting_getPointLight(int index) {
-return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
 }
+
 DirectionalLight lighting_getDirectionalLight(int index) {
-return DirectionalLight(lighting.lightColor, lighting.lightDirection);
-}
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
+
 float getPointLightAttenuation(PointLight pointLight, float distance) {
-return pointLight.attenuation.x
-+ pointLight.attenuation.y * distance
-+ pointLight.attenuation.z * distance * distance;
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
 }
+
+// #endif
 `;

package/dist/modules/lighting/lights/lighting.d.ts

@@ -47,6 +47,8 @@ export type LightingUniforms = {
 };
 /** UBO ready lighting module */
 export declare const lighting: {
+    readonly props: LightingProps;
+    readonly uniforms: LightingUniforms;
     readonly name: "lighting";
     readonly defines: {
         readonly MAX_LIGHTS: 5;
@@ -71,10 +73,8 @@ export declare const lighting: {
         readonly lightDirection: readonly [1, 1, 1];
         readonly lightAttenuation: readonly [1, 1, 1];
     };
-    readonly vs: string;
-    readonly fs: string;
-    readonly props: Required<LightingProps>;
-    readonly uniforms: LightingUniforms;
+    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: typeof getUniforms;
 };
 declare function getUniforms(props?: LightingProps, prevUniforms?: Partial<LightingUniforms>): LightingUniforms;

package/dist/modules/lighting/lights/lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lighting.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAUhD,mCAAmC;AACnC,oBAAY,UAAU;IACpB,KAAK,IAAI;IACT,WAAW,IAAI;CAChB;AAED,4BAA4B;AAE5B,MAAM,MAAM,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEjE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAChC,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;IACjB,kBAAkB;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAClC,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACrC,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACtC,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;CACzC,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmC6C,CAAC;AAEnE,iBAAS,WAAW,CAClB,KAAK,CAAC,EAAE,aAAa,EACrB,YAAY,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC3C,gBAAgB,CAoClB"}
+{"version":3,"file":"lighting.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAUhD,mCAAmC;AACnC,oBAAY,UAAU;IACpB,KAAK,IAAI;IACT,WAAW,IAAI;CAChB;AAED,4BAA4B;AAE5B,MAAM,MAAM,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEjE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAChC,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;IACjB,kBAAkB;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAClC,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACrC,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IACtC,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;CACzC,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCgC,CAAC;AAEnE,iBAAS,WAAW,CAClB,KAAK,CAAC,EAAE,aAAa,EACrB,YAAY,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAC3C,gBAAgB,CAoClB"}

package/dist/modules/lighting/lights/lighting.js

@@ -14,6 +14,8 @@ export var LIGHT_TYPE;
 })(LIGHT_TYPE || (LIGHT_TYPE = {}));
 /** UBO ready lighting module */
 export const lighting = {
+    props: {},
+    uniforms: {},
     name: 'lighting',
     defines: {
         MAX_LIGHTS
@@ -42,8 +44,6 @@ export const lighting = {
     },
     vs: lightingUniforms,
     fs: lightingUniforms,
-    props: {},
-    uniforms: {},
     getUniforms
 };
 function getUniforms(props, prevUniforms = {}) {

package/dist/modules/lighting/no-material/dirlight.d.ts

@@ -9,18 +9,18 @@ export declare const FS_WGSL = "uniform dirlightUniforms {\n  vec3 lightDirectio
  * Cheap lighting - single directional light, single dot product, one uniform
  */
 export declare const dirlight: {
+    readonly props: DirlightProps;
+    readonly uniforms: DirlightUniforms;
     readonly name: "dirlight";
     readonly dependencies: [];
-    readonly vs: string;
-    readonly fs: string;
+    readonly vs: "out vec3 dirlight_vNormal;\n\nvoid dirlight_setNormal(vec3 normal) {\n  dirlight_vNormal = normalize(normal);\n}\n";
+    readonly fs: "uniform dirlightUniforms {\n  vec3 lightDirection;\n} dirlight;\n\nin vec3 dirlight_vNormal;\n\n// Returns color attenuated by angle from light source\nvec4 dirlight_filterColor(vec4 color) {\n  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));\n  return vec4(color.rgb * d, color.a);\n}\n";
     readonly uniformTypes: {
         readonly lightDirection: "vec3<f32>";
     };
     readonly defaultUniforms: {
         readonly lightDirection: Float32Array;
     };
-    readonly props: Required<DirlightProps>;
-    readonly uniforms: DirlightProps;
     readonly getUniforms: typeof getUniforms;
 };
 declare function getUniforms(opts?: DirlightProps): DirlightUniforms;

package/dist/modules/lighting/no-material/dirlight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/no-material/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAIhD,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAG7C,eAAO,MAAM,OAAO,mGAInB,CAAC;AAGF,eAAO,MAAM,OAAO,4UAUnB,CAAC;AAwBF;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAoB6C,CAAC;AAEnE,iBAAS,WAAW,CAAC,IAAI,GAAE,aAAwC,GAAG,gBAAgB,CAOrF"}
+{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/no-material/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAGhD,MAAM,MAAM,aAAa,GAAG;IAC1B,cAAc,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAG7C,eAAO,MAAM,OAAO,mGAInB,CAAC;AAGF,eAAO,MAAM,OAAO,4UAUnB,CAAC;AAwBF;;GAEG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;CAoBgC,CAAC;AAEnE,iBAAS,WAAW,CAAC,IAAI,GAAE,aAAwC,GAAG,gBAAgB,CAOrF"}