@luma.gl/shadertools 9.3.0-alpha.4 → 9.3.0-alpha.8

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

@@ -135,6 +135,9 @@ vec4 picking_filterColor(vec4 color) {
 }
 `;
 /**
+ * Deprecated legacy picking module retained for compatibility with existing
+ * shadertools users such as deck.gl. Keep the shader contract stable.
+ *
  * Provides support for color-coding-based picking and highlighting.
  * In particular, supports picking a specific instance in an instanced
  * draw call and highlighting an instance based on its picking color,

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

@@ -1 +1 @@
-{"version":3,"file":"picking.js","sourceRoot":"","sources":["../../../../src/modules/engine/picking/picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,aAAa;AACb,MAAM,uBAAuB,GAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AA2C3D,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwErB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDrB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,KAAK,EAAE,EAAkB;IACzB,QAAQ,EAAE,EAAqB;IAE/B,IAAI,EAAE,SAAS;IAEf,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,cAAc,EAAE,KAAK;QACrB,sBAAsB,EAAE,WAAW;QACnC,cAAc,EAAE,WAAW;KAC5B;IACD,eAAe,EAAE;QACf,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,cAAc,EAAE,IAAI;QACpB,sBAAsB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACjC,cAAc,EAAE,uBAAuB;KACxC;IAED,EAAE;IACF,EAAE;IACF,WAAW;CACmD,CAAC;AAEjE,SAAS,WAAW,CAAC,OAAqB,EAAE,EAAE,YAA8B;IAC1E,MAAM,QAAQ,GAAG,EAAqB,CAAC;IAEvC,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;QAC9C,4EAA4E;IAC9E,CAAC;SAAM,IAAI,IAAI,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAChD,QAAQ,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACrC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAClC,MAAM,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAiB,CAAC;QACvF,QAAQ,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/B,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACf,CAAC;QACD,QAAQ,CAAC,cAAc,GAAG,KAAqB,CAAC;IAClD,CAAC;IAED,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QAChC,QAAQ,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3C,QAAQ,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACtC,QAAQ,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"picking.js","sourceRoot":"","sources":["../../../../src/modules/engine/picking/picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,aAAa;AACb,MAAM,uBAAuB,GAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AA2C3D,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwErB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDrB,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,KAAK,EAAE,EAAkB;IACzB,QAAQ,EAAE,EAAqB;IAE/B,IAAI,EAAE,SAAS;IAEf,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,cAAc,EAAE,KAAK;QACrB,sBAAsB,EAAE,WAAW;QACnC,cAAc,EAAE,WAAW;KAC5B;IACD,eAAe,EAAE;QACf,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,iBAAiB,EAAE,KAAK;QACxB,cAAc,EAAE,IAAI;QACpB,sBAAsB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACjC,cAAc,EAAE,uBAAuB;KACxC;IAED,EAAE;IACF,EAAE;IACF,WAAW;CACmD,CAAC;AAEjE,SAAS,WAAW,CAAC,OAAqB,EAAE,EAAE,YAA8B;IAC1E,MAAM,QAAQ,GAAG,EAAqB,CAAC;IAEvC,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;QAC9C,4EAA4E;IAC9E,CAAC;SAAM,IAAI,IAAI,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;QAChD,QAAQ,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACrC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAClC,MAAM,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAiB,CAAC;QACvF,QAAQ,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/B,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACf,CAAC;QACD,QAAQ,CAAC,cAAc,GAAG,KAAqB,CAAC;IAClD,CAAC;IAED,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QAChC,QAAQ,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3C,QAAQ,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACtC,QAAQ,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,30 @@
+export declare const source = "\nstruct skinUniforms {\n  jointMatrix: array<mat4x4<f32>, 20>,\n};\n\n@group(0) @binding(auto) var<uniform> skin: skinUniforms;\n\nfn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {\n  return (weights.x * skin.jointMatrix[joints.x])\n       + (weights.y * skin.jointMatrix[joints.y])\n       + (weights.z * skin.jointMatrix[joints.z])\n       + (weights.w * skin.jointMatrix[joints.w]);\n}\n";
+export declare const vs = "\nuniform skinUniforms {\n  mat4 jointMatrix[SKIN_MAX_JOINTS];\n} skin;\n\nmat4 getSkinMatrix(vec4 weights, uvec4 joints) {\n  return (weights.x * skin.jointMatrix[joints.x])\n       + (weights.y * skin.jointMatrix[joints.y])\n       + (weights.z * skin.jointMatrix[joints.z])\n       + (weights.w * skin.jointMatrix[joints.w]);\n}\n\n";
+export declare const fs = "";
+export type SkinProps = {
+    scenegraphsFromGLTF?: any;
+};
+export type SkinUniforms = {
+    jointMatrix?: any;
+};
+export declare const skin: {
+    readonly props: SkinProps;
+    readonly uniforms: SkinUniforms;
+    readonly name: "skin";
+    readonly bindingLayout: readonly [{
+        readonly name: "skin";
+        readonly group: 0;
+    }];
+    readonly dependencies: [];
+    readonly source: "\nstruct skinUniforms {\n  jointMatrix: array<mat4x4<f32>, 20>,\n};\n\n@group(0) @binding(auto) var<uniform> skin: skinUniforms;\n\nfn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {\n  return (weights.x * skin.jointMatrix[joints.x])\n       + (weights.y * skin.jointMatrix[joints.y])\n       + (weights.z * skin.jointMatrix[joints.z])\n       + (weights.w * skin.jointMatrix[joints.w]);\n}\n";
+    readonly vs: "\nuniform skinUniforms {\n  mat4 jointMatrix[SKIN_MAX_JOINTS];\n} skin;\n\nmat4 getSkinMatrix(vec4 weights, uvec4 joints) {\n  return (weights.x * skin.jointMatrix[joints.x])\n       + (weights.y * skin.jointMatrix[joints.y])\n       + (weights.z * skin.jointMatrix[joints.z])\n       + (weights.w * skin.jointMatrix[joints.w]);\n}\n\n";
+    readonly fs: "";
+    readonly defines: {
+        readonly SKIN_MAX_JOINTS: 20;
+    };
+    readonly getUniforms: (props?: SkinProps, prevUniforms?: SkinUniforms) => SkinUniforms;
+    readonly uniformTypes: {
+        readonly jointMatrix: readonly ["mat4x4<f32>", 20];
+    };
+};
+//# sourceMappingURL=skin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skin.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/skin/skin.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM,2ZAalB,CAAC;AAEF,eAAO,MAAM,EAAE,oVAad,CAAC;AAEF,eAAO,MAAM,EAAE,KACd,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,mBAAmB,CAAC,EAAE,GAAG,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,CAAC,EAAE,GAAG,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,IAAI;oBACF,SAAS;uBACN,YAAY;;;;;;;;;;;;;mCAaP,SAAS,iBAAsB,YAAY,KAAG,YAAY;;;;CA+CvB,CAAC"}

package/dist/modules/engine/skin/skin.js

@@ -0,0 +1,86 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Matrix4 } from '@math.gl/core';
+const SKIN_MAX_JOINTS = 20;
+export const source = /* wgsl */ `
+struct skinUniforms {
+  jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
+};
+
+@group(0) @binding(auto) var<uniform> skin: skinUniforms;
+
+fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+`;
+export const vs = /* glsl */ `\
+
+uniform skinUniforms {
+  mat4 jointMatrix[SKIN_MAX_JOINTS];
+} skin;
+
+mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+
+`;
+export const fs = /* glsl */ `\
+`;
+export const skin = {
+    props: {},
+    uniforms: {},
+    name: 'skin',
+    bindingLayout: [{ name: 'skin', group: 0 }],
+    dependencies: [],
+    source,
+    vs,
+    fs,
+    defines: {
+        SKIN_MAX_JOINTS
+    },
+    getUniforms: (props = {}, prevUniforms) => {
+        const { scenegraphsFromGLTF } = props;
+        if (!scenegraphsFromGLTF?.gltf?.skins?.[0]) {
+            return { jointMatrix: [] };
+        }
+        const { inverseBindMatrices, joints, skeleton } = scenegraphsFromGLTF.gltf.skins[0];
+        const matsib = [];
+        const countib = inverseBindMatrices.value.length / 16;
+        for (let i = 0; i < countib; i++) {
+            const slice = inverseBindMatrices.value.subarray(i * 16, i * 16 + 16);
+            matsib.push(new Matrix4(Array.from(slice)));
+        }
+        const top = scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(skeleton);
+        const matrices = {};
+        top.preorderTraversal((node, { worldMatrix }) => {
+            matrices[node.id] = worldMatrix;
+        });
+        const mats = new Float32Array(SKIN_MAX_JOINTS * 16); // 16 floats per 4x4 matrix
+        for (let i = 0; i < SKIN_MAX_JOINTS; ++i) {
+            const nodeIndex = joints[i];
+            if (nodeIndex === undefined)
+                break;
+            const worldMat = matrices[scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(nodeIndex).id];
+            const invBindMat = matsib[i];
+            const Z = new Matrix4().copy(worldMat).multiplyRight(invBindMat);
+            const off = i * 16;
+            for (let j = 0; j < 16; j++) {
+                mats[off + j] = Z[j];
+            }
+        }
+        return {
+            jointMatrix: mats
+        };
+    },
+    uniformTypes: {
+        jointMatrix: ['mat4x4<f32>', SKIN_MAX_JOINTS]
+    }
+};
+//# sourceMappingURL=skin.js.map

package/dist/modules/engine/skin/skin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skin.js","sourceRoot":"","sources":["../../../../src/modules/engine/skin/skin.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,6 @@
 import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
 export type GouraudMaterialProps = {
+    unlit?: boolean;
     ambient?: number;
     diffuse?: number;
     /** Specularity exponent */

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;AAKtE,MAAM,MAAM,oBAAoB,GAAG;IACjC,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,EAAE,YAAY,CAAC,oBAAoB,CAgC9D,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;AAKtE,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;AAEF,yIAAyI;AACzI,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CAmC9D,CAAC"}

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

@@ -8,6 +8,7 @@ import { PHONG_WGSL } from "../phong-material/phong-shaders-wgsl.js";
 export const gouraudMaterial = {
     props: {},
     name: 'gouraudMaterial',
+    bindingLayout: [{ name: 'gouraudMaterial', group: 3 }],
     // Note these are switched between phong and gouraud
     vs: PHONG_FS.replace('phongMaterial', 'gouraudMaterial'),
     fs: PHONG_VS.replace('phongMaterial', 'gouraudMaterial'),
@@ -17,12 +18,14 @@ export const gouraudMaterial = {
     },
     dependencies: [lighting],
     uniformTypes: {
+        unlit: 'i32',
         ambient: 'f32',
         diffuse: 'f32',
         shininess: 'f32',
         specularColor: 'vec3<f32>'
     },
     defaultUniforms: {
+        unlit: false,
         ambient: 0.35,
         diffuse: 0.6,
         shininess: 32,

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;AAUhE,yIAAyI;AACzI,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,KAAK,EAAE,EAA0B;IAEjC,IAAI,EAAE,iBAAiB;IACvB,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,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC3B;IACD,eAAe,EAAE;QACf,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;KAClC;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,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAiB,CAAC;QACpF,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,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gDAA6C;AACxE,OAAO,EAAC,UAAU,EAAC,gDAA6C;AAWhE,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;KAC3B;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;KAClC;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,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,CAAiB,CAAC;QACpF,CAAC;QACD,OAAO,EAAC,GAAG,eAAe,CAAC,eAAe,EAAE,GAAG,QAAQ,EAAC,CAAC;IAC3D,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,26 @@
+import type { Texture } from '@luma.gl/core';
+export type IBLBindings = {
+    pbr_diffuseEnvSampler?: Texture | null;
+    pbr_specularEnvSampler?: Texture | null;
+    pbr_brdfLUT?: Texture | null;
+};
+export declare const iblWGSL = "#ifdef USE_IBL\n@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;\n@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;\n#endif\n";
+export declare const iblGLSL = "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+export declare const ibl: {
+    readonly name: "ibl";
+    readonly firstBindingSlot: 32;
+    readonly bindingLayout: readonly [{
+        readonly name: "pbr_diffuseEnvSampler";
+        readonly group: 2;
+    }, {
+        readonly name: "pbr_specularEnvSampler";
+        readonly group: 2;
+    }, {
+        readonly name: "pbr_brdfLUT";
+        readonly group: 2;
+    }];
+    readonly source: "#ifdef USE_IBL\n@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;\n@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;\n#endif\n";
+    readonly vs: "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+    readonly fs: "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+};
+//# sourceMappingURL=ibl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ibl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/ibl/ibl.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAG3C,MAAM,MAAM,WAAW,GAAG;IACxB,qBAAqB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,OAAO,gbASnB,CAAC;AAEF,eAAO,MAAM,OAAO,sJAMnB,CAAC;AAEF,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;CAW+C,CAAC"}

package/dist/modules/lighting/ibl/ibl.js

@@ -0,0 +1,33 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+export const ibl = {
+    name: 'ibl',
+    firstBindingSlot: 32,
+    bindingLayout: [
+        { name: 'pbr_diffuseEnvSampler', group: 2 },
+        { name: 'pbr_specularEnvSampler', group: 2 },
+        { name: 'pbr_brdfLUT', group: 2 }
+    ],
+    source: iblWGSL,
+    vs: iblGLSL,
+    fs: iblGLSL
+};
+//# sourceMappingURL=ibl.js.map

package/dist/modules/lighting/ibl/ibl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/ibl/ibl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAWpC,MAAM,CAAC,MAAM,OAAO,GAAG,UAAU,CAAC;;;;;;;;;CASjC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,UAAU,CAAC;;;;;;CAMjC,CAAC;AAEF,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,IAAI,EAAE,KAAK;IACX,gBAAgB,EAAE,EAAE;IACpB,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,CAAC,EAAC;QACzC,EAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,CAAC,EAAC;QAC1C,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,EAAC;KAChC;IACD,MAAM,EAAE,OAAO;IACf,EAAE,EAAE,OAAO;IACX,EAAE,EAAE,OAAO;CACkD,CAAC"}

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

@@ -0,0 +1,10 @@
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+    unlit?: boolean;
+    ambient?: number;
+    diffuse?: number;
+};
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export declare const lambertMaterial: ShaderModule<LambertMaterialProps>;
+//# sourceMappingURL=lambert-material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-material.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAKtE,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CAwB9D,CAAC"}

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

@@ -0,0 +1,33 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { lighting } from "../lights/lighting.js";
+import { LAMBERT_WGSL } from "./lambert-shaders-wgsl.js";
+import { LAMBERT_VS, LAMBERT_FS } from "./lambert-shaders-glsl.js";
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export const lambertMaterial = {
+    name: 'lambertMaterial',
+    firstBindingSlot: 0,
+    bindingLayout: [{ name: 'lambertMaterial', group: 3 }],
+    dependencies: [lighting],
+    source: LAMBERT_WGSL,
+    vs: LAMBERT_VS,
+    fs: LAMBERT_FS,
+    defines: {
+        LIGHTING_FRAGMENT: true
+    },
+    uniformTypes: {
+        unlit: 'i32',
+        ambient: 'f32',
+        diffuse: 'f32'
+    },
+    defaultUniforms: {
+        unlit: false,
+        ambient: 0.35,
+        diffuse: 0.6
+    },
+    getUniforms(props) {
+        return { ...lambertMaterial.defaultUniforms, ...props };
+    }
+};
+//# sourceMappingURL=lambert-material.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,YAAY,EAAC,kCAA+B;AACpD,OAAO,EAAC,UAAU,EAAE,UAAU,EAAC,kCAA+B;AAS9D,sFAAsF;AACtF,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,IAAI,EAAE,iBAAiB;IACvB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACpD,YAAY,EAAE,CAAC,QAAQ,CAAC;IACxB,MAAM,EAAE,YAAY;IACpB,EAAE,EAAE,UAAU;IACd,EAAE,EAAE,UAAU;IACd,OAAO,EAAE;QACP,iBAAiB,EAAE,IAAI;KACxB;IACD,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;KACf;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;KACb;IACD,WAAW,CAAC,KAA4B;QACtC,OAAO,EAAC,GAAG,eAAe,CAAC,eAAe,EAAE,GAAG,KAAK,EAAC,CAAC;IACxD,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,3 @@
+export declare const LAMBERT_VS = "uniform lambertMaterialUniforms {\n  uniform bool unlit;\n  uniform float ambient;\n  uniform float diffuse;\n} material;\n";
+export declare const LAMBERT_FS = "uniform lambertMaterialUniforms {\n  uniform bool unlit;\n  uniform float ambient;\n  uniform float diffuse;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {\n  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);\n  return lambertian * material.diffuse * surfaceColor * 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  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, 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, 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, normal_worldspace, directionalLight.color);\n  }\n\n  return lightColor;\n}\n";
+//# sourceMappingURL=lambert-shaders-glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,gIAMtB,CAAC;AAEF,eAAO,MAAM,UAAU,k/DAgDtB,CAAC"}

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

@@ -0,0 +1,60 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const LAMBERT_VS = /* glsl */ `\
+uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`;
+export const LAMBERT_FS = /* glsl */ `\
+uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`;
+//# sourceMappingURL=lambert-shaders-glsl.js.map

package/dist/modules/lighting/lambert-material/lambert-shaders-glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-shaders-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-shaders-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;CAMpC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDpC,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const LAMBERT_WGSL = "struct lambertMaterialUniforms {\n  unlit: u32,\n  ambient: f32,\n  diffuse: f32,\n};\n\n@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;\n\nfn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {\n  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);\n  return lambertian * lambertMaterial.diffuse * surfaceColor * 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 (lambertMaterial.unlit != 0u) {\n    return surfaceColor;\n  }\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  lightColor = lambertMaterial.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      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      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(\n      surfaceColor,\n      -directionalLight.direction,\n      normal_worldspace,\n      directionalLight.color\n    );\n  }\n\n  return lightColor;\n}\n";
+//# sourceMappingURL=lambert-shaders-wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-shaders-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-shaders-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,i1EAoExB,CAAC"}

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

@@ -0,0 +1,73 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const LAMBERT_WGSL = /* wgsl */ `\
+struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`;
+//# sourceMappingURL=lambert-shaders-wgsl.js.map

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

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

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

@@ -1,2 +1,2 @@
-export declare const lightingUniformsGLSL = "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 lightType;\n\n  int directionalLightCount;\n  int pointLightCount;\n\n  vec3 ambientColor;\n\n  vec3 lightColor0;\n  vec3 lightPosition0;\n  vec3 lightDirection0;\n  vec3 lightAttenuation0;\n\n  vec3 lightColor1;\n  vec3 lightPosition1;\n  vec3 lightDirection1;\n  vec3 lightAttenuation1;\n\n  vec3 lightColor2;\n  vec3 lightPosition2;\n  vec3 lightDirection2;\n  vec3 lightAttenuation2;\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  switch (index) {\n    case 0:\n      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);\n    case 1:\n      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);\n    case 2:\n    default:  \n      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);\n  }\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  switch (index) {\n    case 0:\n      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);\n    case 1:\n      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);\n    case 2:\n    default:   \n      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);\n  }\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";
+export declare const lightingUniformsGLSL = "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 SpotLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nstruct UniformLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int directionalLightCount;\n  int pointLightCount;\n  int spotLightCount;\n  vec3 ambientColor;\n  UniformLight lights[5];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  UniformLight light = lighting.lights[index];\n  return PointLight(light.color, light.position, light.attenuation);\n}\n\nSpotLight lighting_getSpotLight(int index) {\n  UniformLight light = lighting.lights[lighting.pointLightCount + index];\n  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  UniformLight light =\n    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];\n  return DirectionalLight(light.color, light.direction);\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\nfloat getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {\n  vec3 light_direction = normalize(positionWorldspace - spotLight.position);\n  float coneFactor = smoothstep(\n    spotLight.coneCos.y,\n    spotLight.coneCos.x,\n    dot(normalize(spotLight.direction), light_direction)\n  );\n  float distanceAttenuation = getPointLightAttenuation(\n    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),\n    distance(spotLight.position, positionWorldspace)\n  );\n  return distanceAttenuation / max(coneFactor, 0.0001);\n}\n\n// #endif\n";
 //# sourceMappingURL=lighting-glsl.d.ts.map

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

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

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

@@ -15,59 +15,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 uniform lightingUniforms {
   int enabled;
-  int lightType;
-
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   vec3 ambientColor;
-
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
-
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
-
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
+  UniformLight lights[5];
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  switch (index) {
-    case 0:
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    case 1:
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    case 2:
-    default:  
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-  }
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  switch (index) {
-    case 0:
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    case 1:
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    case 2:
-    default:   
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-  }
-} 
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -75,6 +67,20 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `;
 //# sourceMappingURL=lighting-glsl.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"lighting-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2E9C,CAAC"}
+{"version":3,"file":"lighting-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF9C,CAAC"}