@woosh/meep-engine 3.67.0 → 3.68.0

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_velocity_texel.d.ts.map

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_velocity_texel.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,SAAS,CAWhB;0BA7BuB,oCAAoC"}

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel = CodeChunk.from(
+    //language=WGSL
+    `
+fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32> {
+    let ndc = before.xy / before.w;
+    let previous = vec2<f32>((ndc.x + 1.0) * 0.5 * size.x, (1.0 - ndc.y) * 0.5 * size.y);
+
+    return vec4<f32>(pixel - previous, depth - before.w, 0.0);
+}
+`);

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts

@@ -27,10 +27,12 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -51,7 +53,7 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({ graph, texture_depth, texture_visibility, buffer_visible_meshlets, buffer_scene_database, buffer_meshlet_metadata, buffer_meshlet_data, buffer_prev_position_offsets, buffer_prev_positions, skinning_active, resolution, view, }: {
     graph: FrameGraph;

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -30,7 +30,9 @@ import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_velocity_texel } from "./chunk_velocity_texel.js";
 import { construct_pixel_reprojection_matrix } from "./construct_pixel_reprojection_matrix.js";
+import { VELOCITY_FORMAT } from "./VELOCITY_BUFFER.js";
 import { view_velocity_matrices } from "./view_velocity_matrices.js";
 import {
     construct_reprojection_matrix_rotation_only,
@@ -92,7 +94,7 @@ fn read_prev_position(base: u32, vertex_index: u32) -> vec3<f32> {
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec2<f32> {
+) -> @location(0) vec4<f32> {
 
     let cur_px = coord.xy;
     let texel = vec2<u32>(cur_px);
@@ -103,12 +105,13 @@ fn main(
     // Visibility-buffer clears leave VISIBILITY_NONE on sky
     // pixels, where reverse-Z depth is always 0.0. Passing 0.0
     // directly avoids a tDepth textureLoad on every background pixel.
+    // The sky stands infinitely far, so it has no depth to move through.
     if visibility_word == VISIBILITY_NONE {
         let position_previous = v3_matrix4_project(
             vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
         );
-        return cur_px - position_previous.xy;
+        return vec4<f32>(cur_px - position_previous.xy, 0.0, 0.0);
     }
 
     // ── Reconstruct world-space position for this pixel ─────────
@@ -233,15 +236,11 @@ fn main(
         prev_world = prev_world_h.xyz / prev_world_h.w;
     }
 
-    // ── Project to previous frame, compute pixel delta ──────────
-    let prev_clip = mViewProjPrevious * vec4<f32>(prev_world, 1.0);
-    let prev_ndc = prev_clip.xyz / prev_clip.w;
-    let prev_px = vec2<f32>(
-        (prev_ndc.x + 1.0) * 0.5 * res.x,
-        (1.0 - prev_ndc.y) * 0.5 * res.y,
-    );
-
-    return cur_px - prev_px;
+    // ── Project to previous frame: the pixel and depth deltas ───
+    //
+    // This frame's clip w, the point's view depth, is the reciprocal of
+    // the w its unprojection came out with.
+    return velocity_texel(cur_px, 1.0 / cur_world_h.w, mViewProjPrevious * vec4<f32>(prev_world, 1.0), res);
 }
 `, [
         chunk_v3_matrix4_project,
@@ -251,6 +250,7 @@ fn main(
         chunk_read_meshlet_vertex_position,
         MESHLET_METADATA_STRUCT.declaration_chunk,
         chunk_visibility_decode,
+        chunk_velocity_texel,
     ]
 );
 
@@ -261,7 +261,7 @@ const shader = new ImageShader({
         body
     }),
     targets: [{
-        format: "rg16float",
+        format: VELOCITY_FORMAT,
     }]
 });
 
@@ -300,10 +300,12 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -324,7 +326,7 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({
                                                   graph,

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js

@@ -35,3 +35,5 @@ chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.IBL, chunk_forward_s
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.Brick4, chunk_forward_sample_indirect_brick4);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.LPV, chunk_forward_sample_indirect_environment);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_probe_clipmap);
+// the screen probes light only the deferred opaque surfaces: every other reader takes the world-space probes
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ScreenProbes, chunk_forward_sample_indirect_probe_clipmap);

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAr3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QAUzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAt3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -98,6 +98,7 @@ export class GPUSceneContext {
         GPUDatabase.enquirePipelines(enquiry);
         GPUAnimationManager.enquirePipelines(enquiry);
         enquiry.compute.push(shader_refresh_all_mesh_bounds.pipeline);
+        GPUSky.enquirePipelines(enquiry);
         GPULightCollection.enquirePipelines(enquiry);
         GPUInstancesAccelerationStructure.enquirePipelines(enquiry);
         GPUSceneVolumetrics.enquirePipelines(enquiry);
@@ -314,7 +315,7 @@ export class GPUSceneContext {
 
         this.#wind = new GPUSceneWind(device);
 
-        this.#sky = new GPUSky(graphics);
+        this.#sky = new GPUSky(graphics, scene.atmosphere);
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }

package/src/shade/renderer/scene/Scene.d.ts

@@ -2,8 +2,8 @@
  * @typedef {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
  */
 /**
- * A scene: the dataset whose entities are what it draws and poses, and the three things that are
- * not entities — its lights' collection, a light probe volume, volumetrics.
+ * A scene: the dataset whose entities are what it draws and poses, and the things that are
+ * not entities — its lights' collection, atmosphere, a light probe volume, volumetrics.
  *
  * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
  * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
@@ -27,6 +27,12 @@ export class Scene {
      * @type {LightCollection}
      */
     lights: LightCollection;
+    /**
+     * Physical Hillaire (2020) sky and atmosphere configuration.
+     *
+     * @type {SceneAtmosphere}
+     */
+    atmosphere: SceneAtmosphere;
     /**
      *
      * @type {LightProbeVolume}
@@ -45,6 +51,7 @@ export class Scene {
 }
 export type EntityComponentDataset = import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset;
 import { LightCollection } from "../light/LightCollection.js";
+import { SceneAtmosphere } from "../atmosphere/SceneAtmosphere.js";
 import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
 import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
 //# sourceMappingURL=Scene.d.ts.map

package/src/shade/renderer/scene/Scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;OAOG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCA1CY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;iCAD5B,gDAAgD;iCAEhD,oCAAoC"}
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;OAOG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;;OAIG;IACH,YAFU,eAAe,CAEU;IAEnC;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCAjDY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;gCAF7B,kCAAkC;iCACjC,gDAAgD;iCAEhD,oCAAoC"}

package/src/shade/renderer/scene/Scene.js

@@ -1,3 +1,4 @@
+import { SceneAtmosphere } from "../atmosphere/SceneAtmosphere.js";
 import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
 import { LightCollection } from "../light/LightCollection.js";
 import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
@@ -7,8 +8,8 @@ import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
  */
 
 /**
- * A scene: the dataset whose entities are what it draws and poses, and the three things that are
- * not entities — its lights' collection, a light probe volume, volumetrics.
+ * A scene: the dataset whose entities are what it draws and poses, and the things that are
+ * not entities — its lights' collection, atmosphere, a light probe volume, volumetrics.
  *
  * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
  * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
@@ -34,6 +35,13 @@ export class Scene {
      */
     lights = new LightCollection();
 
+    /**
+     * Physical Hillaire (2020) sky and atmosphere configuration.
+     *
+     * @type {SceneAtmosphere}
+     */
+    atmosphere = new SceneAtmosphere();
+
     /**
      *
      * @type {LightProbeVolume}

package/src/shade/renderer/shader/ImageShader.d.ts

@@ -6,14 +6,16 @@ export class ImageShader {
      * Utility constructor, matching general Shade API
      * @param {Object} options
      * @param {ShaderDescriptor} options.descriptor
-     * @param {ColorTargetState[]} options.targets
-     * @param {DepthStencilState} [options.depthStencil]
+     * @param {(GPUColorTargetState|{clearValue?:number[]})[]} options.targets
+     * @param {GPUDepthStencilState} [options.depthStencil]
      * @returns {ImageShader}
      */
     static from({ descriptor, targets, depthStencil, }: {
         descriptor: ShaderDescriptor;
-        targets: ColorTargetState[];
-        depthStencil?: DepthStencilState;
+        targets: (GPUColorTargetState | {
+            clearValue?: number[];
+        })[];
+        depthStencil?: GPUDepthStencilState;
     }): ImageShader;
     constructor({ descriptor, targets, depthStencil, }: {
         descriptor: any;
@@ -24,7 +26,7 @@ export class ImageShader {
      *
      * @returns {ShaderDescriptor}
      */
-    get descriptor(): ShaderDescriptor;
+    get descriptor(): import("./ShaderDescriptor.js").ShaderDescriptor;
     /**
      * Optional clear values for each target
      * @type {number[][]}
@@ -62,16 +64,26 @@ export class ImageShader {
     /**
      * Note the absence of depth target, image shader is a full-screen pass, so depth is not used.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} [bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
-     * @param {GPURenderPassColorAttachment[]} [colorAttachments] where to draw, these are fragment shader outputs.
-     * @param {GPURenderPassDepthStencilAttachment} [depthStencilAttachment]
-     * @param {GPUTextureFormat[]} [color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
-     * @param {number[]} [viewport] [x0, y0, width, height ]
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} [options.bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
+     * @param {GPURenderPassColorAttachment[]} [options.colorAttachments] where to draw, these are fragment shader outputs.
+     * @param {GPURenderPassDepthStencilAttachment} [options.depthStencilAttachment]
+     * @param {GPUTextureFormat[]} [options.color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
+     * @param {number[]} [options.viewport] [x0, y0, width, height ]
      */
-    draw({ encoder, bindings, colorAttachments, depthStencilAttachment, color_formats, viewport }: ShadeGPUCommandContext): void;
+    draw({ encoder, bindings, colorAttachments, depthStencilAttachment, color_formats, viewport }: {
+        encoder: ShadeGPUCommandContext;
+        bindings?: any;
+        colorAttachments?: GPURenderPassColorAttachment[];
+        depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
+        color_formats?: GPUTextureFormat[];
+        viewport?: number[];
+    }): void;
     #private;
 }
 export type RenderPipelineDescriptor = import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type ShaderSwitchSet = import("./compiler/ShaderSwitchSet.js").ShaderSwitchSet;
+export type ShaderDescriptor = import("./ShaderDescriptor.js").ShaderDescriptor;
 //# sourceMappingURL=ImageShader.d.ts.map

package/src/shade/renderer/shader/ImageShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAiLI;;;;;;;OAOG;IACH;QALqC,UAAU;QACR,OAAO,EAAnC,kBAAkB;QACU,YAAY;QACtC,WAAW,CAavB;IA9ED;;;;OAwDC;IAxKD;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAelB;;;OAGG;IACH,gHAEC;IAED;;;;;;;;OAQG;IACH,4BAHW,kBAAkB,GAChB,wBAAwB,CAIpC;IAED;;;OAGG;IACH,6BAEC;IAoBD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,WAAW,CA8BvB;IAkFD;;;;;;;;;OASG;IACH,6HA0EC;;CACJ;uCApSY,OAAO,8DAA8D,EAAE,wBAAwB;8BAC/F,OAAO,+BAA+B,EAAE,eAAe"}
+{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAeA;;GAEG;AACH;IAiLI;;;;;;;OAOG;IACH;QALqC,UAAU,EAApC,gBAAgB;QACwC,OAAO,EAA/D,CAAC,sBAAoB;YAAC,UAAU,CAAC,EAAC,MAAM,EAAE,CAAA;SAAC,CAAC,EAAE;QACf,YAAY;QACzC,WAAW,CAavB;IA9ED;;;;OAwDC;IAxKD;;;OAGG;IACH,mEAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAelB;;;OAGG;IACH,gHAEC;IAED;;;;;;;;OAQG;IACH,4BAHW,kBAAkB,GAChB,wBAAwB,CAIpC;IAED;;;OAGG;IACH,6BAEC;IAoBD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,WAAW,CA8BvB;IAkFD;;;;;;;;;;OAUG;IACH;QAP2C,OAAO,EAAvC,sBAAsB;QACL,QAAQ;QACgB,gBAAgB,GAAzD,8BAA8B;QACgB,sBAAsB;QACvC,aAAa,GAA1C,kBAAkB;QACC,QAAQ,GAA3B,MAAM,EAAE;aA4ElB;;CACJ;uCAvSY,OAAO,8DAA8D,EAAE,wBAAwB;qCAC/F,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,+BAA+B,EAAE,eAAe;+BACvD,OAAO,uBAAuB,EAAE,gBAAgB"}

package/src/shade/renderer/shader/ImageShader.js

@@ -6,7 +6,9 @@ import { create_full_quad_pipeline_descriptor } from "./fullscreen/create_full_q
 
 /**
  * @typedef {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} RenderPipelineDescriptor
+ * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("./compiler/ShaderSwitchSet.js").ShaderSwitchSet} ShaderSwitchSet
+ * @typedef {import("./ShaderDescriptor.js").ShaderDescriptor} ShaderDescriptor
  */
 
 const VALIDATION_ENABLED = true;
@@ -195,8 +197,8 @@ export class ImageShader {
      * Utility constructor, matching general Shade API
      * @param {Object} options
      * @param {ShaderDescriptor} options.descriptor
-     * @param {ColorTargetState[]} options.targets
-     * @param {DepthStencilState} [options.depthStencil]
+     * @param {(GPUColorTargetState|{clearValue?:number[]})[]} options.targets
+     * @param {GPUDepthStencilState} [options.depthStencil]
      * @returns {ImageShader}
      */
     static from({
@@ -215,12 +217,13 @@ export class ImageShader {
     /**
      * Note the absence of depth target, image shader is a full-screen pass, so depth is not used.
      *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {Object} [bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
-     * @param {GPURenderPassColorAttachment[]} [colorAttachments] where to draw, these are fragment shader outputs.
-     * @param {GPURenderPassDepthStencilAttachment} [depthStencilAttachment]
-     * @param {GPUTextureFormat[]} [color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
-     * @param {number[]} [viewport] [x0, y0, width, height ]
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} [options.bindings] data bindings. It's optional, but in 99.99% of use cases you will want to specify this.
+     * @param {GPURenderPassColorAttachment[]} [options.colorAttachments] where to draw, these are fragment shader outputs.
+     * @param {GPURenderPassDepthStencilAttachment} [options.depthStencilAttachment]
+     * @param {GPUTextureFormat[]} [options.color_formats] optional, if specified will be used to rewrite the pipeline for compatibility
+     * @param {number[]} [options.viewport] [x0, y0, width, height ]
      */
     draw({
              encoder,

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.d.ts

@@ -1,5 +1,7 @@
 /**
- * This is more of atmosphere "width" or "thickness", as it's relative to the surface
+ * Default Earth atmosphere shell thickness above `PLANET_RADIUS` in GPU atmosphere units
+ * ($\text{km}$), derived from physical metres via {@link ATMOSPHERE_UNIT_SCALE_DECLARATION}.
+ *
  * @type {CodeChunk}
  */
 export const ATMOSPHERE_HEIGHT_DECLARATION: CodeChunk;

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ATMOSPHERE_HEIGHT_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,4CAFU,SAAS,CAKjB;0BATwB,6BAA6B"}
+{"version":3,"file":"ATMOSPHERE_HEIGHT_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4CAFU,SAAS,CAUjB;0BAhBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js

@@ -1,10 +1,18 @@
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "../../../atmosphere/ATMOSPHERE_UNIT_SCALE.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 
 /**
- * This is more of atmosphere "width" or "thickness", as it's relative to the surface
+ * Default Earth atmosphere shell thickness above `PLANET_RADIUS` in GPU atmosphere units
+ * ($\text{km}$), derived from physical metres via {@link ATMOSPHERE_UNIT_SCALE_DECLARATION}.
+ *
  * @type {CodeChunk}
  */
 export const ATMOSPHERE_HEIGHT_DECLARATION = CodeChunk.from(
-//language=WGSL
-    `const ATMOSPHERE_HEIGHT = 100000;`
+    //language=WGSL
+    `
+const ATMOSPHERE_HEIGHT_METERS: f32 = 100000.0;
+const ATMOSPHERE_HEIGHT: f32 = ATMOSPHERE_HEIGHT_METERS * METERS_TO_ATMOSPHERE_UNITS;
+    `, [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
+    ]
 );

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.d.ts

@@ -1,15 +1,6 @@
 /**
- * The two sphere radii the atmosphere is bounded by, as f32.
- *
- * `PLANET_RADIUS` and `ATMOSPHERE_HEIGHT` carry no type suffix, so they are AbstractInt.
- * That converts silently wherever it is used directly in an f32 expression, but binding one
- * to an un-annotated `let` materialises it to i32 — which then neither mixes with f32 nor
- * holds the square of a planetary radius, since 6478000^2 is four orders of magnitude past
- * what an i32 can represent. Anything that needs a radius as a value rather than as a term
- * takes it from here.
- *
- * The squares are what the ray/sphere quadratics actually want, and as module-scope consts
- * they are folded once rather than recomputed per invocation.
+ * The two concentric sphere radii bounding the default Earth atmosphere, in GPU atmosphere units
+ * ($\text{km}$, see `ATMOSPHERE_UNIT_SCALE_DECLARATION`).
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ATMOSPHERE_RADII_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CAcjB;0BA/BwB,6BAA6B"}
+{"version":3,"file":"ATMOSPHERE_RADII_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAFU,SAAS,CAcjB;0BAtBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.js

@@ -1,32 +1,23 @@
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "./ATMOSPHERE_HEIGHT_DECLARATION.js";
-import { PLANET_RADIUS_DECLARATION } from "./PLANET_RADIUS_DECLARATION.js";
-
-/**
- * The two sphere radii the atmosphere is bounded by, as f32.
- *
- * `PLANET_RADIUS` and `ATMOSPHERE_HEIGHT` carry no type suffix, so they are AbstractInt.
- * That converts silently wherever it is used directly in an f32 expression, but binding one
- * to an un-annotated `let` materialises it to i32 — which then neither mixes with f32 nor
- * holds the square of a planetary radius, since 6478000^2 is four orders of magnitude past
- * what an i32 can represent. Anything that needs a radius as a value rather than as a term
- * takes it from here.
- *
- * The squares are what the ray/sphere quadratics actually want, and as module-scope consts
- * they are folded once rather than recomputed per invocation.
- *
- * @type {CodeChunk}
- */
-export const ATMOSPHERE_RADII_DECLARATION = CodeChunk.from(
-    //language=WGSL
-    `
-const ATMOSPHERE_GROUND_RADIUS = f32(PLANET_RADIUS);
-const ATMOSPHERE_TOP_RADIUS = f32(PLANET_RADIUS) + f32(ATMOSPHERE_HEIGHT);
-
-const ATMOSPHERE_GROUND_RADIUS_SQUARED = ATMOSPHERE_GROUND_RADIUS * ATMOSPHERE_GROUND_RADIUS;
-const ATMOSPHERE_TOP_RADIUS_SQUARED = ATMOSPHERE_TOP_RADIUS * ATMOSPHERE_TOP_RADIUS;
-    `, [
-        PLANET_RADIUS_DECLARATION,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-    ]
-);
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { ATMOSPHERE_HEIGHT_DECLARATION } from "./ATMOSPHERE_HEIGHT_DECLARATION.js";
+import { PLANET_RADIUS_DECLARATION } from "./PLANET_RADIUS_DECLARATION.js";
+
+/**
+ * The two concentric sphere radii bounding the default Earth atmosphere, in GPU atmosphere units
+ * ($\text{km}$, see `ATMOSPHERE_UNIT_SCALE_DECLARATION`).
+ *
+ * @type {CodeChunk}
+ */
+export const ATMOSPHERE_RADII_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    `
+const ATMOSPHERE_GROUND_RADIUS: f32 = PLANET_RADIUS;
+const ATMOSPHERE_TOP_RADIUS: f32 = PLANET_RADIUS + ATMOSPHERE_HEIGHT;
+
+const ATMOSPHERE_GROUND_RADIUS_SQUARED: f32 = ATMOSPHERE_GROUND_RADIUS * ATMOSPHERE_GROUND_RADIUS;
+const ATMOSPHERE_TOP_RADIUS_SQUARED: f32 = ATMOSPHERE_TOP_RADIUS * ATMOSPHERE_TOP_RADIUS;
+    `, [
+        PLANET_RADIUS_DECLARATION,
+        ATMOSPHERE_HEIGHT_DECLARATION,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Default Earth radius in GPU atmosphere units ($\text{km}$), derived from the physical metre
+ * radius via {@link ATMOSPHERE_UNIT_SCALE_DECLARATION}.
+ *
+ * @type {CodeChunk}
+ */
 export const PLANET_RADIUS_DECLARATION: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 //# sourceMappingURL=PLANET_RADIUS_DECLARATION.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PLANET_RADIUS_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js"],"names":[],"mappings":"AAEA,kDAGE;0BALwB,6BAA6B"}
+{"version":3,"file":"PLANET_RADIUS_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,SAAS,CAUjB;0BAhBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js

@@ -1,6 +1,18 @@
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "../../../atmosphere/ATMOSPHERE_UNIT_SCALE.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 
+/**
+ * Default Earth radius in GPU atmosphere units ($\text{km}$), derived from the physical metre
+ * radius via {@link ATMOSPHERE_UNIT_SCALE_DECLARATION}.
+ *
+ * @type {CodeChunk}
+ */
 export const PLANET_RADIUS_DECLARATION = CodeChunk.from(
-//language=WGSL
-    `const PLANET_RADIUS = 6378000;`
+    //language=WGSL
+    `
+const PLANET_RADIUS_METERS: f32 = 6378000.0;
+const PLANET_RADIUS: f32 = PLANET_RADIUS_METERS * METERS_TO_ATMOSPHERE_UNITS;
+    `, [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
+    ]
 );

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_height.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_atmosphere_height.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_height.js"],"names":[],"mappings":"AAIA,gDAYE;0BAhBwB,6BAA6B"}
+{"version":3,"file":"chunk_atmosphere_height.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_height.js"],"names":[],"mappings":"AAKA,gDAaE;0BAjBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_height.js

@@ -1,3 +1,4 @@
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "../../../atmosphere/ATMOSPHERE_UNIT_SCALE.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { PLANET_CENTER_DECLARATION } from "./PLANET_CENTER_DECLARATION.js";
 import { PLANET_RADIUS_DECLARATION } from "./PLANET_RADIUS_DECLARATION.js";
@@ -5,12 +6,13 @@ import { PLANET_RADIUS_DECLARATION } from "./PLANET_RADIUS_DECLARATION.js";
 export const chunk_atmosphere_height = CodeChunk.from(
     //language=WGSL
     `
-fn atmosphere_height( position_ws:vec3<f32> ) -> f32
+fn atmosphere_height(position_ws: vec3<f32>) -> f32
 {
-	return distance(position_ws, PLANET_CENTER) - PLANET_RADIUS;
+    return (distance(position_ws * METERS_TO_ATMOSPHERE_UNITS, PLANET_CENTER) - PLANET_RADIUS) * ATMOSPHERE_UNIT_METERS;
 }
 `,
     [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
         PLANET_RADIUS_DECLARATION,
         PLANET_CENTER_DECLARATION
     ]

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_intersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_atmosphere_intersection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_intersection.js"],"names":[],"mappings":"AAMA,sDAcO;0BApBmB,6BAA6B"}
+{"version":3,"file":"chunk_atmosphere_intersection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_intersection.js"],"names":[],"mappings":"AAOA,sDAqBO;0BA3BmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_intersection.js

@@ -1,3 +1,4 @@
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "../../../atmosphere/ATMOSPHERE_UNIT_SCALE.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { ATMOSPHERE_HEIGHT_DECLARATION } from "./ATMOSPHERE_HEIGHT_DECLARATION.js";
 import { chunk_sphere_intersection } from "./chunk_sphere_intersection.js";
@@ -8,12 +9,19 @@ export const chunk_atmosphere_intersection = CodeChunk.from(
     //language=WGSL
     `
 fn atmosphere_intersection (
-    rayStart:vec3<f32>,
-    rayDir:vec3<f32>
+    rayStart: vec3<f32>,
+    rayDir: vec3<f32>
 ) -> vec2<f32> {
-	return sphere_intersection(rayStart, rayDir, PLANET_CENTER, PLANET_RADIUS + ATMOSPHERE_HEIGHT);
+    let hits = sphere_intersection(
+        rayStart * METERS_TO_ATMOSPHERE_UNITS,
+        rayDir,
+        PLANET_CENTER,
+        PLANET_RADIUS + ATMOSPHERE_HEIGHT
+    );
+    return select(hits, hits * ATMOSPHERE_UNIT_METERS, hits >= vec2<f32>(0.0));
 }
 `, [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
         chunk_sphere_intersection,
         PLANET_CENTER_DECLARATION,
         PLANET_RADIUS_DECLARATION,