@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.5

package/dist/modules/lighting/pbr-material/pbr-scene.js

@@ -0,0 +1,83 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Portable scene tone-mapping modes shared by the GLSL and WGSL PBR implementations. */
+export const PBR_TONE_MAP_MODE = {
+    NONE: 0,
+    REINHARD: 1,
+    KHRONOS_PBR_NEUTRAL: 2,
+    ACES: 3
+};
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+// Match integer precision across stages without relying on a preceding lighting module.
+const uniformBlock = /* glsl */ `\
+layout(std140) uniform pbrSceneUniforms {
+  float exposure;
+  highp int toneMapMode;
+  float environmentIntensity;
+  float environmentRotation;
+  float environmentMipCount;
+  highp int outputEncoding;
+  vec2 framebufferSize;
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+} pbrScene;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+uniform sampler2D pbr_transmissionFramebufferSampler;
+#endif
+`;
+const wgslUniformBlock = /* wgsl */ `\
+struct pbrSceneUniforms {
+  exposure: f32,
+  toneMapMode: i32,
+  environmentIntensity: f32,
+  environmentRotation: f32,
+  environmentMipCount: f32,
+  outputEncoding: i32,
+  framebufferSize: vec2<f32>,
+  viewMatrix: mat4x4<f32>,
+  projectionMatrix: mat4x4<f32>
+};
+
+@group(1) @binding(auto) var<uniform> pbrScene: pbrSceneUniforms;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+@group(1) @binding(auto) var pbr_transmissionFramebufferSampler: texture_2d<f32>;
+@group(1) @binding(auto) var pbr_transmissionFramebufferSamplerSampler: sampler;
+#endif
+`;
+export const pbrScene = {
+    name: 'pbrScene',
+    bindingLayout: [
+        { name: 'pbrScene', group: 1 },
+        { name: 'pbr_transmissionFramebufferSampler', group: 1 }
+    ],
+    source: wgslUniformBlock,
+    vs: uniformBlock,
+    fs: uniformBlock,
+    getUniforms: (props) => props,
+    uniformTypes: {
+        exposure: 'f32',
+        toneMapMode: 'i32',
+        environmentIntensity: 'f32',
+        environmentRotation: 'f32',
+        environmentMipCount: 'f32',
+        outputEncoding: 'i32',
+        framebufferSize: 'vec2<f32>',
+        viewMatrix: 'mat4x4<f32>',
+        projectionMatrix: 'mat4x4<f32>'
+    },
+    defaultUniforms: {
+        exposure: 1,
+        toneMapMode: PBR_TONE_MAP_MODE.KHRONOS_PBR_NEUTRAL,
+        environmentIntensity: 1,
+        environmentRotation: Math.PI * 0.5,
+        environmentMipCount: 1,
+        outputEncoding: 1,
+        framebufferSize: [1, 1],
+        viewMatrix: IDENTITY_MATRIX,
+        projectionMatrix: IDENTITY_MATRIX
+    }
+};
+//# sourceMappingURL=pbr-scene.js.map

package/dist/modules/lighting/pbr-material/pbr-scene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-scene.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-material/pbr-scene.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAM5D,yFAAyF;AACzF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,CAAC;IACP,QAAQ,EAAE,CAAC;IACX,mBAAmB,EAAE,CAAC;IACtB,IAAI,EAAE,CAAC;CACC,CAAC;AAuBX,MAAM,eAAe,GAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAExF,wFAAwF;AACxF,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgB/B,CAAC;AAEF,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBnC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAC;QAC5B,EAAC,IAAI,EAAE,oCAAoC,EAAE,KAAK,EAAE,CAAC,EAAC;KACvD;IACD,MAAM,EAAE,gBAAgB;IACxB,EAAE,EAAE,YAAY;IAChB,EAAE,EAAE,YAAY;IAChB,WAAW,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK;IAC5C,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,oBAAoB,EAAE,KAAK;QAC3B,mBAAmB,EAAE,KAAK;QAC1B,mBAAmB,EAAE,KAAK;QAC1B,cAAc,EAAE,KAAK;QACrB,eAAe,EAAE,WAAW;QAC5B,UAAU,EAAE,aAAa;QACzB,gBAAgB,EAAE,aAAa;KAChC;IACD,eAAe,EAAE;QACf,QAAQ,EAAE,CAAC;QACX,WAAW,EAAE,iBAAiB,CAAC,mBAAmB;QAClD,oBAAoB,EAAE,CAAC;QACvB,mBAAmB,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG;QAClC,mBAAmB,EAAE,CAAC;QACtB,cAAc,EAAE,CAAC;QACjB,eAAe,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACvB,UAAU,EAAE,eAAe;QAC3B,gBAAgB,EAAE,eAAe;KACJ;CACmD,CAAC"}

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

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var phong_material_exports = {};
+__export(phong_material_exports, {
+  phongMaterial: () => phongMaterial
+});
+module.exports = __toCommonJS(phong_material_exports);
+var import_float_colors = require("../../color/float-colors.cjs");
+var import_lighting = require("../lights/lighting.cjs");
+var import_phong_shaders_wgsl = require("./phong-shaders-wgsl.cjs");
+var import_phong_shaders_glsl = require("./phong-shaders-glsl.cjs");
+const DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
+const phongMaterial = {
+  name: "phongMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "phongMaterial", group: 3 }],
+  dependencies: [import_lighting.lighting, import_float_colors.floatColors],
+  // Note these are switched between phong and gouraud
+  source: import_phong_shaders_wgsl.PHONG_WGSL,
+  vs: import_phong_shaders_glsl.PHONG_VS,
+  fs: import_phong_shaders_glsl.PHONG_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: "i32",
+    ambient: "f32",
+    diffuse: "f32",
+    shininess: "f32",
+    specularColor: "vec3<f32>"
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6,
+    shininess: 32,
+    specularColor: DEFAULT_SPECULAR_COLOR
+  },
+  getUniforms(props) {
+    return { ...phongMaterial.defaultUniforms, ...props };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  phongMaterial
+});

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

@@ -0,0 +1,13 @@
+import { NumberArray3 } from '@math.gl/core';
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PhongMaterialProps = {
+    unlit?: boolean;
+    ambient?: number;
+    diffuse?: number;
+    /** Specularity exponent */
+    shininess?: number;
+    specularColor?: NumberArray3;
+};
+/** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
+export declare const phongMaterial: ShaderModule<PhongMaterialProps>;
+//# sourceMappingURL=phong-material.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"phong-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,oCAAiC;AACrD,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,UAAU,EAAC,gCAA6B;AAChD,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gCAA6B;AAWxD,MAAM,sBAAsB,GAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEnE,wIAAwI;AACxI,MAAM,CAAC,MAAM,aAAa,GAAqC;IAC7D,IAAI,EAAE,eAAe;IACrB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAClD,YAAY,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC;IACrC,oDAAoD;IACpD,MAAM,EAAE,UAAU;IAClB,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,QAAQ;IACZ,OAAO,EAAE;QACP,iBAAiB,EAAE,IAAI;KACxB;IACD,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC3B;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,sBAAsB;KACtC;IACD,WAAW,CAAC,KAA0B;QACpC,OAAO,EAAC,GAAG,aAAa,CAAC,eAAe,EAAE,GAAG,KAAK,EAAC,CAAC;IACtD,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,100 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var phong_shaders_glsl_exports = {};
+__export(phong_shaders_glsl_exports, {
+  PHONG_FS: () => PHONG_FS,
+  PHONG_VS: () => PHONG_VS
+});
+module.exports = __toCommonJS(phong_shaders_glsl_exports);
+const PHONG_VS = (
+  /* glsl */
+  `layout(std140) uniform phongMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+`
+);
+const PHONG_FS = (
+  /* glsl */
+  `layout(std140) uniform phongMaterialUniforms {
+  uniform bool unlit;
+  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 * floatColors_normalize(material.specularColor)) * 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;
+  }
+
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  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, view_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, view_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, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PHONG_FS,
+  PHONG_VS
+});

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

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

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

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

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

@@ -0,0 +1,72 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const PHONG_VS = /* glsl */ `\
+layout(std140) uniform phongMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+`;
+export const PHONG_FS = /* glsl */ `\
+layout(std140) uniform phongMaterialUniforms {
+  uniform bool unlit;
+  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 * floatColors_normalize(material.specularColor)) * 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;
+  }
+
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  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, view_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, view_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, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+}
+`;
+//# sourceMappingURL=phong-shaders-glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"phong-shaders-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;CAQlC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DlC,CAAC"}

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

@@ -0,0 +1,153 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var phong_shaders_wgsl_exports = {};
+__export(phong_shaders_wgsl_exports, {
+  PHONG_WGSL: () => PHONG_WGSL
+});
+module.exports = __toCommonJS(phong_shaders_wgsl_exports);
+const PHONG_WGSL = (
+  /* wgsl */
+  `struct phongMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, phongMaterial.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (
+    lambertian * phongMaterial.diffuse * surfaceColor +
+    specular * floatColors_normalize(phongMaterial.specularColor)
+  ) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (phongMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = phongMaterial.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,
+      view_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,
+      view_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, view_direction, normal_worldspace, directionalLight.color);
+  }  
+  
+  return lightColor;
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled != 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    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,
+        view_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,
+        view_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, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  return lightColor;
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PHONG_WGSL
+});

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

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

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

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