@woosh/meep-engine 2.170.0 → 3.0.1

package/src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js

@@ -0,0 +1,57 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_max_v3 } from "../geometry/vec3/chunk_max_v3.js";
+import { chunk_compute_multiscattering_specular } from "../light/chunk_compute_multiscattering_specular.js";
+import { RECIPROCAL_PI_DECLARATION } from "../math/RECIPROCAL_PI_DECLARATION.js";
+
+export const chunk_compute_indirect_specular = CodeChunk.from(
+    //language=WGSL
+    `
+fn compute_indirect_specular(
+    radiance: vec3<f32>,
+    irradiance: vec3<f32>,
+    normal: vec3<f32>,
+    view_direction: vec3<f32>,
+    material_diffuse: vec3<f32>,
+    material_specularF0: vec3<f32>,
+    material_specularF90: f32,
+    material_roughness: f32
+) -> mat2x3<f32> {
+    // Both indirect specular and indirect diffuse light accumulate here
+	var single_scattering = vec3<f32>( 0.0 );
+	var multi_scattering = vec3<f32>( 0.0 );
+
+    let NoV = saturate( dot(normal, view_direction) );
+    
+    // split sum approximation
+	let f_ab = textureSampleLevel(tSplitSum, sLinear, vec2(NoV, material_roughness), 0.0 ).rg;
+	
+	compute_multiscattering_specular(
+        f_ab,
+        material_specularF0,
+        material_specularF90,
+        &single_scattering,
+        &multi_scattering 
+    );
+
+	let totalScattering = single_scattering + multi_scattering;
+	
+	var indirect_specular = radiance * totalScattering;
+	
+	// diffuse refelections will only be a portion of whatever remain after spec
+	let conservation_factor = saturate(vec3<f32>(1.0) - totalScattering);
+	
+	let cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
+	let diffuse = material_diffuse * conservation_factor;
+	let indirect_diffuse = diffuse * cosineWeightedIrradiance;
+	
+	return mat2x3(
+	    indirect_specular,
+	    indirect_diffuse
+	);
+}
+    `, [
+        chunk_compute_multiscattering_specular,
+        RECIPROCAL_PI_DECLARATION,
+        chunk_max_v3,
+    ]
+)

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_metalness.d.ts

@@ -0,0 +1,3 @@
+export const chunk_decode_g_buffer_metalness: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decode_g_buffer_metalness.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_metalness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decode_g_buffer_metalness.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_metalness.js"],"names":[],"mappings":"AAEA,wDAOC;0BATyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_metalness.js

@@ -0,0 +1,10 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+export const chunk_decode_g_buffer_metalness = CodeChunk.from(
+    //language=WGSL
+    `
+fn decode_g_buffer_metalness(pbr_texel: vec4f) -> f32{
+    return pbr_texel.x;
+}
+    `
+)

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_roughness.d.ts

@@ -0,0 +1,3 @@
+export const chunk_decode_g_buffer_roughness: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decode_g_buffer_roughness.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_roughness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decode_g_buffer_roughness.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_roughness.js"],"names":[],"mappings":"AAEA,wDAOE;0BATwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_roughness.js

@@ -0,0 +1,10 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+export const chunk_decode_g_buffer_roughness = CodeChunk.from(
+    //language=WGSL
+    `
+fn decode_g_buffer_roughness(pbr_texel: vec4f) -> f32{
+    return pbr_texel.y;   
+}
+    `
+);

package/src/shade/renderer/shader/chunk/material/chunk_dielectric_specular_color.d.ts

@@ -0,0 +1,18 @@
+/**
+ * IOR-aware F0 derivation used by the MaterialX/OpenPBR substrate model.
+ *
+ * For dielectrics the Fresnel reflectance at normal incidence is
+ *   F0 = ((ior - 1) / (ior + 1))^2
+ * assuming an air interface (n_outside = 1.0).
+ *
+ * For metals (metalness = 1) we ignore IOR and use the albedo as the
+ * tinted reflectance, matching the standard metallic workflow.
+ *
+ * At ior = 1.5 this evaluates to F0 = 0.04 — bit-identical to the legacy
+ * hardcoded dielectric F0 used everywhere prior to this change.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dielectric_specular_color: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_dielectric_specular_color.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_dielectric_specular_color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_dielectric_specular_color.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_dielectric_specular_color.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,8CAFU,SAAS,CAWjB;0BA1BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_dielectric_specular_color.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * IOR-aware F0 derivation used by the MaterialX/OpenPBR substrate model.
+ *
+ * For dielectrics the Fresnel reflectance at normal incidence is
+ *   F0 = ((ior - 1) / (ior + 1))^2
+ * assuming an air interface (n_outside = 1.0).
+ *
+ * For metals (metalness = 1) we ignore IOR and use the albedo as the
+ * tinted reflectance, matching the standard metallic workflow.
+ *
+ * At ior = 1.5 this evaluates to F0 = 0.04 — bit-identical to the legacy
+ * hardcoded dielectric F0 used everywhere prior to this change.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dielectric_specular_color = CodeChunk.from(
+    //language=WGSL
+    `
+fn dielectric_specular_color(ior: f32, metalness: f32, base_color: vec3<f32>) -> vec3<f32> {
+    let f0_d = (ior - 1.0) / (ior + 1.0);
+    let f0_dielectric = vec3<f32>(f0_d * f0_d);
+    return mix(f0_dielectric, base_color, metalness);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/material/chunk_get_bent_noh_squared.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GGX spherical area light approximation
+ * @see https://www.shadertoy.com/view/MXyXDy
+ * @see https://advances.realtimerendering.com/s2017/DecimaSiggraph2017.pdf
+ * @type {CodeChunk}
+ */
+export const chunk_get_bent_noh_squared: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_get_bent_noh_squared.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_get_bent_noh_squared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_get_bent_noh_squared.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_get_bent_noh_squared.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAFU,SAAS,CA4ElB;0BAlFyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_get_bent_noh_squared.js

@@ -0,0 +1,83 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * GGX spherical area light approximation
+ * @see https://www.shadertoy.com/view/MXyXDy
+ * @see https://advances.realtimerendering.com/s2017/DecimaSiggraph2017.pdf
+ * @type {CodeChunk}
+ */
+export const chunk_get_bent_noh_squared = CodeChunk.from(
+    //language=WGSL
+    `
+fn get_bent_noh_squared(
+    NoL: f32,
+    NoV: f32,
+    VoL: f32,
+    radius_tan: f32 
+) -> f32{
+
+    let radius_cos = inverseSqrt(1.0 + radius_tan * radius_tan);
+    
+    let RoL = 2.0 * NoL * NoV - VoL;
+    if (RoL >= radius_cos){
+        return 1.0;
+    }
+    if (RoL <= -radius_cos) {
+        // Symmetric negative-end early-exit. The reflection ray points away
+        // from the source, so no perimeter point yields a valid representative
+        // direction (the orthonormal T = (R - (R.L)L)/|...| is undefined
+        // here). Without this exit, NoTr can exceed 1 below — geometrically
+        // invalid — and the final saturate snaps to a false peak (1.0),
+        // surfacing as single-pixel fireflies on foliage silhouettes pointed
+        // near the sun. Fall back to the un-bent (N.H)^2.
+        let NoH_pt = NoL + NoV;
+        return saturate(NoH_pt * NoH_pt / max(2.0 + 2.0 * VoL, 1e-6));
+    }
+
+    // Belt-and-suspenders guard against FP noise near the negative early-exit
+    // boundary; the symmetric exit above is the primary defense.
+    let rOverLengthT = radius_cos * radius_tan / sqrt(max(1.0 - RoL * RoL, 1e-6));
+    
+    var NoTr = rOverLengthT * (NoV - RoL * NoL);
+    var VoTr = rOverLengthT * (2.0 * NoV * NoV - 1.0 - RoL * VoL);
+
+    // One Newton iteration on the rep-point angle (Decima 2017): seed with
+    // Karis's closest-point answer (above) and refine to maximize (N·H)².
+    // Bigger lift on glossy surfaces at grazing angles.
+    let triple = sqrt(saturate(1.0 - NoL * NoL - NoV * NoV - VoL * VoL + 2.0 * NoL * NoV * VoL));
+
+    let NoBr = rOverLengthT * triple;
+    let VoBr = rOverLengthT * (2.0 * triple * NoV);
+
+    let NoLVTr = NoL * radius_cos + NoV + NoTr;
+    let VoLVTr = VoL * radius_cos + 1.0 + VoTr;
+
+    let p = NoBr * VoLVTr;
+    let q = NoLVTr * VoLVTr;
+    let s = VoBr * NoLVTr;
+
+    let xNum = q * ( 0.25 * s - 0.5 * p );
+    let xDenom = p * p + s * (s - 2.0 * p) + NoLVTr * ((NoL * radius_cos + NoV) * VoLVTr * VoLVTr -
+       q * (0.5 * (VoLVTr + VoL * radius_cos) + 0.5));
+
+    // + 1e-8 guards the 0/0 case when N, L, V are coplanar (triple == 0
+    // ⇒ NoBr = VoBr = 0 ⇒ xNum = 0) and xDenom also vanishes.
+    let twoX1 = 2.0 * xNum / (xDenom * xDenom + xNum * xNum + 1e-8);
+    let sinTheta = twoX1 * xDenom;
+    let cosTheta = 1.0 - twoX1 * xNum;
+
+    NoTr = cosTheta * NoTr + sinTheta * NoBr;
+    VoTr = cosTheta * VoTr + sinTheta * VoBr;
+
+     // Calculate (N.H) ^ 2 based on the bent light vector
+    let newNoL = NoL * radius_cos + NoTr;
+    let newVoL = VoL * radius_cos + VoTr;
+    
+    let NoH = NoV + newNoL;
+    let HoH = 2.0 * newVoL + 2.0;
+    
+    return saturate(NoH * NoH / max(HoH, 1e-6));
+    
+}
+    `
+)

package/src/shade/renderer/shader/chunk/material/chunk_metalness_to_specular_color.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ref: https://github.com/KhronosGroup/glTF/blob/6014140040039d0bc25547fa1255569a1e31c6d1/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/examples/convert-between-workflows/js/three.pbrUtilities.js#L33
+ * @type {CodeChunk}
+ */
+export const chunk_metalness_to_specular_color: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_metalness_to_specular_color.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_metalness_to_specular_color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_metalness_to_specular_color.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_metalness_to_specular_color.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,gDAFU,SAAS,CAYZ;0BAjBmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_metalness_to_specular_color.js

@@ -0,0 +1,18 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../brdf/chunk_MIN_DIELECTRICS_F0.js";
+
+/**
+ * Ref: https://github.com/KhronosGroup/glTF/blob/6014140040039d0bc25547fa1255569a1e31c6d1/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/examples/convert-between-workflows/js/three.pbrUtilities.js#L33
+ * @type {CodeChunk}
+ */
+export const chunk_metalness_to_specular_color = CodeChunk.from(
+    //language=WGSL
+    `
+fn metalness_to_specular_color(metalness:f32, base_color: vec3<f32>) -> vec3<f32>{
+    const dielectric_specular_color = vec3(MIN_DIELECTRICS_F0);
+    
+    return mix(dielectric_specular_color, base_color, metalness);
+}
+`, [
+        chunk_MIN_DIELECTRICS_F0
+    ]);

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_physical.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Direct physically-based lighting calculation
+ * @type {CodeChunk}
+ */
+export const chunk_re_direct_physical: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_re_direct_physical.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_physical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_re_direct_physical.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_re_direct_physical.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,uCAFU,SAAS,CAwFlB;0BApGyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_physical.js

@@ -0,0 +1,101 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_BRDF_GGX } from "../brdf/chunk_BRDF_GGX.js";
+import { chunk_oren_nayar_compensated_diffuse } from "../brdf/diffuse/EON.js";
+import { INCIDENT_LIGHT_STRUCT } from "../light/INCIDENT_LIGHT_STRUCT.js";
+import { REFLECTED_LIGHT_STRUCT } from "../light/REFLECTED_LIGHT_STRUCT.js";
+import { RECIPROCAL_PI_DECLARATION } from "../math/RECIPROCAL_PI_DECLARATION.js";
+import { chunk_get_bent_noh_squared } from "./chunk_get_bent_noh_squared.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "./GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "./MATERIAL_SHADING_INFO_STRUCT.js";
+
+/**
+ * Direct physically-based lighting calculation
+ * @type {CodeChunk}
+ */
+export const chunk_re_direct_physical = CodeChunk.from(
+// language=WGSL
+    `
+fn re_direct_physical( 
+    light: ${INCIDENT_LIGHT_STRUCT.wgsl_ref},
+    geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
+    material: ${MATERIAL_SHADING_INFO_STRUCT.wgsl_ref},
+    reflectedLight: ptr<function, ${REFLECTED_LIGHT_STRUCT.wgsl_ref}>
+) {
+    // TODO extract dot products to a separate container to save on ALU
+
+    // N, L, V are assumed to be normalized
+    let N = geometry.shading_normal;
+    let L = light.direction;
+    let V = geometry.view_direction;
+
+	let H = normalize( L + V );
+
+	let NdotL = dot( N, L );
+	let NoL = saturate( NdotL );
+	let NoV = saturate( dot( N, V ) );
+	let VoH = saturate( dot( V, H ) );
+	// V·L spans [-1, 1] and must not be clamped: get_bent_noh_squared's identities
+	// (RoL = 2·NoL·NoV − VoL and the Gram determinant) rely on the signed value, and
+	// mirror configurations at incidence > 45° have VoL < 0
+	let VoL = dot( V, L );
+
+	let alpha = material.roughness * material.roughness;
+
+	// Representative-point sphere-light specular (Karis 2013 + Decima 2017):
+	// bend L to the sphere perimeter point that maximizes (N·H)², widen
+	// roughness by the source's solid angle, renormalize for energy.
+	// "light.radius" already carries sin(θ_source); clamp avoids the
+	// degenerate tan = ∞ at sin = 1 (shading point exactly at source surface).
+	let sin_src = clamp(light.radius, 0.0, 0.999);
+	let cos_src = sqrt(1.0 - sin_src * sin_src);
+	let radius_tan = sin_src / cos_src;
+	let bent_NoH_squared = get_bent_noh_squared(NoL, NoV, VoL, radius_tan);
+
+	let alpha_prime = saturate(alpha + sin_src / 3.0);
+	let energy_factor = (alpha / alpha_prime) * (alpha / alpha_prime);
+
+	// Soft-horizon wrap: light center can sit just below horizon while parts
+	// of the source disk still illuminate the surface. Reduces to plain
+	// saturate(NdotL) as sin_src → 0, becomes 0 once even the disk's top edge
+	// is below horizon (NdotL ≤ −sin_src). The bent-NoH math above keeps the
+	// un-wrapped saturated cosines (it needs the true reflection geometry),
+	// but the BRDF NoL term tracks the wrap to keep Oren-Nayar and V_GGX
+	// bounded at silhouettes where NoL = NoV = 0 would otherwise hit the
+	// stinv = s/max(eps, max(NoL,NoV)) singularity in the diffuse lobe.
+	let NoL_wrap = saturate((NdotL + sin_src) / (1.0 + sin_src));
+	let irradiance = NoL_wrap * light.color;
+
+	let ggx = BRDF_GGX(
+	    NoL_wrap,
+	    NoV,
+	    bent_NoH_squared,
+	    VoH,
+	    material.specularF0,
+	    material.specularF90,
+	    alpha_prime,
+	);
+
+    (*reflectedLight).specular += irradiance * ggx * energy_factor;
+
+    let diffuse_color = oren_nayar_compensated_diffuse(
+        NoV,
+        NoL_wrap,
+        VoL,
+        material.roughness,
+        material.diffuse,
+    );
+    
+	(*reflectedLight).diffuse += irradiance * diffuse_color * RECIPROCAL_PI;
+	
+}
+    `, [
+        INCIDENT_LIGHT_STRUCT.declaration_chunk,
+        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
+        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
+        REFLECTED_LIGHT_STRUCT.declaration_chunk,
+        RECIPROCAL_PI_DECLARATION,
+        chunk_BRDF_GGX,
+        chunk_get_bent_noh_squared,
+        chunk_oren_nayar_compensated_diffuse
+    ]
+)

package/src/shade/renderer/shader/chunk/material/chunk_re_indirect_specular_physical.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @see https://github.com/mrdoob/three.js/blob/089e36db16a6fbaf8cd12fbc8b6abfa3beaa4801/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L512
+ * @type {CodeChunk}
+ */
+export const chunk_re_indirect_specular_physical: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_re_indirect_specular_physical.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_re_indirect_specular_physical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_re_indirect_specular_physical.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_re_indirect_specular_physical.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,kDAFU,SAAS,CAiCZ;0BAzCmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_re_indirect_specular_physical.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { REFLECTED_LIGHT_STRUCT } from "../light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_compute_indirect_specular } from "./chunk_compute_indirect_specular.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "./GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "./MATERIAL_SHADING_INFO_STRUCT.js";
+
+/**
+ * @see https://github.com/mrdoob/three.js/blob/089e36db16a6fbaf8cd12fbc8b6abfa3beaa4801/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L512
+ * @type {CodeChunk}
+ */
+export const chunk_re_indirect_specular_physical = CodeChunk.from(
+// language=WGSL
+    `
+fn re_indirect_specular_physical(
+    radiance: vec3<f32>,
+    irradiance: vec3<f32>,
+    geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
+    material: ${MATERIAL_SHADING_INFO_STRUCT.wgsl_ref},
+    reflectedLight: ptr<function, ${REFLECTED_LIGHT_STRUCT.wgsl_ref} >
+) {
+
+    let indirect = compute_indirect_specular(
+        radiance,
+        irradiance,
+        geometry.shading_normal,
+        geometry.view_direction,
+        material.diffuse,
+        material.specularF0,
+        material.specularF90,
+        material.roughness
+    );
+
+	(*reflectedLight).specular += indirect[0];
+	(*reflectedLight).diffuse += indirect[1];
+	
+}
+`, [
+        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
+        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
+        REFLECTED_LIGHT_STRUCT.declaration_chunk,
+        chunk_compute_indirect_specular,
+    ]);

package/src/shade/renderer/shader/chunk/math/EPSILON_DECLARATION.d.ts

@@ -0,0 +1,3 @@
+export const EPSILON_DECLARATION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=EPSILON_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/math/EPSILON_DECLARATION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EPSILON_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/EPSILON_DECLARATION.js"],"names":[],"mappings":"AAEA,4CAGC;0BALyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/EPSILON_DECLARATION.js

@@ -0,0 +1,6 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+export const EPSILON_DECLARATION = CodeChunk.from(
+//language=WGSL
+    "const EPSILON  :f32 = 1e-6;"
+)

package/src/shade/renderer/shader/chunk/math/F16_MAX_DEFINITION.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Note that Uint16 has the max value of 65535, which is very close.
+ * That's just a coincidence.
+ * see https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+ * @type {CodeChunk}
+ */
+export const F16_MAX_DEFINITION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=F16_MAX_DEFINITION.d.ts.map

package/src/shade/renderer/shader/chunk/math/F16_MAX_DEFINITION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"F16_MAX_DEFINITION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/F16_MAX_DEFINITION.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iCAFU,SAAS,CAKjB;0BAXwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/F16_MAX_DEFINITION.js

@@ -0,0 +1,12 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Note that Uint16 has the max value of 65535, which is very close.
+ * That's just a coincidence.
+ * see https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+ * @type {CodeChunk}
+ */
+export const F16_MAX_DEFINITION = CodeChunk.from(
+    //language=WGSL
+    "const F16_MAX = 65504.0;"
+);

package/src/shade/renderer/shader/chunk/math/F32_MAX_DEFINITION.d.ts

@@ -0,0 +1,7 @@
+/**
+ * see https://github.com/gpuweb/gpuweb/issues/3431#issuecomment-1252519246
+ * @type {CodeChunk}
+ */
+export const F32_MAX_DEFINITION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=F32_MAX_DEFINITION.d.ts.map

package/src/shade/renderer/shader/chunk/math/F32_MAX_DEFINITION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"F32_MAX_DEFINITION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/F32_MAX_DEFINITION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iCAFU,SAAS,CAKjB;0BATwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/F32_MAX_DEFINITION.js

@@ -0,0 +1,12 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * see https://github.com/gpuweb/gpuweb/issues/3431#issuecomment-1252519246
+ * @type {CodeChunk}
+ */
+export const F32_MAX_DEFINITION = CodeChunk.from(
+    //language=WGSL
+    "const F32_MAX = 3.402823466e+38;"
+);
+
+

package/src/shade/renderer/shader/chunk/math/F32_MIN_DEFINITION.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @type {CodeChunk}
+ */
+export const F32_MIN_DEFINITION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=F32_MIN_DEFINITION.d.ts.map

package/src/shade/renderer/shader/chunk/math/F32_MIN_DEFINITION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"F32_MIN_DEFINITION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/F32_MIN_DEFINITION.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,iCAFU,SAAS,CAKjB;0BARwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/F32_MIN_DEFINITION.js

@@ -0,0 +1,9 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * @type {CodeChunk}
+ */
+export const F32_MIN_DEFINITION = CodeChunk.from(
+    //language=WGSL
+    "const F32_MIN = -3.4028234e+38;"
+);

package/src/shade/renderer/shader/chunk/math/GOLDEN_ANGLE_DECLARATION.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The golden angle, π(3 − √5) ≈ 2.39996 rad (≈ 137.5°). The ideal
+ * increment between successive points on a Vogel / Fibonacci spiral:
+ * consecutive samples are maximally spread with no rational period, so a
+ * finite set tiles a disk or sphere near-uniformly.
+ */
+export const GOLDEN_ANGLE_DECLARATION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=GOLDEN_ANGLE_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/math/GOLDEN_ANGLE_DECLARATION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GOLDEN_ANGLE_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/GOLDEN_ANGLE_DECLARATION.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iDAGE;0BAXwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/GOLDEN_ANGLE_DECLARATION.js

@@ -0,0 +1,12 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * The golden angle, π(3 − √5) ≈ 2.39996 rad (≈ 137.5°). The ideal
+ * increment between successive points on a Vogel / Fibonacci spiral:
+ * consecutive samples are maximally spread with no rational period, so a
+ * finite set tiles a disk or sphere near-uniformly.
+ */
+export const GOLDEN_ANGLE_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    "const GOLDEN_ANGLE : f32 = 2.39996322972865332;"
+);

package/src/shade/renderer/shader/chunk/math/INFINITY_DECLARATION.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Note: log(+/-0) always produces -inf. Reverse polarity here
+ * @type {CodeChunk}
+ */
+export const INFINITY_DECLARATION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=INFINITY_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/math/INFINITY_DECLARATION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"INFINITY_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/INFINITY_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,mCAFU,SAAS,CAOlB;0BAXyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/INFINITY_DECLARATION.js

@@ -0,0 +1,12 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Note: log(+/-0) always produces -inf. Reverse polarity here
+ * @type {CodeChunk}
+ */
+export const INFINITY_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    `
+const INFINITY : f32 = -log(0.0);
+    `
+)

package/src/shade/renderer/shader/chunk/math/PI_DECLARATION.d.ts

@@ -0,0 +1,6 @@
+/**
+ * pi
+ */
+export const PI_DECLARATION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=PI_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/math/PI_DECLARATION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PI_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/PI_DECLARATION.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,uCAGE;0BARwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/PI_DECLARATION.js

@@ -0,0 +1,10 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * pi
+ */
+export const PI_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    "const PI : f32 = 3.1415926535897932384626433832795;"
+);
+

package/src/shade/renderer/shader/chunk/math/PI_HALF_DECLARATION.d.ts

@@ -0,0 +1,6 @@
+/**
+ * pi / 2
+ */
+export const PI_HALF_DECLARATION: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=PI_HALF_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/math/PI_HALF_DECLARATION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PI_HALF_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/PI_HALF_DECLARATION.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,4CAGE;0BARwB,6BAA6B"}