@woosh/meep-engine 2.163.2 → 2.163.4

package/src/core/geom/vec3/v3_uniform_sample_cone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Uniformly sample a direction within a cone around +Z (solid-angle uniform).
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number} u random value in [0, 1] (controls polar angle)
+ * @param {number} v random value in [0, 1] (controls azimuth)
+ * @param {number} cos_theta_max cosine of the cone half-angle; 1 = a single direction, -1 = full sphere
+ */
+export function v3_uniform_sample_cone(out: number[] | Float32Array, out_offset: number, u: number, v: number, cos_theta_max: number): void;
+//# sourceMappingURL=v3_uniform_sample_cone.d.ts.map

package/src/core/geom/vec3/v3_uniform_sample_cone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_uniform_sample_cone.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_uniform_sample_cone.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,4CANW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,KACN,MAAM,KACN,MAAM,iBACN,MAAM,QAWhB"}

package/src/core/geom/vec3/v3_uniform_sample_cone.js

@@ -0,0 +1,21 @@
+const TWO_PI = Math.PI * 2;
+
+/**
+ * Uniformly sample a direction within a cone around +Z (solid-angle uniform).
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number} u random value in [0, 1] (controls polar angle)
+ * @param {number} v random value in [0, 1] (controls azimuth)
+ * @param {number} cos_theta_max cosine of the cone half-angle; 1 = a single direction, -1 = full sphere
+ */
+export function v3_uniform_sample_cone(out, out_offset, u, v, cos_theta_max) {
+    const cos_theta = (1.0 - u) + u * cos_theta_max;
+    const sin_theta = Math.sqrt(Math.max(0.0, 1.0 - cos_theta * cos_theta));
+
+    const phi = v * TWO_PI;
+
+    out[out_offset] = Math.cos(phi) * sin_theta;
+    out[out_offset + 1] = Math.sin(phi) * sin_theta;
+    out[out_offset + 2] = cos_theta;
+}

package/src/core/math/physics/brdf/cone_cosine_from_roughness.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cosine of the importance-sampling cone aperture (cos of twice the half-angle)
+ * for a given perceptual roughness, derived by inverting the spherical-gaussian
+ * specular lobe. Roughness 1 maps to roughly a half-pi half-angle.
+ *
+ * Pairs with {@link reflection_sample_weight}; used to bound the set of sampled
+ * directions when convolving an environment map.
+ *
+ * @param {number} linear_roughness perceptual roughness in [0, 1]
+ * @returns {number} cone cosine in [-1, 1]
+ */
+export function cone_cosine_from_roughness(linear_roughness: number): number;
+//# sourceMappingURL=cone_cosine_from_roughness.d.ts.map

package/src/core/math/physics/brdf/cone_cosine_from_roughness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cone_cosine_from_roughness.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/brdf/cone_cosine_from_roughness.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,6DAHW,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/physics/brdf/cone_cosine_from_roughness.js

@@ -0,0 +1,28 @@
+import { lerp } from "../../lerp.js";
+
+/**
+ * Cosine of the importance-sampling cone aperture (cos of twice the half-angle)
+ * for a given perceptual roughness, derived by inverting the spherical-gaussian
+ * specular lobe. Roughness 1 maps to roughly a half-pi half-angle.
+ *
+ * Pairs with {@link reflection_sample_weight}; used to bound the set of sampled
+ * directions when convolving an environment map.
+ *
+ * @param {number} linear_roughness perceptual roughness in [0, 1]
+ * @returns {number} cone cosine in [-1, 1]
+ */
+export function cone_cosine_from_roughness(linear_roughness) {
+    // From linear roughness to GGX roughness input.
+    const m = linear_roughness * linear_roughness;
+
+    // Chosen so that roughness of 1.0 maps to a half-pi cone aperture.
+    const cutoff_value = lerp(0.01, 0.14, m);
+
+    // Inversion of the spherical gaussian: cutoff for the half angle from N.H.
+    const half_angle_cos = Math.log(cutoff_value) * (m * m) * 0.5 + 1.0;
+    const half_angle_cos_sqr = half_angle_cos * half_angle_cos;
+    const half_angle_sin_sqr = Math.max(0.0, 1.0 - half_angle_cos_sqr);
+
+    // cos(2 * half_angle) via the cosine double-angle identity.
+    return half_angle_cos_sqr - half_angle_sin_sqr;
+}

package/src/core/math/physics/brdf/reflection_sample_weight.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Spherical-gaussian approximation of the GGX specular weight for a sample,
+ * used when convolving an environment map for prefiltered reflections.
+ *
+ * From "SG Series Part 4: Specular Lighting From an SG Light Source" by MJP.
+ * Both directions are assumed unit length.
+ *
+ * @param {number} out_x reflection (output) direction
+ * @param {number} out_y
+ * @param {number} out_z
+ * @param {number} in_x sampled (input) direction
+ * @param {number} in_y
+ * @param {number} in_z
+ * @param {number} linear_roughness perceptual roughness in [0, 1]
+ * @returns {number} non-negative weight
+ */
+export function reflection_sample_weight(out_x: number, out_y: number, out_z: number, in_x: number, in_y: number, in_z: number, linear_roughness: number): number;
+//# sourceMappingURL=reflection_sample_weight.d.ts.map

package/src/core/math/physics/brdf/reflection_sample_weight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection_sample_weight.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/brdf/reflection_sample_weight.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,gDATW,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,oBACN,MAAM,GACJ,MAAM,CA+BlB"}

package/src/core/math/physics/brdf/reflection_sample_weight.js

@@ -0,0 +1,48 @@
+import { clamp01 } from "../../clamp01.js";
+
+/**
+ * Spherical-gaussian approximation of the GGX specular weight for a sample,
+ * used when convolving an environment map for prefiltered reflections.
+ *
+ * From "SG Series Part 4: Specular Lighting From an SG Light Source" by MJP.
+ * Both directions are assumed unit length.
+ *
+ * @param {number} out_x reflection (output) direction
+ * @param {number} out_y
+ * @param {number} out_z
+ * @param {number} in_x sampled (input) direction
+ * @param {number} in_y
+ * @param {number} in_z
+ * @param {number} linear_roughness perceptual roughness in [0, 1]
+ * @returns {number} non-negative weight
+ */
+export function reflection_sample_weight(
+    out_x, out_y, out_z,
+    in_x, in_y, in_z,
+    linear_roughness
+) {
+    // From linear roughness to GGX roughness input.
+    const m = linear_roughness * linear_roughness;
+
+    // Half vector H = normalize(out + in)
+    let h_x = out_x + in_x;
+    let h_y = out_y + in_y;
+    let h_z = out_z + in_z;
+
+    const h_length = Math.sqrt(h_x * h_x + h_y * h_y + h_z * h_z);
+
+    if (h_length === 0) {
+        // out and in are antiparallel; no contribution
+        return 0;
+    }
+
+    const inv = 1.0 / h_length;
+
+    // NH = saturate(dot(N = out, H))
+    const NH = clamp01((out_x * h_x + out_y * h_y + out_z * h_z) * inv);
+
+    const m2 = m * m;
+
+    // Spherical Gaussian: exp(2 * (NH - 1) / m^2)
+    return Math.exp(2.0 * (NH - 1.0) / m2);
+}

package/src/engine/graphics/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/GraphicsEngine.js"],"names":[],"mappings":"AA4DA;IAOI;;;;;OAKG;IACH,+BAJW,MAAM,EAgLhB;IAtLD,gCAEC;IAgBG;;;;OAIG;IACH,2BAA+C;IAK/C;;;;;QAOI;;WAEG;;QAEH;;WAEG;;;;;MAMN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;;OAMG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;OAGG;IACH,QAFU,kBAAkB,CAEU;IAWtC;;;OAGG;IACH,aAAkB;IAGlB;;;OAGG;IACH,cAFU,KAAK,CAEgB;IAK/B;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,aAAa,CAEH;IAGpB,+BAA0C;IAU1C;;OAEG;IACH,eAA+B;IAI/B;;;OAGG;IACH,uBAFU,kBAAkB,CAEgB;IAE5C;;;OAGG;IACH,oBAFU,iBAAiB,CAEsB;IAEjD;;;OAGG;IACH,gBAFU,iBAAiB,CAES;IAEpC;;;OAGG;IACH,sBAAoC;IAGpC;;;;OAIG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IACnB,kKAcI;IAGR;;;OAGG;IACH,sBAFa,eAAe,CAI3B;IAED;;;OAGG;IACH,eAFa,aAAa,CAIzB;IAED,mBA8BC;IAED;;;;OAIG;IACH,iCAEC;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,+BAcC;IAED,cAgEC;IAzBsB,8BAA0C;IA2BjE;;;OAGG;IACH,cAFa,MAAM,CAYlB;IAED;;OAEG;IACH,aAQC;IAED;;OAEG;IACH,yBAQC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;OAIG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAczB;IAED;;;;;OAKG;IACH,8BAQC;IAED,0BAEC;IAED;;;OAGG;IACH,4BAFW,cAAc,QA8BxB;IAED;;OAEG;IACH,qBAqBC;IAED;;OAEG;IACH,0BAeC;IAED;;OAEG;IACH,eA8CC;;CACJ;mBA5lBkB,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;mCAajB,uCAAuC;sBAlBnE,OAAO;uBAaS,wBAAwB;8BAbxC,OAAO;4BAYc,+BAA+B;mCAKxB,uCAAuC;kCAKxC,gCAAgC;kCADhC,oCAAoC;gCAPtC,uCAAuC;+BAKxC,4BAA4B"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/GraphicsEngine.js"],"names":[],"mappings":"AAgEA;IAOI;;;;;OAKG;IACH,+BAJW,MAAM,EAgLhB;IAtLD,gCAEC;IAgBG;;;;OAIG;IACH,2BAA+C;IAK/C;;;;;QAOI;;WAEG;;QAEH;;WAEG;;;;;MAMN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;;OAMG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;OAGG;IACH,QAFU,kBAAkB,CAEU;IAWtC;;;OAGG;IACH,aAAkB;IAGlB;;;OAGG;IACH,cAFU,KAAK,CAEgB;IAK/B;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,aAAa,CAEH;IAGpB,+BAA0C;IAU1C;;OAEG;IACH,eAA+B;IAI/B;;;OAGG;IACH,uBAFU,kBAAkB,CAEgB;IAE5C;;;OAGG;IACH,oBAFU,iBAAiB,CAEsB;IAEjD;;;OAGG;IACH,gBAFU,iBAAiB,CAES;IAEpC;;;OAGG;IACH,sBAAoC;IAGpC;;;;OAIG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IACnB,kKAcI;IAGR;;;OAGG;IACH,sBAFa,eAAe,CAI3B;IAED;;;OAGG;IACH,eAFa,aAAa,CAIzB;IAED;;;;;;;;;;;;;OAaG;IACH,iCAHW,MAAM,OAAO,eACb,4BAA4B,QAkCtC;IAED,mBA8BC;IAED;;;;OAIG;IACH,iCAEC;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,+BAcC;IAED,cAgEC;IAzBsB,8BAA0C;IA2BjE;;;OAGG;IACH,cAFa,MAAM,CAYlB;IAED;;OAEG;IACH,aAQC;IAED;;OAEG;IACH,yBAQC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;OAIG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAczB;IAED;;;;;OAKG;IACH,8BAQC;IAED,0BAEC;IAED;;;OAGG;IACH,4BAFW,cAAc,QA8BxB;IAED;;OAEG;IACH,qBAqBC;IAED;;OAEG;IACH,0BAeC;IAED;;OAEG;IACH,eA8CC;;CACJ;mBA7oBkB,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;mCAajB,uCAAuC;sBAlBnE,OAAO;uBAaS,wBAAwB;8BAbxC,OAAO;4BAYc,+BAA+B;mCAKxB,uCAAuC;kCAKxC,gCAAgC;kCADhC,oCAAoC;gCAPtC,uCAAuC;6CAW1B,2CAA2C;+BANzD,4BAA4B"}

package/src/engine/graphics/GraphicsEngine.js

@@ -1,7 +1,10 @@
 import {
+    CubeReflectionMapping,
+    EquirectangularReflectionMapping,
     Group,
     LinearEncoding,
     NoToneMapping,
+    PMREMGenerator,
     Raycaster as ThreeRaycaster,
     Scene as ThreeScene,
     Vector3 as ThreeVector3,
@@ -32,6 +35,7 @@ import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
 import { three_setSceneAutoUpdate } from "./three/three_setSceneAutoUpdate.js";
+import { EnvironmentTextureProjection } from "./texture/EnvironmentTextureProjection.js";
 
 /**
  *
@@ -261,6 +265,54 @@ export class GraphicsEngine {
         return this.renderer;
     }
 
+    /**
+     * Set the scene's environment map. The supplied texture is treated as BOTH:
+     *   - the skybox background (shown directly), and
+     *   - the image-based-lighting (IBL) source for physically based materials.
+     *
+     * The texture is run through three.js' PMREMGenerator to produce the
+     * prefiltered radiance assigned to `scene.environment`, while the original
+     * texture is assigned to `scene.background`.
+     *
+     * Must be called after the renderer has started up.
+     *
+     * @param {THREE.Texture} texture environment texture (equirectangular or cube)
+     * @param {EnvironmentTextureProjection} [projection=EnvironmentTextureProjection.Equirectangular] how the texture is projected
+     */
+    set_environment_texture(texture, projection = EnvironmentTextureProjection.Equirectangular) {
+        assert.defined(texture, 'texture');
+
+        const renderer = this.renderer;
+
+        if (renderer === null || renderer === undefined) {
+            throw new Error('GraphicsEngine.set_environment_texture: renderer is not initialized, call after startup');
+        }
+
+        const pmrem = new PMREMGenerator(renderer);
+
+        let target;
+
+        if (projection === EnvironmentTextureProjection.Equirectangular) {
+            texture.mapping = EquirectangularReflectionMapping;
+            target = pmrem.fromEquirectangular(texture);
+        } else if (projection === EnvironmentTextureProjection.Cube) {
+            texture.mapping = CubeReflectionMapping;
+            target = pmrem.fromCubemap(texture);
+        } else {
+            pmrem.dispose();
+            throw new Error(`GraphicsEngine.set_environment_texture: unsupported projection '${projection}'`);
+        }
+
+        pmrem.dispose();
+
+        const scene = this.scene;
+
+        // prefiltered radiance used by PBR materials as the IBL source
+        scene.environment = target.texture;
+        // original texture shown as the skybox
+        scene.background = texture;
+    }
+
     updateSize() {
         const size = this.viewport.size;
 

package/src/engine/graphics/sh3/sky/hosek/make_environment_sky_hosek.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Build an environment map from the Hosek sky model as a single equirectangular
+ * {@link DataTexture} (three.js' native sky representation,
+ * EquirectangularReflectionMapping).
+ *
+ * This returns the raw (sharp) sky; prefiltering for IBL is done by
+ * `GraphicsEngine.set_environment_texture`, which PMREMs it. The texture can be
+ * used directly as `scene.background`.
+ *
+ * @param {object} options
+ * @param {number[]|Float32Array} options.sun direction towards the sun (engine frame, +Y up); need not be unit length
+ * @param {number} [options.resolution=256] width of the equirectangular map; height is resolution/2
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @returns {THREE.DataTexture}
+ */
+export function make_environment_sky_hosek({ sun, resolution, turbidity, overcast, albedo }: {
+    sun: number[] | Float32Array;
+    resolution?: number;
+    turbidity?: number;
+    overcast?: number;
+    albedo?: number[] | Float32Array;
+}): THREE.DataTexture;
+import { DataTexture } from "three";
+//# sourceMappingURL=make_environment_sky_hosek.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/make_environment_sky_hosek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make_environment_sky_hosek.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/make_environment_sky_hosek.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH;IAP0C,GAAG,EAAlC,MAAM,EAAE,GAAC,YAAY;IACJ,UAAU,GAA3B,MAAM;IACW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IAC0B,MAAM,GAAtC,MAAM,EAAE,GAAC,YAAY;IACnB,iBAAiB,CAwB7B;4BA1CM,OAAO"}

package/src/engine/graphics/sh3/sky/hosek/make_environment_sky_hosek.js

@@ -0,0 +1,49 @@
+import {
+    DataTexture,
+    EquirectangularReflectionMapping,
+    FloatType,
+    LinearFilter,
+    RGBAFormat
+} from "three";
+import { render_hosek_sky_to_equirectangular } from "./render_hosek_sky_to_equirectangular.js";
+
+/**
+ * Build an environment map from the Hosek sky model as a single equirectangular
+ * {@link DataTexture} (three.js' native sky representation,
+ * EquirectangularReflectionMapping).
+ *
+ * This returns the raw (sharp) sky; prefiltering for IBL is done by
+ * `GraphicsEngine.set_environment_texture`, which PMREMs it. The texture can be
+ * used directly as `scene.background`.
+ *
+ * @param {object} options
+ * @param {number[]|Float32Array} options.sun direction towards the sun (engine frame, +Y up); need not be unit length
+ * @param {number} [options.resolution=256] width of the equirectangular map; height is resolution/2
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @returns {THREE.DataTexture}
+ */
+export function make_environment_sky_hosek(
+    {
+        sun,
+        resolution = 256,
+        turbidity = 2,
+        overcast = 0,
+        albedo = [0, 0, 0]
+    }
+) {
+    const width = Math.max(2, resolution | 0);
+    const height = Math.max(1, width >> 1);
+
+    const data = render_hosek_sky_to_equirectangular(sun, width, height, { turbidity, overcast, albedo });
+
+    const texture = new DataTexture(data, width, height, RGBAFormat, FloatType);
+    texture.mapping = EquirectangularReflectionMapping;
+    texture.magFilter = LinearFilter;
+    texture.minFilter = LinearFilter;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+
+    return texture;
+}

package/src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Render the Hosek sky into an equirectangular RGBA float buffer.
+ *
+ * The layout matches three.js' `equirectUv` (so the result can be used directly
+ * as an EquirectangularReflectionMapping texture or fed to PMREMGenerator):
+ *   u = atan2(z, x) / (2pi) + 0.5
+ *   v = asin(y) / pi + 0.5
+ * with +Y up, matching the engine convention.
+ *
+ * @param {number[]|Float32Array} sun direction towards the sun (engine frame, +Y up); need not be unit length
+ * @param {number} width  number of horizontal (longitude) samples
+ * @param {number} height number of vertical (latitude) samples
+ * @param {object} [options]
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @param {Float32Array} [options.target] optional pre-allocated buffer of length width*height*4
+ * @returns {Float32Array} RGBA, row 0 = bottom (-Y), length width*height*4
+ */
+export function render_hosek_sky_to_equirectangular(sun: number[] | Float32Array, width: number, height: number, options?: {
+    turbidity?: number;
+    overcast?: number;
+    albedo?: number[] | Float32Array;
+    target?: Float32Array;
+}): Float32Array;
+//# sourceMappingURL=render_hosek_sky_to_equirectangular.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render_hosek_sky_to_equirectangular.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDAVW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,UACN,MAAM;IAEW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IAC0B,MAAM,GAAtC,MAAM,EAAE,GAAC,YAAY;IACE,MAAM,GAA7B,YAAY;IACV,YAAY,CAgDxB"}

package/src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.js

@@ -0,0 +1,70 @@
+import { make_sky_hosek } from "../../path_tracer/make_sky_hosek.js";
+
+const TWO_PI = Math.PI * 2;
+
+/**
+ * Render the Hosek sky into an equirectangular RGBA float buffer.
+ *
+ * The layout matches three.js' `equirectUv` (so the result can be used directly
+ * as an EquirectangularReflectionMapping texture or fed to PMREMGenerator):
+ *   u = atan2(z, x) / (2pi) + 0.5
+ *   v = asin(y) / pi + 0.5
+ * with +Y up, matching the engine convention.
+ *
+ * @param {number[]|Float32Array} sun direction towards the sun (engine frame, +Y up); need not be unit length
+ * @param {number} width  number of horizontal (longitude) samples
+ * @param {number} height number of vertical (latitude) samples
+ * @param {object} [options]
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @param {Float32Array} [options.target] optional pre-allocated buffer of length width*height*4
+ * @returns {Float32Array} RGBA, row 0 = bottom (-Y), length width*height*4
+ */
+export function render_hosek_sky_to_equirectangular(sun, width, height, options = {}) {
+    const {
+        turbidity = 2,
+        overcast = 0,
+        albedo = [0, 0, 0],
+        target
+    } = options;
+
+    const sky = make_sky_hosek(sun, turbidity, overcast, albedo);
+
+    const data = target !== undefined ? target : new Float32Array(width * height * 4);
+
+    const direction = [0, 0, 0];
+
+    let p = 0;
+
+    for (let j = 0; j < height; j++) {
+        const v = (j + 0.5) / height;
+
+        // v = asin(y)/pi + 0.5  =>  y = sin((v - 0.5) * pi)
+        const latitude = (v - 0.5) * Math.PI;
+        const y = Math.sin(latitude);
+        const cos_latitude = Math.cos(latitude);
+
+        for (let i = 0; i < width; i++) {
+            const u = (i + 0.5) / width;
+
+            // u = atan2(z, x)/(2pi) + 0.5  =>  atan2(z, x) = (u - 0.5) * 2pi
+            const longitude = (u - 0.5) * TWO_PI;
+
+            direction[0] = cos_latitude * Math.cos(longitude);
+            direction[1] = y;
+            direction[2] = cos_latitude * Math.sin(longitude);
+
+            const offset = p * 4;
+
+            // writes linear RGB into data[offset .. offset + 2]
+            sky(data, offset, direction, 0);
+
+            data[offset + 3] = 1;
+
+            p++;
+        }
+    }
+
+    return data;
+}

package/src/engine/graphics/sh3/sky/hosek/setup_environment_sky_from_ecd.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Build a Hosek sky environment and apply it to a graphics scene, deriving the
+ * sun direction from the dataset's directional light.
+ *
+ * Delegates to {@link GraphicsEngine#set_environment_texture}, which PMREMs the
+ * equirectangular sky and assigns it as both the IBL source
+ * (`scene.environment`) and the skybox (`scene.background`).
+ *
+ * @param {GraphicsEngine} graphics
+ * @param {EntityComponentDataset} ecd source of the {@link DirectionalLight} that defines the sun
+ * @param {object} [options]
+ * @param {number} [options.resolution=256] width of the equirectangular map; height is resolution/2
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @returns {THREE.DataTexture} the equirectangular sky texture that was applied
+ */
+export function setup_environment_sky_from_ecd(graphics: GraphicsEngine, ecd: EntityComponentDataset, options?: {
+    resolution?: number;
+    turbidity?: number;
+    overcast?: number;
+    albedo?: number[] | Float32Array;
+}): THREE.DataTexture;
+//# sourceMappingURL=setup_environment_sky_from_ecd.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/setup_environment_sky_from_ecd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup_environment_sky_from_ecd.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/setup_environment_sky_from_ecd.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH;IAN4B,UAAU,GAA3B,MAAM;IACW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IAC0B,MAAM,GAAtC,MAAM,EAAE,GAAC,YAAY;IACnB,MAAM,WAAW,CA+B7B"}

package/src/engine/graphics/sh3/sky/hosek/setup_environment_sky_from_ecd.js

@@ -0,0 +1,51 @@
+import { DirectionalLight } from "../../../render/forward_plus/model/DirectionalLight.js";
+import { EnvironmentTextureProjection } from "../../../texture/EnvironmentTextureProjection.js";
+import { make_environment_sky_hosek } from "./make_environment_sky_hosek.js";
+
+/**
+ * Build a Hosek sky environment and apply it to a graphics scene, deriving the
+ * sun direction from the dataset's directional light.
+ *
+ * Delegates to {@link GraphicsEngine#set_environment_texture}, which PMREMs the
+ * equirectangular sky and assigns it as both the IBL source
+ * (`scene.environment`) and the skybox (`scene.background`).
+ *
+ * @param {GraphicsEngine} graphics
+ * @param {EntityComponentDataset} ecd source of the {@link DirectionalLight} that defines the sun
+ * @param {object} [options]
+ * @param {number} [options.resolution=256] width of the equirectangular map; height is resolution/2
+ * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
+ * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
+ * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
+ * @returns {THREE.DataTexture} the equirectangular sky texture that was applied
+ */
+export function setup_environment_sky_from_ecd(graphics, ecd, options = {}) {
+    const {
+        resolution = 256,
+        turbidity = 2,
+        overcast = 0,
+        albedo = [0, 0, 0]
+    } = options;
+
+    const { component: light } = ecd.getAnyComponent(DirectionalLight);
+
+    /**
+     * Direction *towards* the sun = negated light travel direction.
+     * Falls back to an overhead sun when the dataset has no directional light.
+     * @type {number[]}
+     */
+    let sun;
+
+    if (light !== null) {
+        const d = light.direction;
+        sun = [-d.x, -d.y, -d.z];
+    } else {
+        sun = [0, 1, 0];
+    }
+
+    const texture = make_environment_sky_hosek({ sun, resolution, turbidity, overcast, albedo });
+
+    graphics.set_environment_texture(texture, EnvironmentTextureProjection.Equirectangular);
+
+    return texture;
+}

package/src/engine/graphics/texture/EnvironmentTextureProjection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * How an environment-map texture is projected onto the sphere.
+ */
+export type EnvironmentTextureProjection = number;
+export namespace EnvironmentTextureProjection {
+    let Equirectangular: number;
+    let Cube: number;
+}
+//# sourceMappingURL=EnvironmentTextureProjection.d.ts.map

package/src/engine/graphics/texture/EnvironmentTextureProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentTextureProjection.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/EnvironmentTextureProjection.js"],"names":[],"mappings":";;;2CAEU,MAAM"}

package/src/engine/graphics/texture/EnvironmentTextureProjection.js

@@ -0,0 +1,15 @@
+/**
+ * How an environment-map texture is projected onto the sphere.
+ * @enum {number}
+ */
+export const EnvironmentTextureProjection = {
+    /**
+     * Lat-long / equirectangular projection. This is the default and the
+     * representation three.js uses for sky textures.
+     */
+    Equirectangular: 0,
+    /**
+     * Cube map (six faces packed as a CubeTexture).
+     */
+    Cube: 1
+};

package/src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Convolve an equirectangular radiance map for a single output direction,
+ * importance-sampling a cone around it with a spherical-gaussian GGX weight.
+ * This is the per-texel core of the prefilter (extracted for testing).
+ *
+ * @param {Sampler2D} input equirectangular radiance (the previous, sharper mip)
+ * @param {number} out_x output (reflection) direction, unit length, +Y up
+ * @param {number} out_y
+ * @param {number} out_z
+ * @param {number} roughness perceptual roughness for this convolution step
+ * @param {number} sample_count number of cone samples
+ * @param {number[]|Float32Array} result
+ * @param {number} [result_offset=0]
+ */
+export function convolve_equirectangular_reflection_direction(input: Sampler2D, out_x: number, out_y: number, out_z: number, roughness: number, sample_count: number, result: number[] | Float32Array, result_offset?: number): void;
+/**
+ * Convolve a whole equirectangular level into `output`.
+ *
+ * @param {Sampler2D} input source radiance (previous mip)
+ * @param {Sampler2D} output destination (this mip)
+ * @param {number} roughness convolution roughness for this step
+ * @param {number} sample_count
+ */
+export function convolve_equirectangular_reflection_level(input: Sampler2D, output: Sampler2D, roughness: number, sample_count: number): void;
+/**
+ * Build a prefiltered reflection mip chain from a base equirectangular radiance
+ * map. Mip 0 is the (sharp) base; each subsequent mip is half resolution and
+ * convolved from the previous one, so roughness increases with mip level. This
+ * is the CPU replacement for THREE's PMREMGenerator, decoupled from three.js.
+ *
+ * @param {Sampler2D} base equirectangular RGBA radiance (mip 0)
+ * @param {object} [options]
+ * @param {number} [options.sample_count=32] cone samples per texel (the sky is low frequency)
+ * @param {number} [options.mip_levels] number of levels; defaults to the full chain
+ * @param {number} [options.max_roughness=0.7] roughness reached at the last mip
+ * @returns {Sampler2D[]} mip chain, index 0 = base
+ */
+export function build_equirectangular_reflection_mip_chain(base: Sampler2D, options?: {
+    sample_count?: number;
+    mip_levels?: number;
+    max_roughness?: number;
+}): Sampler2D[];
+import { Sampler2D } from "../sampler/Sampler2D.js";
+//# sourceMappingURL=convolve_equirectangular_reflection.d.ts.map

package/src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convolve_equirectangular_reflection.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,qEATW,SAAS,SACT,MAAM,SACN,MAAM,SACN,MAAM,aACN,MAAM,gBACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,QAiEhB;AAED;;;;;;;GAOG;AACH,iEALW,SAAS,UACT,SAAS,aACT,MAAM,gBACN,MAAM,QA6BhB;AAED;;;;;;;;;;;;GAYG;AACH,iEAPW,SAAS;IAEQ,YAAY,GAA7B,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACJ,SAAS,EAAE,CAoCvB;0BArLyB,yBAAyB"}