@luma.gl/shaders 10.0.0-alpha.10 → 10.0.0-alpha.12

package/dist/modules/lighting/prefiltered-environment/prefiltered-environment.cjs

@@ -0,0 +1,379 @@
+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 prefiltered_environment_exports = {};
+__export(prefiltered_environment_exports, {
+  PBR_ENVIRONMENT_FRAGMENT_GLSL: () => PBR_ENVIRONMENT_FRAGMENT_GLSL,
+  PBR_ENVIRONMENT_FRAGMENT_WGSL: () => PBR_ENVIRONMENT_FRAGMENT_WGSL,
+  pbrEnvironmentFilter: () => pbrEnvironmentFilter
+});
+module.exports = __toCommonJS(prefiltered_environment_exports);
+const GLSL_UNIFORMS = (
+  /* glsl */
+  `layout(std140) uniform pbrEnvironmentFilterUniforms {
+  int face;
+  float roughness;
+  int mode;
+  int sampleCount;
+  int sourceEncoding;
+} pbrEnvironmentFilter;
+
+uniform sampler2D pbrEnvironmentSource;
+`
+);
+const WGSL_UNIFORMS = (
+  /* wgsl */
+  `struct PBREnvironmentFilterUniforms {
+  face: i32,
+  roughness: f32,
+  mode: i32,
+  sampleCount: i32,
+  sourceEncoding: i32,
+};
+
+@group(0) @binding(auto) var<uniform> pbrEnvironmentFilter: PBREnvironmentFilterUniforms;
+@group(0) @binding(auto) var pbrEnvironmentSource: texture_2d<f32>;
+@group(0) @binding(auto) var pbrEnvironmentSourceSampler: sampler;
+`
+);
+const pbrEnvironmentFilter = {
+  name: "pbrEnvironmentFilter",
+  bindingLayout: [
+    { name: "pbrEnvironmentFilter", group: 0 },
+    { name: "pbrEnvironmentSource", group: 0 }
+  ],
+  fs: GLSL_UNIFORMS,
+  source: WGSL_UNIFORMS,
+  getUniforms: (properties) => properties,
+  uniformTypes: {
+    face: "i32",
+    roughness: "f32",
+    mode: "i32",
+    sampleCount: "i32",
+    sourceEncoding: "i32"
+  },
+  defaultUniforms: {
+    face: 0,
+    roughness: 0,
+    mode: 0,
+    sampleCount: 64,
+    sourceEncoding: 0
+  }
+};
+const PBR_ENVIRONMENT_FRAGMENT_GLSL = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+precision highp int;
+
+in vec2 uv;
+out vec4 fragmentColor;
+
+const float ENVIRONMENT_PI = 3.141592653589793;
+
+vec2 getEnvironmentHammersley(uint index, uint sampleCount)
+{
+  uint reversedBits = (index << 16u) | (index >> 16u);
+  reversedBits = ((reversedBits & 0x55555555u) << 1u) |
+    ((reversedBits & 0xAAAAAAAAu) >> 1u);
+  reversedBits = ((reversedBits & 0x33333333u) << 2u) |
+    ((reversedBits & 0xCCCCCCCCu) >> 2u);
+  reversedBits = ((reversedBits & 0x0F0F0F0Fu) << 4u) |
+    ((reversedBits & 0xF0F0F0F0u) >> 4u);
+  reversedBits = ((reversedBits & 0x00FF00FFu) << 8u) |
+    ((reversedBits & 0xFF00FF00u) >> 8u);
+  return vec2(
+    float(index) / float(sampleCount),
+    float(reversedBits) * 2.3283064365386963e-10
+  );
+}
+
+vec3 getEnvironmentFaceDirection(int face, vec2 textureCoordinate)
+{
+  vec2 coordinate = textureCoordinate * 2.0 - 1.0;
+  if (face == 0) return normalize(vec3(1.0, -coordinate.y, -coordinate.x));
+  if (face == 1) return normalize(vec3(-1.0, -coordinate.y, coordinate.x));
+  if (face == 2) return normalize(vec3(coordinate.x, 1.0, coordinate.y));
+  if (face == 3) return normalize(vec3(coordinate.x, -1.0, -coordinate.y));
+  if (face == 4) return normalize(vec3(coordinate.x, -coordinate.y, 1.0));
+  return normalize(vec3(-coordinate.x, -coordinate.y, -1.0));
+}
+
+mat3 getEnvironmentTangentBasis(vec3 normal)
+{
+  vec3 up = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+  vec3 tangent = normalize(cross(up, normal));
+  return mat3(tangent, cross(normal, tangent), normal);
+}
+
+vec3 sampleEnvironmentDirection(vec3 direction)
+{
+  vec3 normalizedDirection = normalize(direction);
+  vec2 textureCoordinate = vec2(
+    atan(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,
+    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI
+  );
+  vec3 color = texture(pbrEnvironmentSource, textureCoordinate).rgb;
+  if (pbrEnvironmentFilter.sourceEncoding == 1) {
+    vec3 lower = color / 12.92;
+    vec3 upper = pow((color + 0.055) / 1.055, vec3(2.4));
+    color = mix(lower, upper, step(vec3(0.04045), color));
+  }
+  return color;
+}
+
+vec3 importanceSampleEnvironment(vec2 sequence, vec3 normal, float roughness)
+{
+  float alpha = max(roughness * roughness, 0.0001);
+  float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+  float cosine = sqrt(
+    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)
+  );
+  float sine = sqrt(max(1.0 - cosine * cosine, 0.0));
+  vec3 halfVector = vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine);
+  return normalize(getEnvironmentTangentBasis(normal) * halfVector);
+}
+
+float getEnvironmentGeometry(float normalDotDirection, float roughness)
+{
+  float alpha = roughness * roughness;
+  float factor = alpha * 0.5;
+  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);
+}
+
+vec2 integrateEnvironmentBRDF(vec2 textureCoordinate, int sampleCount)
+{
+  float normalDotView = max(textureCoordinate.x, 0.001);
+  float roughness = 1.0 - textureCoordinate.y;
+  vec3 viewDirection = vec3(sqrt(max(1.0 - normalDotView * normalDotView, 0.0)), 0.0, normalDotView);
+  vec2 integration = vec2(0.0);
+
+  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {
+    if (sampleIndex >= sampleCount) break;
+    vec3 halfVector = importanceSampleEnvironment(
+      getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount)),
+      vec3(0.0, 0.0, 1.0),
+      roughness
+    );
+    vec3 lightDirection = normalize(2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection);
+    float normalDotLight = max(lightDirection.z, 0.0);
+    float normalDotHalf = max(halfVector.z, 0.0);
+    float viewDotHalf = max(dot(viewDirection, halfVector), 0.0);
+    if (normalDotLight > 0.0) {
+      float visibility = getEnvironmentGeometry(normalDotView, roughness) *
+        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /
+        max(normalDotHalf * normalDotView, 0.0001);
+      float fresnel = pow(1.0 - viewDotHalf, 5.0);
+      integration += vec2(1.0 - fresnel, fresnel) * visibility;
+    }
+  }
+  return integration / float(sampleCount);
+}
+
+vec3 integrateEnvironmentDirection(vec3 normal, int sampleCount)
+{
+  vec3 accumulatedColor = vec3(0.0);
+  float accumulatedWeight = 0.0;
+
+  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {
+    if (sampleIndex >= sampleCount) break;
+    vec2 sequence = getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount));
+    vec3 direction;
+    float sampleWeight;
+
+    if (pbrEnvironmentFilter.mode == 1) {
+      float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+      float cosine = sqrt(1.0 - sequence.y);
+      float sine = sqrt(sequence.y);
+      direction = normalize(
+        getEnvironmentTangentBasis(normal) *
+        vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine)
+      );
+      sampleWeight = 1.0;
+    } else {
+      vec3 halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);
+      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);
+      sampleWeight = max(dot(normal, direction), 0.0);
+    }
+
+    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;
+    accumulatedWeight += sampleWeight;
+  }
+
+  return accumulatedColor / max(accumulatedWeight, 0.0001);
+}
+
+void main(void)
+{
+  int sampleCount = max(pbrEnvironmentFilter.sampleCount, 1);
+  if (pbrEnvironmentFilter.mode == 2) {
+    fragmentColor = vec4(integrateEnvironmentBRDF(uv, sampleCount), 0.0, 1.0);
+    return;
+  }
+
+  vec3 direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, uv);
+  fragmentColor = vec4(integrateEnvironmentDirection(direction, sampleCount), 1.0);
+}
+`
+);
+const PBR_ENVIRONMENT_FRAGMENT_WGSL = (
+  /* wgsl */
+  `const ENVIRONMENT_PI: f32 = 3.141592653589793;
+
+fn getEnvironmentHammersley(index: u32, sampleCount: u32) -> vec2f {
+  return vec2f(f32(index) / f32(sampleCount), f32(reverseBits(index)) * 2.3283064365386963e-10);
+}
+
+fn getEnvironmentFaceDirection(face: i32, textureCoordinate: vec2f) -> vec3f {
+  let coordinate = textureCoordinate * 2.0 - 1.0;
+  if (face == 0) { return normalize(vec3f(1.0, -coordinate.y, -coordinate.x)); }
+  if (face == 1) { return normalize(vec3f(-1.0, -coordinate.y, coordinate.x)); }
+  if (face == 2) { return normalize(vec3f(coordinate.x, 1.0, coordinate.y)); }
+  if (face == 3) { return normalize(vec3f(coordinate.x, -1.0, -coordinate.y)); }
+  if (face == 4) { return normalize(vec3f(coordinate.x, -coordinate.y, 1.0)); }
+  return normalize(vec3f(-coordinate.x, -coordinate.y, -1.0));
+}
+
+fn getEnvironmentTangentBasis(normal: vec3f) -> mat3x3f {
+  var up = vec3f(1.0, 0.0, 0.0);
+  if (abs(normal.z) < 0.999) {
+    up = vec3f(0.0, 0.0, 1.0);
+  }
+  let tangent = normalize(cross(up, normal));
+  return mat3x3f(tangent, cross(normal, tangent), normal);
+}
+
+fn sampleEnvironmentDirection(direction: vec3f) -> vec3f {
+  let normalizedDirection = normalize(direction);
+  let textureCoordinate = vec2f(
+    atan2(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,
+    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI
+  );
+  var color = textureSampleLevel(
+    pbrEnvironmentSource,
+    pbrEnvironmentSourceSampler,
+    textureCoordinate,
+    0.0
+  ).rgb;
+  if (pbrEnvironmentFilter.sourceEncoding == 1) {
+    let lower = color / 12.92;
+    let upper = pow((color + 0.055) / 1.055, vec3f(2.4));
+    color = mix(lower, upper, step(vec3f(0.04045), color));
+  }
+  return color;
+}
+
+fn importanceSampleEnvironment(sequence: vec2f, normal: vec3f, roughness: f32) -> vec3f {
+  let alpha = max(roughness * roughness, 0.0001);
+  let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+  let cosine = sqrt(
+    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)
+  );
+  let sine = sqrt(max(1.0 - cosine * cosine, 0.0));
+  let halfVector = vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine);
+  return normalize(getEnvironmentTangentBasis(normal) * halfVector);
+}
+
+fn getEnvironmentGeometry(normalDotDirection: f32, roughness: f32) -> f32 {
+  let alpha = roughness * roughness;
+  let factor = alpha * 0.5;
+  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);
+}
+
+fn integrateEnvironmentBRDF(textureCoordinate: vec2f, sampleCount: u32) -> vec2f {
+  let normalDotView = max(textureCoordinate.x, 0.001);
+  let roughness = 1.0 - textureCoordinate.y;
+  let viewDirection = vec3f(
+    sqrt(max(1.0 - normalDotView * normalDotView, 0.0)),
+    0.0,
+    normalDotView
+  );
+  var integration = vec2f(0.0);
+
+  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {
+    let halfVector = importanceSampleEnvironment(
+      getEnvironmentHammersley(sampleIndex, sampleCount),
+      vec3f(0.0, 0.0, 1.0),
+      roughness
+    );
+    let lightDirection = normalize(
+      2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection
+    );
+    let normalDotLight = max(lightDirection.z, 0.0);
+    let normalDotHalf = max(halfVector.z, 0.0);
+    let viewDotHalf = max(dot(viewDirection, halfVector), 0.0);
+    if (normalDotLight > 0.0) {
+      let visibility = getEnvironmentGeometry(normalDotView, roughness) *
+        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /
+        max(normalDotHalf * normalDotView, 0.0001);
+      let fresnel = pow(1.0 - viewDotHalf, 5.0);
+      integration += vec2f(1.0 - fresnel, fresnel) * visibility;
+    }
+  }
+  return integration / f32(sampleCount);
+}
+
+fn integrateEnvironmentDirection(normal: vec3f, sampleCount: u32) -> vec3f {
+  var accumulatedColor = vec3f(0.0);
+  var accumulatedWeight = 0.0;
+
+  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {
+    let sequence = getEnvironmentHammersley(sampleIndex, sampleCount);
+    var direction: vec3f;
+    var sampleWeight: f32;
+
+    if (pbrEnvironmentFilter.mode == 1) {
+      let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;
+      let cosine = sqrt(1.0 - sequence.y);
+      let sine = sqrt(sequence.y);
+      direction = normalize(
+        getEnvironmentTangentBasis(normal) *
+        vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine)
+      );
+      sampleWeight = 1.0;
+    } else {
+      let halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);
+      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);
+      sampleWeight = max(dot(normal, direction), 0.0);
+    }
+
+    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;
+    accumulatedWeight += sampleWeight;
+  }
+  return accumulatedColor / max(accumulatedWeight, 0.0001);
+}
+
+@fragment
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
+  // ClipSpace UVs increase upward; WebGPU texture rows increase downward.
+  let textureCoordinate = vec2f(inputs.uv.x, 1.0 - inputs.uv.y);
+  let sampleCount = u32(max(pbrEnvironmentFilter.sampleCount, 1));
+  if (pbrEnvironmentFilter.mode == 2) {
+    return vec4f(integrateEnvironmentBRDF(textureCoordinate, sampleCount), 0.0, 1.0);
+  }
+
+  let direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, textureCoordinate);
+  return vec4f(integrateEnvironmentDirection(direction, sampleCount), 1.0);
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PBR_ENVIRONMENT_FRAGMENT_GLSL,
+  PBR_ENVIRONMENT_FRAGMENT_WGSL,
+  pbrEnvironmentFilter
+});

package/dist/modules/lighting/prefiltered-environment/prefiltered-environment.d.ts

@@ -0,0 +1,41 @@
+export type PBREnvironmentFilterUniforms = {
+    face: number;
+    roughness: number;
+    mode: number;
+    sampleCount: number;
+    sourceEncoding: number;
+};
+export type PBREnvironmentFilterBindings<TextureT = unknown> = {
+    pbrEnvironmentSource: TextureT;
+};
+export type PBREnvironmentFilterProps<TextureT = unknown> = PBREnvironmentFilterUniforms & PBREnvironmentFilterBindings<TextureT>;
+export declare const pbrEnvironmentFilter: {
+    readonly name: "pbrEnvironmentFilter";
+    readonly bindingLayout: readonly [{
+        readonly name: "pbrEnvironmentFilter";
+        readonly group: 0;
+    }, {
+        readonly name: "pbrEnvironmentSource";
+        readonly group: 0;
+    }];
+    readonly fs: "layout(std140) uniform pbrEnvironmentFilterUniforms {\n  int face;\n  float roughness;\n  int mode;\n  int sampleCount;\n  int sourceEncoding;\n} pbrEnvironmentFilter;\n\nuniform sampler2D pbrEnvironmentSource;\n";
+    readonly source: "struct PBREnvironmentFilterUniforms {\n  face: i32,\n  roughness: f32,\n  mode: i32,\n  sampleCount: i32,\n  sourceEncoding: i32,\n};\n\n@group(0) @binding(auto) var<uniform> pbrEnvironmentFilter: PBREnvironmentFilterUniforms;\n@group(0) @binding(auto) var pbrEnvironmentSource: texture_2d<f32>;\n@group(0) @binding(auto) var pbrEnvironmentSourceSampler: sampler;\n";
+    readonly getUniforms: (properties: Partial<PBREnvironmentFilterProps>) => Partial<PBREnvironmentFilterProps<unknown>>;
+    readonly uniformTypes: {
+        readonly face: "i32";
+        readonly roughness: "f32";
+        readonly mode: "i32";
+        readonly sampleCount: "i32";
+        readonly sourceEncoding: "i32";
+    };
+    readonly defaultUniforms: {
+        readonly face: 0;
+        readonly roughness: 0;
+        readonly mode: 0;
+        readonly sampleCount: 64;
+        readonly sourceEncoding: 0;
+    };
+};
+export declare const PBR_ENVIRONMENT_FRAGMENT_GLSL = "#version 300 es\nprecision highp float;\nprecision highp int;\n\nin vec2 uv;\nout vec4 fragmentColor;\n\nconst float ENVIRONMENT_PI = 3.141592653589793;\n\nvec2 getEnvironmentHammersley(uint index, uint sampleCount)\n{\n  uint reversedBits = (index << 16u) | (index >> 16u);\n  reversedBits = ((reversedBits & 0x55555555u) << 1u) |\n    ((reversedBits & 0xAAAAAAAAu) >> 1u);\n  reversedBits = ((reversedBits & 0x33333333u) << 2u) |\n    ((reversedBits & 0xCCCCCCCCu) >> 2u);\n  reversedBits = ((reversedBits & 0x0F0F0F0Fu) << 4u) |\n    ((reversedBits & 0xF0F0F0F0u) >> 4u);\n  reversedBits = ((reversedBits & 0x00FF00FFu) << 8u) |\n    ((reversedBits & 0xFF00FF00u) >> 8u);\n  return vec2(\n    float(index) / float(sampleCount),\n    float(reversedBits) * 2.3283064365386963e-10\n  );\n}\n\nvec3 getEnvironmentFaceDirection(int face, vec2 textureCoordinate)\n{\n  vec2 coordinate = textureCoordinate * 2.0 - 1.0;\n  if (face == 0) return normalize(vec3(1.0, -coordinate.y, -coordinate.x));\n  if (face == 1) return normalize(vec3(-1.0, -coordinate.y, coordinate.x));\n  if (face == 2) return normalize(vec3(coordinate.x, 1.0, coordinate.y));\n  if (face == 3) return normalize(vec3(coordinate.x, -1.0, -coordinate.y));\n  if (face == 4) return normalize(vec3(coordinate.x, -coordinate.y, 1.0));\n  return normalize(vec3(-coordinate.x, -coordinate.y, -1.0));\n}\n\nmat3 getEnvironmentTangentBasis(vec3 normal)\n{\n  vec3 up = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);\n  vec3 tangent = normalize(cross(up, normal));\n  return mat3(tangent, cross(normal, tangent), normal);\n}\n\nvec3 sampleEnvironmentDirection(vec3 direction)\n{\n  vec3 normalizedDirection = normalize(direction);\n  vec2 textureCoordinate = vec2(\n    atan(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,\n    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI\n  );\n  vec3 color = texture(pbrEnvironmentSource, textureCoordinate).rgb;\n  if (pbrEnvironmentFilter.sourceEncoding == 1) {\n    vec3 lower = color / 12.92;\n    vec3 upper = pow((color + 0.055) / 1.055, vec3(2.4));\n    color = mix(lower, upper, step(vec3(0.04045), color));\n  }\n  return color;\n}\n\nvec3 importanceSampleEnvironment(vec2 sequence, vec3 normal, float roughness)\n{\n  float alpha = max(roughness * roughness, 0.0001);\n  float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;\n  float cosine = sqrt(\n    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)\n  );\n  float sine = sqrt(max(1.0 - cosine * cosine, 0.0));\n  vec3 halfVector = vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine);\n  return normalize(getEnvironmentTangentBasis(normal) * halfVector);\n}\n\nfloat getEnvironmentGeometry(float normalDotDirection, float roughness)\n{\n  float alpha = roughness * roughness;\n  float factor = alpha * 0.5;\n  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);\n}\n\nvec2 integrateEnvironmentBRDF(vec2 textureCoordinate, int sampleCount)\n{\n  float normalDotView = max(textureCoordinate.x, 0.001);\n  float roughness = 1.0 - textureCoordinate.y;\n  vec3 viewDirection = vec3(sqrt(max(1.0 - normalDotView * normalDotView, 0.0)), 0.0, normalDotView);\n  vec2 integration = vec2(0.0);\n\n  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {\n    if (sampleIndex >= sampleCount) break;\n    vec3 halfVector = importanceSampleEnvironment(\n      getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount)),\n      vec3(0.0, 0.0, 1.0),\n      roughness\n    );\n    vec3 lightDirection = normalize(2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection);\n    float normalDotLight = max(lightDirection.z, 0.0);\n    float normalDotHalf = max(halfVector.z, 0.0);\n    float viewDotHalf = max(dot(viewDirection, halfVector), 0.0);\n    if (normalDotLight > 0.0) {\n      float visibility = getEnvironmentGeometry(normalDotView, roughness) *\n        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /\n        max(normalDotHalf * normalDotView, 0.0001);\n      float fresnel = pow(1.0 - viewDotHalf, 5.0);\n      integration += vec2(1.0 - fresnel, fresnel) * visibility;\n    }\n  }\n  return integration / float(sampleCount);\n}\n\nvec3 integrateEnvironmentDirection(vec3 normal, int sampleCount)\n{\n  vec3 accumulatedColor = vec3(0.0);\n  float accumulatedWeight = 0.0;\n\n  for (int sampleIndex = 0; sampleIndex < 1024; sampleIndex++) {\n    if (sampleIndex >= sampleCount) break;\n    vec2 sequence = getEnvironmentHammersley(uint(sampleIndex), uint(sampleCount));\n    vec3 direction;\n    float sampleWeight;\n\n    if (pbrEnvironmentFilter.mode == 1) {\n      float azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;\n      float cosine = sqrt(1.0 - sequence.y);\n      float sine = sqrt(sequence.y);\n      direction = normalize(\n        getEnvironmentTangentBasis(normal) *\n        vec3(cos(azimuth) * sine, sin(azimuth) * sine, cosine)\n      );\n      sampleWeight = 1.0;\n    } else {\n      vec3 halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);\n      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);\n      sampleWeight = max(dot(normal, direction), 0.0);\n    }\n\n    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;\n    accumulatedWeight += sampleWeight;\n  }\n\n  return accumulatedColor / max(accumulatedWeight, 0.0001);\n}\n\nvoid main(void)\n{\n  int sampleCount = max(pbrEnvironmentFilter.sampleCount, 1);\n  if (pbrEnvironmentFilter.mode == 2) {\n    fragmentColor = vec4(integrateEnvironmentBRDF(uv, sampleCount), 0.0, 1.0);\n    return;\n  }\n\n  vec3 direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, uv);\n  fragmentColor = vec4(integrateEnvironmentDirection(direction, sampleCount), 1.0);\n}\n";
+export declare const PBR_ENVIRONMENT_FRAGMENT_WGSL = "const ENVIRONMENT_PI: f32 = 3.141592653589793;\n\nfn getEnvironmentHammersley(index: u32, sampleCount: u32) -> vec2f {\n  return vec2f(f32(index) / f32(sampleCount), f32(reverseBits(index)) * 2.3283064365386963e-10);\n}\n\nfn getEnvironmentFaceDirection(face: i32, textureCoordinate: vec2f) -> vec3f {\n  let coordinate = textureCoordinate * 2.0 - 1.0;\n  if (face == 0) { return normalize(vec3f(1.0, -coordinate.y, -coordinate.x)); }\n  if (face == 1) { return normalize(vec3f(-1.0, -coordinate.y, coordinate.x)); }\n  if (face == 2) { return normalize(vec3f(coordinate.x, 1.0, coordinate.y)); }\n  if (face == 3) { return normalize(vec3f(coordinate.x, -1.0, -coordinate.y)); }\n  if (face == 4) { return normalize(vec3f(coordinate.x, -coordinate.y, 1.0)); }\n  return normalize(vec3f(-coordinate.x, -coordinate.y, -1.0));\n}\n\nfn getEnvironmentTangentBasis(normal: vec3f) -> mat3x3f {\n  var up = vec3f(1.0, 0.0, 0.0);\n  if (abs(normal.z) < 0.999) {\n    up = vec3f(0.0, 0.0, 1.0);\n  }\n  let tangent = normalize(cross(up, normal));\n  return mat3x3f(tangent, cross(normal, tangent), normal);\n}\n\nfn sampleEnvironmentDirection(direction: vec3f) -> vec3f {\n  let normalizedDirection = normalize(direction);\n  let textureCoordinate = vec2f(\n    atan2(normalizedDirection.z, normalizedDirection.x) / (2.0 * ENVIRONMENT_PI) + 0.5,\n    acos(clamp(normalizedDirection.y, -1.0, 1.0)) / ENVIRONMENT_PI\n  );\n  var color = textureSampleLevel(\n    pbrEnvironmentSource,\n    pbrEnvironmentSourceSampler,\n    textureCoordinate,\n    0.0\n  ).rgb;\n  if (pbrEnvironmentFilter.sourceEncoding == 1) {\n    let lower = color / 12.92;\n    let upper = pow((color + 0.055) / 1.055, vec3f(2.4));\n    color = mix(lower, upper, step(vec3f(0.04045), color));\n  }\n  return color;\n}\n\nfn importanceSampleEnvironment(sequence: vec2f, normal: vec3f, roughness: f32) -> vec3f {\n  let alpha = max(roughness * roughness, 0.0001);\n  let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;\n  let cosine = sqrt(\n    (1.0 - sequence.y) / max(1.0 + (alpha * alpha - 1.0) * sequence.y, 0.0001)\n  );\n  let sine = sqrt(max(1.0 - cosine * cosine, 0.0));\n  let halfVector = vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine);\n  return normalize(getEnvironmentTangentBasis(normal) * halfVector);\n}\n\nfn getEnvironmentGeometry(normalDotDirection: f32, roughness: f32) -> f32 {\n  let alpha = roughness * roughness;\n  let factor = alpha * 0.5;\n  return normalDotDirection / max(normalDotDirection * (1.0 - factor) + factor, 0.0001);\n}\n\nfn integrateEnvironmentBRDF(textureCoordinate: vec2f, sampleCount: u32) -> vec2f {\n  let normalDotView = max(textureCoordinate.x, 0.001);\n  let roughness = 1.0 - textureCoordinate.y;\n  let viewDirection = vec3f(\n    sqrt(max(1.0 - normalDotView * normalDotView, 0.0)),\n    0.0,\n    normalDotView\n  );\n  var integration = vec2f(0.0);\n\n  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {\n    let halfVector = importanceSampleEnvironment(\n      getEnvironmentHammersley(sampleIndex, sampleCount),\n      vec3f(0.0, 0.0, 1.0),\n      roughness\n    );\n    let lightDirection = normalize(\n      2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection\n    );\n    let normalDotLight = max(lightDirection.z, 0.0);\n    let normalDotHalf = max(halfVector.z, 0.0);\n    let viewDotHalf = max(dot(viewDirection, halfVector), 0.0);\n    if (normalDotLight > 0.0) {\n      let visibility = getEnvironmentGeometry(normalDotView, roughness) *\n        getEnvironmentGeometry(normalDotLight, roughness) * viewDotHalf /\n        max(normalDotHalf * normalDotView, 0.0001);\n      let fresnel = pow(1.0 - viewDotHalf, 5.0);\n      integration += vec2f(1.0 - fresnel, fresnel) * visibility;\n    }\n  }\n  return integration / f32(sampleCount);\n}\n\nfn integrateEnvironmentDirection(normal: vec3f, sampleCount: u32) -> vec3f {\n  var accumulatedColor = vec3f(0.0);\n  var accumulatedWeight = 0.0;\n\n  for (var sampleIndex = 0u; sampleIndex < sampleCount; sampleIndex++) {\n    let sequence = getEnvironmentHammersley(sampleIndex, sampleCount);\n    var direction: vec3f;\n    var sampleWeight: f32;\n\n    if (pbrEnvironmentFilter.mode == 1) {\n      let azimuth = 2.0 * ENVIRONMENT_PI * sequence.x;\n      let cosine = sqrt(1.0 - sequence.y);\n      let sine = sqrt(sequence.y);\n      direction = normalize(\n        getEnvironmentTangentBasis(normal) *\n        vec3f(cos(azimuth) * sine, sin(azimuth) * sine, cosine)\n      );\n      sampleWeight = 1.0;\n    } else {\n      let halfVector = importanceSampleEnvironment(sequence, normal, pbrEnvironmentFilter.roughness);\n      direction = normalize(2.0 * dot(normal, halfVector) * halfVector - normal);\n      sampleWeight = max(dot(normal, direction), 0.0);\n    }\n\n    accumulatedColor += sampleEnvironmentDirection(direction) * sampleWeight;\n    accumulatedWeight += sampleWeight;\n  }\n  return accumulatedColor / max(accumulatedWeight, 0.0001);\n}\n\n@fragment\nfn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {\n  // ClipSpace UVs increase upward; WebGPU texture rows increase downward.\n  let textureCoordinate = vec2f(inputs.uv.x, 1.0 - inputs.uv.y);\n  let sampleCount = u32(max(pbrEnvironmentFilter.sampleCount, 1));\n  if (pbrEnvironmentFilter.mode == 2) {\n    return vec4f(integrateEnvironmentBRDF(textureCoordinate, sampleCount), 0.0, 1.0);\n  }\n\n  let direction = getEnvironmentFaceDirection(pbrEnvironmentFilter.face, textureCoordinate);\n  return vec4f(integrateEnvironmentDirection(direction, sampleCount), 1.0);\n}\n";
+//# sourceMappingURL=prefiltered-environment.d.ts.map

package/dist/modules/lighting/prefiltered-environment/prefiltered-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefiltered-environment.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/prefiltered-environment/prefiltered-environment.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,4BAA4B,CAAC,QAAQ,GAAG,OAAO,IAAI;IAC7D,oBAAoB,EAAE,QAAQ,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,QAAQ,GAAG,OAAO,IAAI,4BAA4B,GACtF,4BAA4B,CAAC,QAAQ,CAAC,CAAC;AA4BzC,eAAO,MAAM,oBAAoB;;;;;;;;;;;uCAQL,OAAO,CAAC,yBAAyB,CAAC;;;;;;;;;;;;;;;CAmB7D,CAAC;AAEF,eAAO,MAAM,6BAA6B,guLAyJzC,CAAC;AAEF,eAAO,MAAM,6BAA6B,m8KA0IzC,CAAC"}