@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.js

@@ -1,69 +1,97 @@
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
-import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
-
-/**
- * Assumes following in the context:
- *      tSkyLutTransmittance: texture_2d<f32>   (sample type "float", i.e. filterable)
- *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
- *
- * The LUT is rgba16float, which is filterable in core WebGPU -- only the 32-bit float
- * formats need the `float32-filterable` feature -- so this goes through the texture unit
- * rather than the 4-tap `texture_sample_bilinear_uv`. Clamp-to-edge on the sampler
- * reproduces that function's per-corner clamping.
- *
- * The half-texel inset {@link chunk_sky_lut_uv} applies needs the LUT's resolution, which is
- * read from the binding rather than passed in: the texture is the authority on its own size,
- * and a caller cannot get it wrong.
- *
- * see {@link shader_transmittance_lut}
- * @type {CodeChunk}
- */
-export const chunk_sample_transmittance_lut_params = CodeChunk.from(
-//language=WGSL
-    `
-fn sample_transmittance_lut_params(
-    height: f32,
-    sun_cos_zenith_angle: f32
-) -> vec3<f32>{
-
-    let uv = sky_lut_uv(
-        height,
-        sun_cos_zenith_angle,
-        vec2<f32>(textureDimensions(tSkyLutTransmittance))
-    );
-
-    return textureSampleLevel(tSkyLutTransmittance, sSkyLut, uv, 0.0).rgb;
-
-}
-    `, [
-        chunk_sky_lut_uv,
-    ]
-);
-
-/**
- * {@link chunk_sample_transmittance_lut_params} from a world-space position. A ray-march that
- * already knows the altitude and the local up vector should build the pair itself and call
- * the primitive, rather than have this recover them with another square root.
- *
- * @type {CodeChunk}
- */
-export const chunk_sample_transmittance_lut = CodeChunk.from(
-//language=WGSL
-    `
-fn sample_transmittance_lut(
-    pos: vec3<f32>,
-    sunDir: vec3<f32>
-) -> vec3<f32>{
-
-    let params = sky_lut_params(pos, sunDir);
-
-    return sample_transmittance_lut_params(params.x, params.y);
-
-}    
-    `,
-    [
-        chunk_sample_transmittance_lut_params,
-        chunk_sky_lut_params,
-    ]
-);
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
+import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
+import { SKY_LUT_SAMPLER_RESOURCE, SKY_LUT_TRANSMITTANCE_RESOURCE } from "./SAMPLER_SKY_LUT.js";
+
+/**
+ * Parameterised transmittance LUT lookup using `atm.atmosphere_height`.
+ *
+ * Assumes in shader scope:
+ *      tSkyLutTransmittance: texture_2d<f32>   (sample type "float", filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sample_transmittance_lut_params_for = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_transmittance_lut_params_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    height: f32,
+    sun_cos_zenith_angle: f32
+) -> vec3<f32> {
+    let uv = sky_lut_uv_for(
+        atm,
+        height,
+        sun_cos_zenith_angle,
+        vec2<f32>(textureDimensions(tSkyLutTransmittance))
+    );
+
+    return textureSampleLevel(tSkyLutTransmittance, sSkyLut, uv, 0.0).rgb;
+}
+    `, [
+        chunk_atmosphere_parameters,
+    ]
+);
+
+chunk_sample_transmittance_lut_params_for.requireResource(SKY_LUT_TRANSMITTANCE_RESOURCE);
+chunk_sample_transmittance_lut_params_for.requireResource(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Earth-default transmittance LUT lookup by `(height, sun_cos_zenith_angle)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sample_transmittance_lut_params = CodeChunk.from(
+//language=WGSL
+    `
+fn sample_transmittance_lut_params(
+    height: f32,
+    sun_cos_zenith_angle: f32
+) -> vec3<f32>{
+
+    let uv = sky_lut_uv(
+        height,
+        sun_cos_zenith_angle,
+        vec2<f32>(textureDimensions(tSkyLutTransmittance))
+    );
+
+    return textureSampleLevel(tSkyLutTransmittance, sSkyLut, uv, 0.0).rgb;
+
+}
+    `, [
+        chunk_sky_lut_uv,
+    ]
+);
+
+chunk_sample_transmittance_lut_params.requireResource(SKY_LUT_TRANSMITTANCE_RESOURCE);
+chunk_sample_transmittance_lut_params.requireResource(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * {@link chunk_sample_transmittance_lut_params} from a world-space position.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sample_transmittance_lut = CodeChunk.from(
+//language=WGSL
+    `
+fn sample_transmittance_lut(
+    pos: vec3<f32>,
+    sunDir: vec3<f32>
+) -> vec3<f32>{
+
+    let params = sky_lut_params(pos, sunDir);
+
+    return sample_transmittance_lut_params(params.x, params.y);
+
+}
+    `,
+    [
+        chunk_sample_transmittance_lut_params,
+        chunk_sky_lut_params,
+    ]
+);

package/src/shade/renderer/atmosphere/chunk_sky_irradiance_lut_encode_uv.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Hillaire (2020) §5.3 Sky-View LUT coordinate encoding and decoding.
+ *
+ * Parameterisation (`resolution` must have an even height, e.g. `192 × 108`):
+ * - `u` encodes relative azimuth to the sun in $[0, \pi]$ via half-texel-inset sub-UVs:
+ *   exploiting mirror symmetry across the sun-zenith plane gives $2\times$ horizontal angular
+ *   resolution and eliminates any $0 / 2\pi$ wrap seam under `clamp-to-edge` bilinear filtering.
+ * - `v` splits cleanly at $0.5$ into two independent $H/2$-row sub-UV ranges with square-root
+ *   horizon clustering:
+ *   - rows $[0, H/2 - 1]$ (`v < 0.5`): ground-intersecting rays ($\theta \in (\theta_{\text{horizon}}, \pi]$);
+ *   - rows $[H/2, H - 1]$ (`v >= 0.5`): sky rays ($\theta \in [0, \theta_{\text{horizon}}]$).
+ *   Because both sub-ranges carry half-texel insets at their inner boundary, hardware bilinear
+ *   filtering never bleeds planet ground texels into sky horizon texels or vice versa.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020), §5.3
+ * @type {CodeChunk}
+ */
 export const chunk_sky_irradiance_lut_encode_uv: CodeChunk;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sky_irradiance_lut_encode_uv.d.ts.map

package/src/shade/renderer/atmosphere/chunk_sky_irradiance_lut_encode_uv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sky_irradiance_lut_encode_uv.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sky_irradiance_lut_encode_uv.js"],"names":[],"mappings":"AAaA,2DA8CM;0BAjDoB,iCAAiC"}
+{"version":3,"file":"chunk_sky_irradiance_lut_encode_uv.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sky_irradiance_lut_encode_uv.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH,iDAFU,SAAS,CAyGjB;0BA9HwB,iCAAiC"}

package/src/shade/renderer/atmosphere/chunk_sky_irradiance_lut_encode_uv.js

@@ -1,60 +1,129 @@
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import {
-    chunk_position_relative_to_planet_center
-} from "../shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js";
-import { PLANET_RADIUS_DECLARATION } from "../shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js";
 import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
 import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
-import {
-    chunk_texture_sample_bilinear_uv
-} from "../shader/chunk/texture/sample/chunk_texture_sample_bilinear_uv.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ATMOSPHERE_ALTITUDE_CUTOFF } from "./ATMOSPHERE_ALTITUDE_CUTOFF.js";
+import {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
 
+/**
+ * Hillaire (2020) §5.3 Sky-View LUT coordinate encoding and decoding.
+ *
+ * Parameterisation (`resolution` must have an even height, e.g. `192 × 108`):
+ * - `u` encodes relative azimuth to the sun in $[0, \pi]$ via half-texel-inset sub-UVs:
+ *   exploiting mirror symmetry across the sun-zenith plane gives $2\times$ horizontal angular
+ *   resolution and eliminates any $0 / 2\pi$ wrap seam under `clamp-to-edge` bilinear filtering.
+ * - `v` splits cleanly at $0.5$ into two independent $H/2$-row sub-UV ranges with square-root
+ *   horizon clustering:
+ *   - rows $[0, H/2 - 1]$ (`v < 0.5`): ground-intersecting rays ($\theta \in (\theta_{\text{horizon}}, \pi]$);
+ *   - rows $[H/2, H - 1]$ (`v >= 0.5`): sky rays ($\theta \in [0, \theta_{\text{horizon}}]$).
+ *   Because both sub-ranges carry half-texel insets at their inner boundary, hardware bilinear
+ *   filtering never bleeds planet ground texels into sky horizon texels or vice versa.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020), §5.3
+ * @type {CodeChunk}
+ */
 export const chunk_sky_irradiance_lut_encode_uv = CodeChunk.from(
     //language=WGSL
     `
-fn sky_irradiance_lut_encode_uv(viewPos: vec3<f32>, rayDir: vec3<f32>, sunDir:vec3<f32>) -> vec2<f32>{
-    let relative_position = position_relative_to_planet_center(viewPos);
-    
-    let height = clamp( length(relative_position), PLANET_RADIUS + ${ATMOSPHERE_ALTITUDE_CUTOFF}, PLANET_RADIUS + ATMOSPHERE_HEIGHT - ${ATMOSPHERE_ALTITUDE_CUTOFF} );
-    
-    let up = normalize(relative_position);
-    
-    let horizonAngle = safe_acos(sqrt(height * height - PLANET_RADIUS * PLANET_RADIUS) / height);
-    let altitudeAngle = horizonAngle - acos(dot(rayDir, up)); // Between -PI/2 and PI/2
-    
-    var azimuthAngle:f32; // Between 0 and 2*PI
-    
-    if (abs(altitudeAngle) > ( 0.5*PI - 0.0001 )) {
-        
-        // Looking nearly straight up or down.
-        azimuthAngle = 0.0;
-        
+fn sky_view_horizon_zenith_angle(
+    planet_radius: f32,
+    observer_radius: f32
+) -> f32 {
+    let r = max(observer_radius, planet_radius);
+    // Difference-of-squares + atan2 avoids losing ~19 mantissa bits in acos(R_p / R_v) near the ground.
+    let horizon_dist = sqrt(max((r - planet_radius) * (r + planet_radius), 0.0));
+    return 0.5 * PI + atan2(horizon_dist, max(planet_radius, MIN_ATMOSPHERE_LENGTH_UNITS));
+}
+
+fn sky_view_lut_uv_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    view_pos: vec3<f32>,
+    ray_dir: vec3<f32>,
+    sun_dir: vec3<f32>,
+    resolution: vec2<f32>
+) -> vec2<f32> {
+    let view_rel = atmosphere_clamped_observer_relative(atm, view_pos);
+    let observer_radius = length(view_rel);
+    let up = view_rel / observer_radius;
+
+    let theta_horizon = sky_view_horizon_zenith_angle(atm.planet_radius, observer_radius);
+    let theta = safe_acos(dot(ray_dir, up));
+
+    let bounds = atmosphere_ray_bounds_for(atm, view_rel, ray_dir);
+
+    let half_rows = max(floor(0.5 * resolution.y), 1.0);
+    var v: f32;
+    if (bounds.hits_ground) {
+        let unit_y = sqrt(saturate((theta - theta_horizon) / max(PI - theta_horizon, 1e-5)));
+        let row = (half_rows - 1.0) * (1.0 - unit_y);
+        v = (row + 0.5) / resolution.y;
+    } else {
+        let unit_y = sqrt(saturate((theta_horizon - theta) / max(theta_horizon, 1e-5)));
+        let row = half_rows + unit_y * (half_rows - 1.0);
+        v = (row + 0.5) / resolution.y;
+    }
+
+    let ray_horiz = ray_dir - up * dot(ray_dir, up);
+    let sun_horiz = sun_dir - up * dot(sun_dir, up);
+    let ray_horiz_len = length(ray_horiz);
+    let sun_horiz_len = length(sun_horiz);
+
+    var unit_x = 0.0;
+    if (ray_horiz_len > 1e-5 && sun_horiz_len > 1e-5) {
+        let cos_azimuth = clamp(dot(ray_horiz / ray_horiz_len, sun_horiz / sun_horiz_len), -1.0, 1.0);
+        unit_x = safe_acos(cos_azimuth) / PI;
+    }
+
+    let u = (unit_x * max(resolution.x - 1.0, 0.0) + 0.5) / max(resolution.x, 1.0);
+    return vec2<f32>(u, v);
+}
+
+struct SkyViewDecodedTexel {
+    ray_local: vec3<f32>,
+    hits_ground: bool,
+}
+
+fn sky_view_lut_decode_texel(
+    planet_radius: f32,
+    observer_radius: f32,
+    texel: vec2<f32>,
+    resolution: vec2<f32>
+) -> SkyViewDecodedTexel {
+    let theta_horizon = sky_view_horizon_zenith_angle(planet_radius, observer_radius);
+    let half_rows = max(floor(0.5 * resolution.y), 1.0);
+    let denom_y = max(half_rows - 1.0, 1.0);
+
+    var theta: f32;
+    var hits_ground: bool;
+    if (texel.y < half_rows) {
+        hits_ground = true;
+        let unit_y = saturate((half_rows - 1.0 - texel.y) / denom_y);
+        theta = clamp(theta_horizon + (PI - theta_horizon) * unit_y * unit_y, theta_horizon + 2e-6, PI);
     } else {
-    
-        let right = cross(sunDir, up);
-        let forward = cross(up, right);
-        
-        let projectedDir = normalize(rayDir - up*(dot(rayDir, up)));
-        
-        let sinTheta = dot(projectedDir, right);
-        let cosTheta = dot(projectedDir, forward);
-        
-        azimuthAngle = atan2(sinTheta, cosTheta) + PI;
-        
+        hits_ground = false;
+        let unit_y = saturate((texel.y - half_rows) / denom_y);
+        theta = clamp(theta_horizon * (1.0 - unit_y * unit_y), 0.0, max(theta_horizon - 2e-6, 0.0));
     }
-    
-    // Non-linear mapping of altitude angle. See Section 5.3 of the paper.
-    let v = 0.5 + 0.5*sign(altitudeAngle)*sqrt( abs(altitudeAngle)*2.0/PI );
-    
-    return vec2(azimuthAngle / (2.0*PI), v);
+
+    let unit_x = saturate(texel.x / max(resolution.x - 1.0, 1.0));
+    let azimuth = unit_x * PI;
+
+    let sin_theta = sin(theta);
+    let cos_theta = cos(theta);
+
+    var out: SkyViewDecodedTexel;
+    out.ray_local = vec3<f32>(sin_theta * cos(azimuth), cos_theta, sin_theta * sin(azimuth));
+    out.hits_ground = hits_ground;
+    return out;
+}
+
+fn sky_irradiance_lut_encode_uv(viewPos: vec3<f32>, rayDir: vec3<f32>, sunDir: vec3<f32>) -> vec2<f32> {
+    return sky_view_lut_uv_for(atmosphere_earth_parameters(), viewPos, rayDir, sunDir, vec2<f32>(192.0, 108.0));
 }
-`, [
+    `, [
         PI_DECLARATION,
-        PLANET_RADIUS_DECLARATION,
-        ATMOSPHERE_HEIGHT_DECLARATION,
         chunk_safe_acos,
-        chunk_position_relative_to_planet_center,
-        chunk_texture_sample_bilinear_uv,
-    ])
+        chunk_atmosphere_parameters,
+    ]
+);

package/src/shade/renderer/atmosphere/chunk_sky_lut_compute_uv.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Parameterised {@link sky_lut_uv_for} straight from a world-space position and
+ * {@link ATMOSPHERE_PARAMETERS_STRUCT}, for passes (such as volumetrics) that sample a sky LUT
+ * generated by {@link GPUSky} under their own texture binding name.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sky_lut_compute_uv_for: CodeChunk;
 /**
  * {@link chunk_sky_lut_uv} straight from a world-space position, for a shader that samples a
  * sky LUT through its own binding rather than through the `sample_*_lut_params` chunks --

package/src/shade/renderer/atmosphere/chunk_sky_lut_compute_uv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sky_lut_compute_uv.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sky_lut_compute_uv.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,uCAFU,SAAS,CAmBlB;0BAlCyB,iCAAiC"}
+{"version":3,"file":"chunk_sky_lut_compute_uv.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sky_lut_compute_uv.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,2CAFU,SAAS,CAmBjB;AAEF;;;;;;;;;;;;GAYG;AACH,uCAFU,SAAS,CAmBlB;0BAhEyB,iCAAiC"}

package/src/shade/renderer/atmosphere/chunk_sky_lut_compute_uv.js

@@ -1,35 +1,65 @@
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
-import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
-
-/**
- * {@link chunk_sky_lut_uv} straight from a world-space position, for a shader that samples a
- * sky LUT through its own binding rather than through the `sample_*_lut_params` chunks --
- * the volumetrics passes, which bind the same transmittance LUT under a name of their own.
- *
- * `resolution` is the LUT's, and it matters: the half-texel inset is what makes a lookup at
- * either end of the range read a value that was computed there. Pass
- * `vec2<f32>(textureDimensions(...))` of the texture being sampled, not of some other one --
- * the transmittance and multiple-scattering LUTs are different sizes, so one uv cannot serve
- * both.
- *
- * @type {CodeChunk}
- */
-export const chunk_sky_lut_compute_uv = CodeChunk.from(
-    //language=WGSL
-    `
-fn sky_lut_compute_uv(
-    pos: vec3<f32>,
-    sunDir: vec3<f32>,
-    resolution: vec2<f32>
-) -> vec2<f32> {
-
-    let params = sky_lut_params(pos, sunDir);
-
-    return sky_lut_uv(params.x, params.y, resolution);
-}
-    `, [
-        chunk_sky_lut_params,
-        chunk_sky_lut_uv,
-    ]
-)
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
+import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
+
+/**
+ * Parameterised {@link sky_lut_uv_for} straight from a world-space position and
+ * {@link ATMOSPHERE_PARAMETERS_STRUCT}, for passes (such as volumetrics) that sample a sky LUT
+ * generated by {@link GPUSky} under their own texture binding name.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sky_lut_compute_uv_for = CodeChunk.from(
+    //language=WGSL
+    `
+fn sky_lut_compute_uv_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    pos: vec3<f32>,
+    sunDir: vec3<f32>,
+    resolution: vec2<f32>
+) -> vec2<f32> {
+    let rel = atmosphere_position_relative_for(atm, pos);
+    let radius = length(rel);
+    let up = select(vec3<f32>(0.0, 1.0, 0.0), rel / radius, radius > 0.0);
+    return sky_lut_uv_for(atm, radius - atm.planet_radius, dot(sunDir, up), resolution);
+}
+    `, [
+        chunk_atmosphere_parameters,
+    ]
+);
+
+/**
+ * {@link chunk_sky_lut_uv} straight from a world-space position, for a shader that samples a
+ * sky LUT through its own binding rather than through the `sample_*_lut_params` chunks --
+ * the volumetrics passes, which bind the same transmittance LUT under a name of their own.
+ *
+ * `resolution` is the LUT's, and it matters: the half-texel inset is what makes a lookup at
+ * either end of the range read a value that was computed there. Pass
+ * `vec2<f32>(textureDimensions(...))` of the texture being sampled, not of some other one --
+ * the transmittance and multiple-scattering LUTs are different sizes, so one uv cannot serve
+ * both.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sky_lut_compute_uv = CodeChunk.from(
+    //language=WGSL
+    `
+fn sky_lut_compute_uv(
+    pos: vec3<f32>,
+    sunDir: vec3<f32>,
+    resolution: vec2<f32>
+) -> vec2<f32> {
+
+    let params = sky_lut_params(pos, sunDir);
+
+    return sky_lut_uv(params.x, params.y, resolution);
+}
+    `, [
+        chunk_sky_lut_params,
+        chunk_sky_lut_uv,
+    ]
+)

package/src/shade/renderer/atmosphere/compute_mie_absorption.d.ts

@@ -2,7 +2,8 @@
  * Compute Mie absorption from scattering and extinction coefficients.
  * @param {number[]} scattering
  * @param {number[]} extinction
+ * @param {number[]} [out]
  * @returns {number[]}
  */
-export function compute_mie_absorption(scattering: number[], extinction: number[]): number[];
+export function compute_mie_absorption(scattering: number[], extinction: number[], out?: number[]): number[];
 //# sourceMappingURL=compute_mie_absorption.d.ts.map

package/src/shade/renderer/atmosphere/compute_mie_absorption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_mie_absorption.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/compute_mie_absorption.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,mDAJW,MAAM,EAAE,cACR,MAAM,EAAE,GACN,MAAM,EAAE,CAQpB"}
+{"version":3,"file":"compute_mie_absorption.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/compute_mie_absorption.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mDALW,MAAM,EAAE,cACR,MAAM,EAAE,QACR,MAAM,EAAE,GACN,MAAM,EAAE,CAOpB"}

package/src/shade/renderer/atmosphere/compute_mie_absorption.js

@@ -2,12 +2,12 @@
  * Compute Mie absorption from scattering and extinction coefficients.
  * @param {number[]} scattering
  * @param {number[]} extinction
+ * @param {number[]} [out]
  * @returns {number[]}
  */
-export function compute_mie_absorption(scattering, extinction) {
-    return [
-        Math.max(extinction[0] - scattering[0], 0),
-        Math.max(extinction[1] - scattering[1], 0),
-        Math.max(extinction[2] - scattering[2], 0),
-    ];
+export function compute_mie_absorption(scattering, extinction, out = [0, 0, 0]) {
+    out[0] = Math.max(extinction[0] - scattering[0], 0);
+    out[1] = Math.max(extinction[1] - scattering[1], 0);
+    out[2] = Math.max(extinction[2] - scattering[2], 0);
+    return out;
 }

package/src/shade/renderer/atmosphere/resolve_atmosphere_sun.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Allocate a reusable {@link AtmosphereSunState} container so per-frame updates perform zero heap
+ * allocations.
+ *
+ * @returns {AtmosphereSunState}
+ */
+export function create_atmosphere_sun_state(): AtmosphereSunState;
+/**
+ * Resolve the active solar light driving {@link Scene#atmosphere}:
+ * 1. The first `DirectionalLight` in `scene.lights.elements`, using `-forward` as the direction
+ *    pointing **toward** the sun (`DirectionalLight` shines along `+Z` / `forward`).
+ * 2. Otherwise, when `atmosphere.fallback_sun_enabled` is true, the fallback sun configured on
+ *    {@link SceneAtmosphere} (with `sun_has_disc = 0` so sunless scenes get skylight IBL without
+ *    an unshadowed solar disc).
+ * 3. Otherwise, zero irradiance.
+ *
+ * @param {Scene} scene
+ * @param {AtmosphereSunState} [out]
+ * @returns {AtmosphereSunState}
+ */
+export function resolve_atmosphere_sun(scene: Scene, out?: AtmosphereSunState): AtmosphereSunState;
+export type Scene = import("../scene/Scene.js").Scene;
+export type AtmosphereSunState = {
+    /**
+     * world-space unit vector pointing **toward** the sun
+     */
+    sun_direction: Float32Array;
+    /**
+     * extraterrestrial RGB irradiance driving atmospheric scattering
+     */
+    sun_irradiance: Float32Array;
+    /**
+     * angular half-radius of the solar disc in radians
+     */
+    sun_disk_radius: number;
+    /**
+     * `1` when an explicit directional sun disc should be drawn, `0` otherwise
+     */
+    sun_has_disc: number;
+};
+//# sourceMappingURL=resolve_atmosphere_sun.d.ts.map

package/src/shade/renderer/atmosphere/resolve_atmosphere_sun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve_atmosphere_sun.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/resolve_atmosphere_sun.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,+CAFa,kBAAkB,CAS9B;AAED;;;;;;;;;;;;GAYG;AACH,8CAJW,KAAK,QACL,kBAAkB,GAChB,kBAAkB,CA6E9B;oBArHY,OAAO,mBAAmB,EAAE,KAAK;;;;;mBAKhC,YAAY;;;;oBACZ,YAAY;;;;qBACZ,MAAM;;;;kBACN,MAAM"}