@3driseai/3drise-viewer 0.1.7 → 0.1.8

package/dist/shaders/clouds/CloudVolumeMaterial.js

@@ -0,0 +1,249 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+import { cloudFull } from '../glsl/cloudCore.glsl.js';
+/**
+ * The volumetric march. Used by Cumulus, Stratocumulus and Cumulonimbus — they are one
+ * density model with different vertical profiles, not three shaders.
+ *
+ * Two hosts, selected by u_host:
+ *   0  object — analytic sphere intersection, rendered on a back-faced container mesh
+ *   1  layer  — analytic curved-slab intersection, rendered by <CloudSky> at half res
+ *
+ * Writes premultiplied scattering in rgb and transmittance in a, so the consumer does
+ * `dst = dst * a + rgb`. In object mode that is ordinary alpha blending with
+ * blendSrc ONE / blendDst SRC_ALPHA; the layer path composites explicitly.
+ */
+const vertex = /* glsl */ `
+out vec2 vUv;
+out vec3 vWorld;
+void main(){
+  vUv = uv;
+  vec4 wp = modelMatrix * vec4(position, 1.0);
+  vWorld = wp.xyz;
+  gl_Position = projectionMatrix * viewMatrix * wp;
+}
+`;
+const fragment = /* glsl */ `
+${cloudFull}
+
+in vec2 vUv;
+in vec3 vWorld;
+out vec4 outColor;
+
+uniform sampler2D u_depth;
+uniform float u_hasDepth;
+uniform vec3  u_camPos, u_camFwd;
+uniform mat4  u_invProj, u_camWorld;
+uniform float u_near, u_far, u_frame;
+uniform vec2  u_resolution;
+uniform int   u_steps;
+uniform float u_stepGrowth, u_maxSpan, u_fogDensity, u_detailFade;
+uniform float u_screenSpace;
+
+#define MAX_STEPS 256
+
+/** Interleaved gradient noise. Cheap, and it decorrelates well under a golden-ratio
+ *  per-frame offset, which is what lets the temporal pass turn it into detail. */
+float ign(vec2 p){
+  return fract(52.9829189 * fract(0.06711056 * p.x + 0.00583715 * p.y));
+}
+
+void main(){
+  vec2 uv = (u_screenSpace > 0.5) ? vUv : (gl_FragCoord.xy / u_resolution);
+  vec2 ndc = uv * 2.0 - 1.0;
+
+  vec4 vp = u_invProj * vec4(ndc, -1.0, 1.0);
+  vp /= vp.w;
+  vec3 rd = normalize(mat3(u_camWorld) * vp.xyz);
+  vec3 ro = u_camPos;
+
+  // Scene depth caps the march, so geometry can sit inside or behind the cloud rather
+  // than always in front of or behind it.
+  float maxT = 1e7;
+  if (u_hasDepth > 0.5){
+    float dz = texture(u_depth, uv).x;
+    if (dz < 0.999999){
+      float viewZ = (u_near * u_far) / ((u_far - u_near) * dz - u_far);
+      maxT = -viewZ / max(dot(rd, u_camFwd), 1e-4);
+    }
+  }
+
+  vec3  scattering = vec3(0.0);
+  float transmittance = 1.0;
+  float cloudDist = 0.0, distW = 0.0;
+
+  float t0, t1;
+  bool hit = (u_host < 0.5)
+    ? sphereRange(ro, rd, u_center, u_radius, t0, t1)
+    : layerRange(ro, rd, u_layerBottom, u_layerTop, t0, t1);
+
+  if (hit){
+    t1 = min(min(t1, maxT), t0 + u_maxSpan);
+    if (t1 > t0){
+      float mu = dot(rd, u_sunDir);
+      float span = t1 - t0;
+      float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);
+
+      // The fine step is tied to CLOUD DEPTH, not to the span. A ray grazing a 2 km deck
+      // spans 100 km; dividing that by the step budget gives kilometre steps and every
+      // feature dissolves into fog. Empty space is skipped 2.8x coarser, and the step
+      // grows with distance to hold screen-space error roughly constant.
+      float dt0 = min(thick * 2.0 / float(u_steps), span / 8.0);
+      dt0 = max(dt0, thick * 0.004);
+      float big = dt0 * 2.8;
+
+      float jitter = fract(ign(gl_FragCoord.xy) + u_frame * 0.6180339887);
+      float t = t0 + dt0 * jitter;
+
+      bool inside = false;
+      int empty = 0;
+
+      for (int i = 0; i < MAX_STEPS; i++){
+        if (t >= t1 || transmittance < 0.015) break;
+
+        // Step size proportional to distance, which is what "constant screen-space
+        // error" actually means: a cloud 80 km out subtends a fraction of the pixels
+        // one 2 km out does. Without this a near-horizontal ray, which can span a
+        // hundred kilometres inside the deck, exhausts MAX_STEPS long before it
+        // exits and the deck simply stops along a straight line.
+        float dt = max(dt0, t * u_stepGrowth);
+        float grow = dt / dt0;
+        vec3 p = ro + rd * t;
+        float h = heightAt(p, t);
+
+        if (!inside){
+          if (cloudDensityCheap(p, h) > 0.0){
+            inside = true; empty = 0;
+            t = max(t - big * grow, t0);   // step back once, then refine
+            continue;
+          }
+          t += big * grow;
+          continue;
+        }
+
+        float d = cloudDensity(p, h, saturate(1.0 - t * u_detailFade));
+        if (d <= 0.0){
+          empty++;
+          if (empty > 8){ inside = false; empty = 0; }
+          t += dt;
+          continue;
+        }
+        empty = 0;
+
+        float sigmaE = d * u_sigmaT;
+        float lightD = lightMarch(p, t);
+
+        vec3 amb = (u_skyAmbient * pow(saturate(h), 0.7)
+                  + u_groundAmbient * pow(saturate(1.0 - h), 0.9) * 0.5)
+                  * u_ambient * exp(-lightD * u_sigmaT * 0.08);
+
+        // Powder / dark-edge. Only when looking away from the sun, or it double-darkens
+        // backlit rims that should be the brightest thing in frame.
+        float pw = 1.0 - exp(-lightD * u_sigmaT * 2.4);
+        pw = mix(1.0, pw, saturate(-mu * 0.5 + 0.5) * u_powder);
+
+        vec3 S = (u_sunColor * (u_sunIntensity * SUN_RADIANCE)
+                  * scatterEnergy(lightD, mu) * pw * cloudAlbedo(h)
+                  + amb) * sigmaE;
+
+        // Hillaire's energy-conserving integration, not S * dt * T.
+        float trs = exp(-sigmaE * dt);
+        scattering += transmittance * ((S - S * trs) / max(sigmaE, 1e-6));
+
+        float wgt = transmittance * (1.0 - trs);
+        cloudDist += t * wgt; distW += wgt;
+        transmittance *= trs;
+        t += dt;
+      }
+
+      // Aerial perspective. Deliberately does NOT blend toward skyRadiance(): the
+      // visible background is whatever SkyController / Skybox drew, and fading a
+      // distant deck toward a DIFFERENT, analytic sky paints a glowing band along
+      // the horizon that exists in no other part of the scene.
+      //
+      // Physically the air between camera and cloud both attenuates the cloud and
+      // adds its own in-scattered light — and that in-scattered light is, to a good
+      // approximation, exactly the background you would see looking that way with no
+      // cloud there. So attenuate the cloud and open the transmittance; the composite
+      // then lets the real background through and the two terms come out right,
+      // whatever sky is behind.
+      if (distW > 0.0){
+        float dist = cloudDist / distW;
+        float fogT = exp(-dist * u_fogDensity);
+        scattering *= fogT;
+        transmittance = mix(1.0, transmittance, fogT);
+      }
+    }
+  }
+
+  outColor = vec4(scattering, transmittance);
+}
+`;
+export const cloudVolumeDefaults = {
+    u_base: null,
+    u_detail: null,
+    u_weather: null,
+    u_curl: null,
+    u_depth: null,
+    u_hasDepth: 0,
+    u_time: 0,
+    u_frame: 0,
+    u_sunDir: new THREE.Vector3(0.3, 0.4, 0.86).normalize(),
+    u_sunColor: new THREE.Color(1, 1, 1),
+    u_sunIntensity: 1,
+    u_turbidity: 1,
+    u_rayleigh: 1,
+    u_mieCoefficient: 0.005,
+    u_mieG: 0.76,
+    u_skyAmbient: new THREE.Color(0.32, 0.5, 0.86),
+    u_groundAmbient: new THREE.Color(0.24, 0.22, 0.19),
+    u_coverage: 0.52,
+    u_density: 2.6,
+    u_cloudType: 0.52,
+    u_baseScale: 1 / 2600,
+    u_detailScale: 1 / 400,
+    u_detailStrength: 0.5,
+    u_curlStrength: 0.55,
+    u_layerBottom: 1500,
+    u_layerTop: 3400,
+    u_shear: 0.08,
+    u_anvil: 0,
+    u_precip: 0,
+    u_weatherScale: 1 / 24000,
+    u_evolution: 0.45,
+    u_windDir: new THREE.Vector2(1, 0.22).normalize(),
+    u_windSpeed: 6,
+    u_rise: 1.4,
+    u_churn: 4.5,
+    u_sigmaT: 0.013,
+    u_g1: 0.8,
+    u_g2: 0.32,
+    u_msExtinction: 0.55,
+    u_msEnergy: 0.58,
+    u_msPhase: 0.6,
+    u_powder: 0.85,
+    u_silver: 0.9,
+    u_ambient: 1,
+    u_steps: 96,
+    u_lightSteps: 6,
+    u_lightStep: 0.024,
+    u_stepGrowth: 0.0045,
+    u_maxSpan: 120000,
+    u_detailFade: 1 / 16000,
+    u_host: 0,
+    u_center: new THREE.Vector3(0, 620, 0),
+    u_radius: 520,
+    u_curvature: 1 / (2 * 6371000),
+    u_fogDensity: 0.000026,
+    u_camPos: new THREE.Vector3(),
+    u_camFwd: new THREE.Vector3(0, 0, -1),
+    u_invProj: new THREE.Matrix4(),
+    u_camWorld: new THREE.Matrix4(),
+    u_near: 1,
+    u_far: 100000,
+    u_resolution: new THREE.Vector2(1, 1),
+    u_screenSpace: 0
+};
+export const CloudVolumeMaterial = shaderMaterial(cloudVolumeDefaults, vertex, fragment);
+extend({ CloudVolumeMaterial });

package/dist/shaders/clouds/SkyBackgroundMaterial.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import { type ThreeElement } from '@react-three/fiber';
+export declare const SkyBackgroundMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_sunDir: THREE.Vector3;
+    u_sunColor: THREE.Color;
+    u_sunIntensity: number;
+    u_turbidity: number;
+    u_rayleigh: number;
+    u_mieCoefficient: number;
+    u_mieG: number;
+    u_invProj: THREE.Matrix4;
+    u_camWorld: THREE.Matrix4;
+}> & {
+    key: string;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        skyBackgroundMaterial: ThreeElement<typeof SkyBackgroundMaterial>;
+    }
+}
+//# sourceMappingURL=SkyBackgroundMaterial.d.ts.map

package/dist/shaders/clouds/SkyBackgroundMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyBackgroundMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/SkyBackgroundMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAgC9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CAcjC,CAAA;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,qBAAqB,EAAE,YAAY,CAAC,OAAO,qBAAqB,CAAC,CAAA;KAClE;CACF"}

package/dist/shaders/clouds/SkyBackgroundMaterial.js

@@ -0,0 +1,42 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+import { cloudCommon, skyLib } from '../glsl/cloudCore.glsl.js';
+/**
+ * The analytic sky the clouds are lit against. Sharing one sky function between the
+ * background, the clouds' ambient term and their aerial perspective is what keeps a
+ * cloud looking like it belongs in the sky behind it rather than pasted onto it.
+ *
+ * Drawn as a fullscreen quad with depth writes off, so the depth buffer stays clear and
+ * the cloud march still sees "no geometry here".
+ */
+const vertex = /* glsl */ `
+out vec2 vUv;
+void main(){ vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }
+`;
+const fragment = /* glsl */ `
+${cloudCommon}
+precision highp float;
+${skyLib}
+in vec2 vUv;
+out vec4 outColor;
+uniform mat4 u_invProj, u_camWorld;
+void main(){
+  vec2 ndc = vUv * 2.0 - 1.0;
+  vec4 vp = u_invProj * vec4(ndc, -1.0, 1.0); vp /= vp.w;
+  vec3 rd = normalize(mat3(u_camWorld) * vp.xyz);
+  outColor = vec4(skyRadiance(rd) + sunDisc(rd), 1.0);
+}
+`;
+export const SkyBackgroundMaterial = shaderMaterial({
+    u_sunDir: new THREE.Vector3(0.3, 0.4, 0.86).normalize(),
+    u_sunColor: new THREE.Color(1, 1, 1),
+    u_sunIntensity: 1,
+    u_turbidity: 1,
+    u_rayleigh: 1,
+    u_mieCoefficient: 0.005,
+    u_mieG: 0.76,
+    u_invProj: new THREE.Matrix4(),
+    u_camWorld: new THREE.Matrix4()
+}, vertex, fragment);
+extend({ SkyBackgroundMaterial });

package/dist/shaders/glsl/cloudCore.glsl.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared cloud core. Imported by CloudVolumeMaterial and by any surface material that
+ * wants cloud shadows. Nothing here is per-type: the four cloud models differ by the
+ * height-gradient blend (u_cloudType), the shear/anvil/precipitation terms, and their
+ * configs — not by separate shader code.
+ *
+ * Fragment shaders including this MUST be compiled with glslVersion: THREE.GLSL3.
+ * GLSL ES 3.00 declares no default precision for sampler3D, so the precision lines
+ * below are required, not decoration.
+ */
+export declare const cloudCommon = "\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n";
+/** Analytic single-scattering sky. Also supplies the clouds' ambient and aerial perspective. */
+export declare const skyLib = "\nuniform vec3  u_sunDir;\nuniform vec3  u_sunColor;\nuniform float u_sunIntensity;\n\n// The four Preetham parameters, taken straight from SkySettings so the clouds are\n// lit by the same atmosphere SkyController draws. Hardcoding them here is exactly\n// what makes cloud lighting drift away from the sky behind it.\nuniform float u_turbidity;\nuniform float u_rayleigh;\nuniform float u_mieCoefficient;\nuniform float u_mieG;\n\n/** Sun radiance in the same units skyRadiance() returns. Phase functions integrate to 1\n *  over the sphere, so they return ~1/4pi; without a real radiance the clouds render black. */\nconst float SUN_RADIANCE = 22.0;\n\nfloat rayleighPhase(float mu){ return (3.0 / (16.0 * PI)) * (1.0 + mu * mu); }\nfloat miePhaseHG(float mu, float g){\n  float g2 = g * g;\n  return (1.0 - g2) / (4.0 * PI * pow(max(1.0 + g2 - 2.0 * g * mu, 1e-4), 1.5));\n}\n/** Kasten-Young relative air mass. */\nfloat airMass(float cy){\n  float z = degrees(acos(clamp(cy, -1.0, 1.0)));\n  return min(1.0 / (max(cy, 0.0) + 0.15 * pow(max(93.885 - z, 0.5), -1.253)), 40.0);\n}\n\nvec3 skyRadiance(vec3 rd){\n  float mu = dot(rd, u_sunDir);\n  float up = rd.y;\n  float am = airMass(max(up, -0.02));\n\n  vec3  bR = vec3(0.0487, 0.1130, 0.2780) * u_turbidity * u_rayleigh;\n  float bM = u_mieCoefficient * u_turbidity * 4.25;\n  vec3  ext = bR * am + vec3(bM * am * 1.2);\n\n  // A single-scattering model that applies the full reddened beam everywhere turns the\n  // zenith teal at low sun. Most zenith light is in reality multiply scattered, so the\n  // Rayleigh term sees a partly whitened sun; only the Mie glow keeps the full depth.\n  vec3 rayCol = mix(u_sunColor, vec3(1.0), 0.60);\n  vec3 insR = bR * am * rayleighPhase(mu) * rayCol;\n  vec3 insM = vec3(bM * am * miePhaseHG(mu, u_mieG) * 1.3) * u_sunColor;\n\n  vec3 col = ((insR + insM) / max(ext, vec3(1e-4))) * (1.0 - exp(-ext)) * 26.0;\n\n  float below = saturate(-up * 14.0);\n  vec3 groundCol = vec3(0.055, 0.052, 0.048) * u_sunColor * (0.25 + 0.75 * saturate(u_sunDir.y));\n  return mix(col, groundCol, below);\n}\n\nvec3 sunDisc(vec3 rd){\n  float mu = dot(rd, u_sunDir);\n  float d = smoothstep(0.99976, 0.99992, mu);\n  float limb = 1.0 - 0.42 * saturate((0.99992 - mu) / 0.00016);\n  return u_sunColor * u_sunIntensity * d * limb * 42.0;\n}\n";
+/** Every uniform the density field reads. Include before cloudDensity. */
+export declare const cloudUniforms = "\nprecision highp float;\nprecision highp sampler3D;\nprecision highp sampler2D;\n\nuniform sampler3D u_base;\nuniform sampler3D u_detail;\nuniform sampler2D u_weather;\nuniform sampler2D u_curl;\nuniform float u_time;\n\nuniform float u_coverage, u_density, u_cloudType;\nuniform float u_baseScale, u_detailScale, u_detailStrength, u_curlStrength;\nuniform float u_layerBottom, u_layerTop, u_shear, u_anvil, u_precip;\nuniform float u_weatherScale, u_evolution;\nuniform vec2  u_windDir;\nuniform float u_windSpeed, u_rise, u_churn;\nuniform float u_host, u_radius, u_curvature;\nuniform vec3  u_center;\n";
+export declare const cloudDensity = "\n/**\n * Height fraction inside the cloud body.\n * In layer mode the ray is bent by planetary curvature (t^2 / 2R) so the deck meets a\n * real horizon instead of running to infinity as a flat slab would. Bending the ray is\n * equivalent to raising the sample's altitude and keeps coordinates small, which a\n * literal 6371 km sphere does not.\n */\nfloat heightAt(vec3 p, float t){\n  if (u_host < 0.5){\n    return saturate((p.y - (u_center.y - u_radius)) / max(2.0 * u_radius, 1.0));\n  }\n  float y = p.y + t * t * u_curvature;\n  return saturate((y - u_layerBottom) / max(u_layerTop - u_layerBottom, 1.0));\n}\n\n/** Two scales scrolling at different rates: coverage evolves rather than slides past. */\nvec4 sampleWeather(vec3 p){\n  vec2 b = p.xz * u_weatherScale;\n  vec2 drift = u_windDir * (u_time * u_windSpeed * 0.16) * u_weatherScale;\n  vec4 a = texture(u_weather, b + drift);\n  vec4 c = texture(u_weather, b * 2.17 - drift * 1.63 + vec2(0.31, 0.73));\n  return mix(a, c, 0.36);\n}\n\n/**\n * Three archetypal vertical profiles, blended by type. This is what makes the four\n * models genuinely different shapes rather than one shape with different noise.\n *   0.0  stratus       thin, bottom-weighted, flat top\n *   0.5  cumulus       flat base, bulge in the upper middle, eroded cauliflower top\n *   1.0  cumulonimbus  holds density to the tropopause, then spreads\n */\nfloat heightGradient(float h, float ty){\n  float stratus = saturate(remap(h, 0.00, 0.06, 0.0, 1.0)) * saturate(remap(h, 0.20, 0.36, 1.0, 0.0));\n  float cumulus = saturate(remap(h, 0.02, 0.20, 0.0, 1.0)) * saturate(remap(h, 0.56, 0.96, 1.0, 0.0));\n  float cumulon = saturate(remap(h, 0.01, 0.09, 0.0, 1.0)) * saturate(remap(h, 0.82, 1.00, 1.0, 0.0));\n  return mix(mix(stratus, cumulus, saturate(ty * 2.0)), cumulon, saturate((ty - 0.5) * 2.0));\n}\n\n/**\n * @param detail 0..1 \u2014 fades high-frequency erosion out with distance. Without it the\n *        finest worley octave beats against the step size and the far field speckles.\n */\nfloat cloudDensity(vec3 p, float h, float detail){\n  if (h <= 0.001 || h >= 0.999) return 0.0;\n\n  vec4 w = sampleWeather(p);\n  float ty = saturate(u_cloudType + (w.b - 0.5) * 0.30);\n\n  float cov = mix(w.r, w.g, 0.40);\n  // Slow formation and decay: the coverage threshold itself breathes.\n  cov += sin(u_time * 0.041 + w.b * 12.6) * 0.5 * u_evolution * 0.16;\n\n  // The window slides AND narrows with coverage. Remapping to a fixed upper bound of 1.0\n  // caps effective coverage near the weather map's median (~0.5), so overcast is\n  // unreachable no matter how high the slider goes.\n  cov = saturate(remap(cov, 1.0 - u_coverage, 1.0 - u_coverage * 0.35, 0.0, 1.0));\n  if (cov <= 0.0) return 0.0;\n\n  // Anvil: above the equilibrium level a storm spreads laterally. Gated on type so a\n  // fair-weather cumulus never grows one.\n  float anvil = saturate(remap(h, 0.70, 1.0, 0.0, 1.0)) * u_anvil * saturate((ty - 0.5) * 2.0);\n  cov = saturate(mix(cov, cov * 1.9, anvil));\n\n  // Object host: fade coverage toward the bounding sphere so the volume is not sliced\n  // flat by its own container. Through coverage, not final density, so the detail\n  // erosion still bites into the boundary and the silhouette stays ragged.\n  if (u_host < 0.5){\n    float rad = length(p - u_center) / max(u_radius, 1.0);\n    cov *= saturate(remap(rad, 0.50, 0.97, 1.0, 0.0));\n    if (cov <= 0.0) return 0.0;\n  }\n\n  // Wind shear tilts the column with altitude; then advection; then convective rise.\n  // Three decoupled timescales is what reads as delicate rather than scrolling.\n  vec3 sp = p;\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  sp.xz += u_windDir * (h * u_shear * thick);\n  sp.xz += u_windDir * (u_time * u_windSpeed);\n  sp.y  -= u_time * u_rise;\n\n  vec4 b = texture(u_base, sp * u_baseScale);\n  float lowFbm = b.g * 0.625 + b.b * 0.25 + b.a * 0.125;\n  float shape  = saturate(remap(b.r, lowFbm - 1.0, 1.0, 0.0, 1.0));\n  shape *= heightGradient(h, ty);\n\n  float d = saturate(remap(shape, 1.0 - cov, 1.0, 0.0, 1.0)) * cov;\n  if (d <= 0.0) return 0.0;\n\n  if (detail > 0.01){\n    vec2 curl = texture(u_curl, sp.xz * u_baseScale * 2.4).rg * 2.0 - 1.0;\n    vec3 dp = sp;\n    // Curl warp is strongest at the base, where a cloud shears out into wisps.\n    dp.xz += curl * u_curlStrength * (1.0 - h) * 260.0;\n    dp.y  -= u_time * u_churn;\n    vec3 dn = texture(u_detail, dp * u_detailScale).rgb;\n    float dFbm = dn.r * 0.625 + dn.g * 0.25 + dn.b * 0.125;\n    // Wispy erosion low down, billowy erosion up top.\n    float m = mix(1.0 - dFbm, dFbm, saturate(h * 3.2));\n    d = saturate(remap(d, m * u_detailStrength * detail, 1.0, 0.0, 1.0));\n  }\n\n  return d * u_density;\n}\n\n/**\n * Scattering albedo. Rain-bearing cloud base holds large drops, which absorb far more\n * than the small droplets higher up \u2014 this is why a storm base is charcoal while its\n * top is brilliant white, and it is not something extinction alone reproduces.\n */\nfloat cloudAlbedo(float h){\n  return mix(1.0, 0.22, u_precip * saturate(remap(h, 0.30, 0.02, 0.0, 1.0)));\n}\n\nfloat cloudDensityCheap(vec3 p, float h){ return cloudDensity(p, h, 0.0); }\n";
+/** Ray/layer and ray/sphere intersection. */
+export declare const cloudGeometry = "\n/**\n * Roots of a*t^2 + rd.y*t + (ro.y - h) = 0 with a = 1/(2R).\n * The naive quadratic formula cancels catastrophically here: a is ~1e-7, so\n * (-b + sqrt(b*b - 4ac)) / 2a returns noise for steep rays and the deck vanishes\n * directly overhead. The stable form below is not optional.\n */\nint layerRoots(vec3 ro, vec3 rd, float h, out float r1, out float r2){\n  float a = u_curvature, b = rd.y, c = ro.y - h;\n  r1 = 1e20; r2 = 1e20;\n  if (a < 1e-12){\n    if (abs(b) < 1e-7) return 0;\n    float t = -c / b;\n    if (t > 0.0){ r1 = t; return 1; }\n    return 0;\n  }\n  float disc = b * b - 4.0 * a * c;\n  if (disc < 0.0) return 0;\n  float sq = sqrt(disc);\n  float q  = -0.5 * (b + (b >= 0.0 ? sq : -sq));\n  if (abs(q) < 1e-20) return 0;\n  float ta = q / a;\n  float tb = c / q;\n  float lo = min(ta, tb), hi = max(ta, tb);\n  int n = 0;\n  if (lo > 0.0){ r1 = lo; n = 1; }\n  if (hi > 0.0){ if (n == 0){ r1 = hi; n = 1; } else { r2 = hi; n = 2; } }\n  return n;\n}\n\nbool layerRange(vec3 ro, vec3 rd, float hb, float ht, out float t0, out float t1){\n  float b1, b2, c1, c2;\n  int nb = layerRoots(ro, rd, hb, b1, b2);\n  int nt = layerRoots(ro, rd, ht, c1, c2);\n  float ts[4]; int n = 0;\n  if (nb > 0){ ts[n] = b1; n++; }\n  if (nb > 1){ ts[n] = b2; n++; }\n  if (nt > 0){ ts[n] = c1; n++; }\n  if (nt > 1){ ts[n] = c2; n++; }\n  if (n == 0){\n    if (ro.y > hb && ro.y < ht){ t0 = 0.0; t1 = 120000.0; return true; }\n    return false;\n  }\n  for (int i = 0; i < 4; i++)\n  for (int j = i + 1; j < 4; j++){\n    if (j < n && ts[j] < ts[i]){ float tmp = ts[i]; ts[i] = ts[j]; ts[j] = tmp; }\n  }\n  bool inside = (ro.y > hb && ro.y < ht);\n  if (inside){ t0 = 0.0; t1 = ts[0]; }\n  else { t0 = ts[0]; t1 = (n > 1) ? ts[n - 1] : ts[0] + 6000.0; }\n  return t1 > t0;\n}\n\nbool sphereRange(vec3 ro, vec3 rd, vec3 c, float r, out float t0, out float t1){\n  vec3 oc = ro - c;\n  float b = dot(oc, rd);\n  float cc = dot(oc, oc) - r * r;\n  float disc = b * b - cc;\n  if (disc < 0.0) return false;\n  float sq = sqrt(disc);\n  t0 = max(-b - sq, 0.0);\n  t1 = -b + sq;\n  return t1 > t0;\n}\n";
+export declare const cloudLighting = "\nuniform float u_sigmaT, u_g1, u_g2;\nuniform float u_msExtinction, u_msEnergy, u_msPhase;\nuniform float u_powder, u_silver, u_ambient;\nuniform vec3  u_skyAmbient, u_groundAmbient;\nuniform int   u_lightSteps;\nuniform float u_lightStep;\n\nfloat hg(float mu, float g){\n  float g2 = g * g;\n  return (1.0 - g2) / (4.0 * PI * pow(max(1.0 + g2 - 2.0 * g * mu, 1e-4), 1.5));\n}\n/** Forward lobe carries the silver lining; the small backward lobe is the glow you get\n *  when the sun is behind you. A single lobe cannot do both. */\nfloat dualLobe(float mu, float g1, float g2){\n  return mix(hg(mu, g1), hg(mu, -abs(g2)), 0.42);\n}\n\nconst vec3 kCone[6] = vec3[6](\n  vec3( 0.38, 0.35, 0.14), vec3(-0.20, 0.60,-0.30), vec3(-0.50,-0.20, 0.40),\n  vec3( 0.10,-0.55,-0.35), vec3( 0.55, 0.10,-0.55), vec3(-0.15, 0.25, 0.62)\n);\n\n/**\n * Six exponentially growing samples toward the sun, spread inside a cone so the\n * self-shadow is soft instead of banded, plus one long-range probe for distant occluders.\n * The step is a FRACTION of cloud depth, not metres: the same absolute value is wrong\n * for an 800 m deck and an 8 km tower.\n */\nfloat lightMarch(vec3 p, float rayT){\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  float st = u_lightStep * thick;\n  float acc = 0.0;\n  float t = 0.0;\n  for (int i = 0; i < 6; i++){\n    if (i >= u_lightSteps) break;\n    vec3 sp = p + u_sunDir * (t + st * 0.5) + kCone[i] * (t * 0.38);\n    acc += cloudDensityCheap(sp, heightAt(sp, rayT)) * st;\n    t += st;\n    st *= 1.62;\n  }\n  vec3 fp = p + u_sunDir * (t * 2.6);\n  acc += cloudDensityCheap(fp, heightAt(fp, rayT)) * st * 2.0;\n  return acc;\n}\n\n/**\n * Wrenninge / Hillaire multiple-scattering octaves: each octave scales extinction,\n * energy and phase anisotropy down. A real cumulus has optical depth 5-40 and stays\n * white only because photons scatter hundreds of times; first-order exp(-tau) alone\n * renders it black. This approximation is the single biggest difference between a\n * physically-grounded cloud and a generic one.\n */\nvec3 scatterEnergy(float lightD, float mu){\n  vec3 L = vec3(0.0);\n  float a = 1.0, b = 1.0, c = 1.0;\n  for (int n = 0; n < 3; n++){\n    float ph = dualLobe(mu, u_g1 * c, u_g2 * c);\n    L += vec3(b * ph * exp(-lightD * u_sigmaT * a));\n    a *= u_msExtinction; b *= u_msEnergy; c *= u_msPhase;\n  }\n  L += vec3(u_silver * pow(saturate(mu), 8.0) * exp(-lightD * u_sigmaT * 0.35));\n  return L;\n}\n";
+/** Everything a fragment shader needs to evaluate the density field. */
+export declare const cloudField: string;
+/** The full model, including scattering. */
+export declare const cloudFull: string;
+//# sourceMappingURL=cloudCore.glsl.d.ts.map

package/dist/shaders/glsl/cloudCore.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/cloudCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,WAAW,2LAMvB,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,MAAM,qxEAyDlB,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,aAAa,mmBAmBzB,CAAA;AAED,eAAO,MAAM,YAAY,spKAmHxB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,aAAa,kkEAgEzB,CAAA;AAED,eAAO,MAAM,aAAa,88EAgEzB,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,UAAU,QAA+E,CAAA;AAEtG,4CAA4C;AAC5C,eAAO,MAAM,SAAS,QAAyC,CAAA"}