@aethervtt/shard-render 0.0.1

package/dist/atmosphere-state.d.ts

@@ -0,0 +1,72 @@
+import { type Entity, type ShardError } from '@aethervtt/shard-core';
+import type { AtmosphereModel, Lut } from './atmosphere-model.js';
+/** An atmosphere as the renderer tracks it: a component's, or a ProceduralSky camera's. */
+export interface AtmosphereRecord {
+    /** The atmosphere's entity; for ProceduralSky, the camera's. */
+    entity: Entity;
+    /** A ProceduralSky (or DefaultEnvironment.sky) mapped onto an Earth atmosphere. */
+    wrapper: boolean;
+    model: AtmosphereModel;
+    /** Bumped when the parameters change (the LUTs are recomputed). */
+    version: number;
+    /** thickness ≤ 0 and the like: not drawn. */
+    problem: ShardError | undefined;
+    /** Center, relative to the floating origin (m). */
+    center: Float64Array;
+    /** The frame it was last seen (records unseen for a while are dropped). */
+    seen: number;
+    /** CPU LUTs for `atmosphere.sample` (built on first use, per version). */
+    cpu: {
+        version: number;
+        transmittance: Lut;
+        multiscatter: Lut;
+    } | undefined;
+    /** GPU LUT layer, and the version it holds (`atmosphere-nodes`). */
+    layer: number;
+    layerVersion: number;
+}
+/** The atmospheres a camera sees this frame. */
+export interface CameraAtmosphere {
+    camera: Entity;
+    /** The atmosphere the camera is in, or else the nearest one on screen. */
+    primary: AtmosphereRecord | undefined;
+    inside: boolean;
+    /** Camera height above the primary's bottomRadius (m). */
+    altitude: number;
+    /** Composite order, far to near, primary last (at most 4). */
+    list: AtmosphereRecord[];
+    /** Camera relative to each listed atmosphere's center (km, xyz) and inside (w). */
+    origins: Float64Array;
+    /** Per directional light (as the light buffer orders them): transmittance rgb toward it. */
+    sunTransmittance: Float32Array;
+    /** The two brightest directional lights: light index, direction, illuminance, disk radius. */
+    suns: {
+        count: number;
+        index: Int32Array;
+        data: Float32Array;
+    };
+    /** Sky-view frame: up, azimuth 0 (toward the sun), azimuth 90°. */
+    frame: Float64Array;
+    /** Draw the sky (and the environment map behind it); -1: don't. */
+    background: number;
+    aerialPerspective: boolean;
+    skyViewSize: [number, number];
+    froxels: [number, number, number];
+    maxDistance: number;
+    /** Fog on this camera was ignored (render/fog-with-atmosphere). */
+    fogIgnored: boolean;
+    /** Changes when the IBL bake is out of date (atmosphere, altitude 2%, up and suns 0.25°). */
+    bakeKey: string;
+    /** Pixels across (radius) of each listed atmosphere's top sphere. */
+    pixels: Float64Array;
+}
+export declare class AtmosphereStore {
+    readonly records: Map<number, AtmosphereRecord>;
+    /** ProceduralSky wrappers, by camera. */
+    readonly wrappers: Map<number, AtmosphereRecord>;
+    readonly cameras: Map<number, CameraAtmosphere>;
+    frame: number;
+    /** Warnings and errors already logged, so each shows once. */
+    readonly logged: Set<string>;
+}
+export declare const Atmospheres: import("@aethervtt/shard-core").ResourceDef<AtmosphereStore>;

package/dist/atmosphere-state.js

@@ -0,0 +1,18 @@
+import { defineResource } from "@aethervtt/shard-core";
+class AtmosphereStore {
+  records = /* @__PURE__ */ new Map();
+  /** ProceduralSky wrappers, by camera. */
+  wrappers = /* @__PURE__ */ new Map();
+  cameras = /* @__PURE__ */ new Map();
+  frame = 0;
+  /** Warnings and errors already logged, so each shows once. */
+  logged = /* @__PURE__ */ new Set();
+}
+const Atmospheres = defineResource("render/Atmospheres", {
+  description: "Atmospheres in the world and what each camera sees of them (spec 0044).",
+  init: () => new AtmosphereStore()
+});
+export {
+  AtmosphereStore,
+  Atmospheres
+};

package/dist/atmosphere.d.ts

@@ -0,0 +1,191 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import { type AppMethod } from '@aethervtt/shard-runtime';
+import { type AtmosphereModel } from './atmosphere-model.js';
+export declare const Atmosphere: import("@aethervtt/shard-core").ComponentDef<{
+    readonly bottomRadius: import("@aethervtt/shard-core").FieldType<number, "f64">;
+    readonly thickness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly rayleighScattering: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly rayleighScale: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mieScattering: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mieAbsorption: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mieScale: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mieG: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mieGOffset: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly absorption: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly absorptionCenter: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly absorptionWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly groundAlbedo: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly deckDepth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const AtmosphereSettings: import("@aethervtt/shard-core").ComponentDef<{
+    readonly aerialPerspective: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly skyViewSize: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly froxels: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly maxDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export interface AtmosphereValue {
+    bottomRadius: number;
+    thickness: number;
+    rayleighScattering: [number, number, number];
+    rayleighScale: number;
+    mieScattering: number;
+    mieAbsorption: number;
+    mieScale: number;
+    mieG: number;
+    mieGOffset: [number, number, number];
+    absorption: [number, number, number];
+    absorptionCenter: number;
+    absorptionWidth: number;
+    groundAlbedo: [number, number, number, number];
+    intensity: number;
+    deckDepth: number;
+}
+/**
+ * Atmosphere presets: whole component values (bottomRadius 0: the planet's radius). Apply one with
+ * `world.set(e, Atmosphere, AtmospherePresets.mars)` or copy its values into a scene.
+ */
+export declare const AtmospherePresets: {
+    readonly earth: AtmosphereValue;
+    /** Thin CO₂ and fine dust: butterscotch by day, a blue glow around the setting sun. */
+    readonly mars: {
+        readonly bottomRadius: number;
+        readonly intensity: number;
+        readonly deckDepth: number;
+        readonly thickness: 80000;
+        readonly rayleighScattering: [1.1e-7, 2.6e-7, 6.3e-7];
+        readonly rayleighScale: 11100;
+        readonly mieScattering: 0.00003;
+        readonly mieAbsorption: 0.000003;
+        readonly mieScale: 11000;
+        readonly mieG: 0.72;
+        readonly mieGOffset: [-0.15, 0, 0.2];
+        readonly absorption: [0.000003, 0.000008, 0.000016];
+        readonly absorptionCenter: 0;
+        readonly absorptionWidth: 44000;
+        readonly groundAlbedo: [0.45, 0.25, 0.15, 1];
+    };
+    /** A small world's thin air: a dark blue sky and faint haze. */
+    readonly thin: {
+        readonly bottomRadius: number;
+        readonly mieScale: number;
+        readonly mieG: number;
+        readonly mieGOffset: [number, number, number];
+        readonly absorptionCenter: number;
+        readonly absorptionWidth: number;
+        readonly groundAlbedo: [number, number, number, number];
+        readonly intensity: number;
+        readonly deckDepth: number;
+        readonly thickness: 30000;
+        readonly rayleighScattering: [0.00000145, 0.00000339, 0.00000828];
+        readonly rayleighScale: 5000;
+        readonly mieScattering: 4e-7;
+        readonly mieAbsorption: 4.4e-7;
+        readonly absorption: [0, 0, 0];
+    };
+    /** Dense aerosols: a pale sky and distant hills lost in haze a few km out. */
+    readonly 'thick-haze': {
+        readonly bottomRadius: number;
+        readonly thickness: number;
+        readonly rayleighScattering: [number, number, number];
+        readonly rayleighScale: number;
+        readonly mieGOffset: [number, number, number];
+        readonly absorption: [number, number, number];
+        readonly absorptionCenter: number;
+        readonly absorptionWidth: number;
+        readonly groundAlbedo: [number, number, number, number];
+        readonly intensity: number;
+        readonly deckDepth: number;
+        readonly mieScattering: 0.00008;
+        readonly mieAbsorption: 0.00002;
+        readonly mieScale: 3000;
+        readonly mieG: 0.7;
+    };
+    /** Red and blue scatter, green passes: a violet sky with green-gold sunsets. */
+    readonly 'alien-violet': {
+        readonly bottomRadius: number;
+        readonly thickness: number;
+        readonly rayleighScale: number;
+        readonly mieScattering: number;
+        readonly mieAbsorption: number;
+        readonly mieScale: number;
+        readonly mieG: number;
+        readonly mieGOffset: [number, number, number];
+        readonly absorption: [number, number, number];
+        readonly absorptionCenter: number;
+        readonly absorptionWidth: number;
+        readonly groundAlbedo: [number, number, number, number];
+        readonly intensity: number;
+        readonly deckDepth: number;
+        readonly rayleighScattering: [0.000026, 0.000006, 0.0000331];
+    };
+    /** Hydrogen and helium over a cloud deck: tall, weakly absorbing; raise absorption for Neptune. */
+    readonly 'gas-giant': {
+        readonly mieG: number;
+        readonly mieGOffset: [number, number, number];
+        readonly intensity: number;
+        readonly bottomRadius: 69911000;
+        readonly thickness: 2000000;
+        readonly rayleighScattering: [0.0000014, 0.0000033, 0.000008];
+        readonly rayleighScale: 27000;
+        readonly mieScattering: 0.000001;
+        readonly mieAbsorption: 2e-7;
+        readonly mieScale: 20000;
+        readonly absorption: [3e-7, 3e-8, 0];
+        readonly absorptionCenter: 0;
+        readonly absorptionWidth: 400000;
+        readonly groundAlbedo: [0.8, 0.7, 0.55, 1];
+        readonly deckDepth: 200000;
+    };
+};
+export type AtmospherePreset = keyof typeof AtmospherePresets;
+export { type AtmosphereRecord, AtmosphereStore, Atmospheres, type CameraAtmosphere, } from './atmosphere-state.js';
+/** The model of an atmosphere component's values (with bottomRadius already resolved), in km. */
+export declare function atmosphereModel(value: AtmosphereValue, bottomRadius: number): AtmosphereModel;
+/**
+ * Per camera: picks the primary atmosphere (the one it's in, or else the nearest on screen) and up
+ * to three secondaries (on screen, over 4 px), computes sunlight transmittance at the camera, and
+ * turns on the sky, the aerial-perspective pass, and the fog override.
+ */
+export declare const selectAtmospheres: import("@aethervtt/shard-core").SystemDef<{
+    q: import("@aethervtt/shard-core").Query;
+}>;
+/**
+ * Transmittance (rgb) of the air between a point (world space, origin-relative m) and a sun, through
+ * an atmosphere: the factor the renderer applies to that sun's light at the camera. `sun` counts
+ * directional lights brightest first. Zero when the planet is in the way. Headless-safe.
+ */
+export declare function sunTransmittanceAt(world: World, atmosphere: Entity, position: ArrayLike<number>, sun?: number): [number, number, number];
+export interface AtmosphereSampleResult {
+    /** Sky radiance toward the direction (cd/m²), the ground's where the ray ends on it. */
+    radiance: [number, number, number];
+    luminance: number;
+    /** How much of what's behind (space, stars) shows through, per channel. */
+    transmittance: [number, number, number];
+    hitsGround: boolean;
+    /** Of the position above bottomRadius (m). */
+    altitude: number;
+    inside: boolean;
+}
+/** Sky radiance and transmittance from a position (world, m) toward a direction, on the CPU. */
+export declare function sampleAtmosphere(world: World, atmosphere: Entity, position: ArrayLike<number>, direction: ArrayLike<number>): AtmosphereSampleResult;
+/** GPU ms of a timed pass, if the profiler has it. */
+type Timings = Record<string, {
+    avg: number;
+}>;
+/** The atmosphere section of `render.describe`. */
+export declare function describeAtmospheres(world: World, timings?: Timings): {
+    views: Record<string, unknown>;
+    atmospheres: {
+        entity: number;
+        version: number;
+        problem: {
+            code: string;
+            message: string;
+            hint?: string;
+            path?: string;
+            details?: unknown[];
+        } | null;
+    }[];
+} | undefined;
+export declare const atmosphereMethods: AppMethod[];