@woosh/meep-engine 3.65.0 → 3.68.0

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,

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_atmosphere_ray_bounds.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAiDjB;0BApEwB,6BAA6B"}
+{"version":3,"file":"chunk_atmosphere_ray_bounds.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAgDjB;0BAnEwB,6BAA6B"}

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

@@ -1,69 +1,68 @@
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { ATMOSPHERE_RADII_DECLARATION } from "./ATMOSPHERE_RADII_DECLARATION.js";
-
-/**
- * How far a ray inside the atmosphere may be marched, and whether it ends on the surface.
- *
- * The ground and the atmosphere shell are concentric on the planet and the ray is shared, so
- * one quadratic setup serves both intersections — only the radius term differs. Calling a
- * general sphere-intersection routine twice instead recomputes the ray-origin offset and all
- * three dot products for the second sphere, and re-derives a leading coefficient that is 1
- * for a unit direction.
- *
- * `origin_rel` is relative to the planet centre and assumed to be inside the atmosphere and
- * at or above the surface, which is what makes the shell's far root the exit point.
- * `ray_direction` must be normalised.
- *
- * `ground_distance` is negative when the ray never meets the surface, which includes looking
- * up from above it: both roots are behind the origin there.
- *
- * @type {CodeChunk}
- */
-export const chunk_atmosphere_ray_bounds = CodeChunk.from(
-    //language=WGSL
-    `
-struct AtmosphereRayBounds {
-    // as far as a march may go: the surface when the ray meets it, the shell otherwise
-    t_max: f32,
-    // distance to the surface, negative when there is no hit ahead
-    ground_distance: f32,
-    hits_ground: bool,
-}
-
-fn atmosphere_ray_bounds(
-    origin_rel: vec3<f32>,
-    ray_direction: vec3<f32>
-) -> AtmosphereRayBounds {
-
-    // ray_direction is a unit vector, so the leading coefficient is 1 and the factors of two
-    // divide out of both roots
-    let b = dot(origin_rel, ray_direction);
-    let r2 = dot(origin_rel, origin_rel);
-    let b2 = b * b;
-
-    // inside the shell, so its constant term is negative, the discriminant is positive, and
-    // the far root is where the ray leaves
-    let atmosphere_distance = -b + sqrt(max(b2 - (r2 - ATMOSPHERE_TOP_RADIUS_SQUARED), 0.0));
-
-    // the ground is the near root, and only when that root is ahead of us
-    let ground_discriminant = b2 - (r2 - ATMOSPHERE_GROUND_RADIUS_SQUARED);
-    let ground_distance = select(
-        -1.0,
-        -b - sqrt(max(ground_discriminant, 0.0)),
-        ground_discriminant >= 0.0
-    );
-
-    let hits_ground = ground_distance > 0.0;
-
-    var result: AtmosphereRayBounds;
-
-    result.t_max = select(atmosphere_distance, ground_distance, hits_ground);
-    result.ground_distance = ground_distance;
-    result.hits_ground = hits_ground;
-
-    return result;
-}
-    `, [
-        ATMOSPHERE_RADII_DECLARATION,
-    ]
-);
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { ATMOSPHERE_RADII_DECLARATION } from "./ATMOSPHERE_RADII_DECLARATION.js";
+
+/**
+ * How far a ray inside the atmosphere may be marched, and whether it ends on the surface.
+ *
+ * The ground and the atmosphere shell are concentric on the planet and the ray is shared, so
+ * one quadratic setup serves both intersections — only the radius term differs. Calling a
+ * general sphere-intersection routine twice instead recomputes the ray-origin offset and all
+ * three dot products for the second sphere, and re-derives a leading coefficient that is 1
+ * for a unit direction.
+ *
+ * `origin_rel` is relative to the planet centre and assumed to be inside the atmosphere and
+ * at or above the surface, which is what makes the shell's far root the exit point.
+ * `ray_direction` must be normalised.
+ *
+ * `ground_distance` is negative when the ray never meets the surface, which includes looking
+ * up from above it: both roots are behind the origin there.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_ray_bounds = CodeChunk.from(
+    //language=WGSL
+    `
+struct AtmosphereRayBounds {
+    // as far as a march may go: the surface when the ray meets it, the shell otherwise
+    t_max: f32,
+    // distance to the surface, negative when there is no hit ahead
+    ground_distance: f32,
+    hits_ground: bool,
+}
+
+fn atmosphere_ray_bounds(
+    origin_rel: vec3<f32>,
+    ray_direction: vec3<f32>
+) -> AtmosphereRayBounds {
+
+    // ray_direction is a unit vector, so the leading coefficient is 1 and the factors of two
+    // divide out of both roots
+    let b = dot(origin_rel, ray_direction);
+    let r = length(origin_rel);
+    let b2 = b * b;
+
+    // Difference-of-squares factoring (r - R)(r + R) avoids catastrophic f32 cancellation when
+    // altitude (r - R) is metres above a 6,378 km planet radius.
+    let atmosphere_distance = -b + sqrt(max(b2 - (r - ATMOSPHERE_TOP_RADIUS) * (r + ATMOSPHERE_TOP_RADIUS), 0.0));
+
+    // the ground is the near root, and only when that root is ahead of us
+    let ground_discriminant = b2 - (r - ATMOSPHERE_GROUND_RADIUS) * (r + ATMOSPHERE_GROUND_RADIUS);
+    let hits_ground = (b < 0.0) && (ground_discriminant >= 0.0);
+    let ground_distance = select(
+        -1.0,
+        max(-b - sqrt(max(ground_discriminant, 0.0)), 0.0),
+        hits_ground
+    );
+
+    var result: AtmosphereRayBounds;
+
+    result.t_max = select(atmosphere_distance, ground_distance, hits_ground);
+    result.ground_distance = ground_distance;
+    result.hits_ground = hits_ground;
+
+    return result;
+}
+    `, [
+        ATMOSPHERE_RADII_DECLARATION,
+    ]
+);

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

@@ -1,5 +1,8 @@
 /**
- * @see https://www.shadertoy.com/view/slSXRW
+ * Integrates direct solar transmittance from `pos` along `sunDir` to the top of the atmosphere,
+ * returning zero when the ray intersects the planet sphere.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
  * @type {CodeChunk}
  */
 export const chunk_get_sun_transmittance: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_get_sun_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,0CAFU,SAAS,CA+CjB;0BA1DwB,6BAA6B"}
+{"version":3,"file":"chunk_get_sun_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0CAFU,SAAS,CAsDjB;0BA7DwB,6BAA6B"}