@johnmorrisdotca/chikyu-earth 0.5.0 → 0.8.0

package/dist/space/ephemeris.js

@@ -0,0 +1,162 @@
+// Where the Sun, the Moon and the planets are, as seen from the centre of the Earth, for any date. astronomy-engine (MIT) does the sums; this file asks it
+// for a handful of vectors, keeps them in the scene's axes, and lets a draw interpolate between two answers a second apart instead of asking at every frame.
+import { Body, GeoVector, HelioVector, SiderealTime } from "astronomy-engine";
+/**
+ * The planets drawn, nearest the Sun first.
+ *
+ * @example
+ * ```ts
+ * import { PLANETS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(PLANETS.join(", "));
+ * ```
+ */
+export const PLANETS = ["Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"];
+/** Equatorial J2000 axes (x to the vernal equinox, z to the north pole) to the scene's (y up). */
+const scene = (v) => [v.x, v.z, -v.y];
+const AU_KM = 149_597_870.7;
+/**
+ * The Earth's radius in kilometres, the unit of the scene's distances.
+ *
+ * @example
+ * ```ts
+ * import { EARTH_RADIUS_KM } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(EARTH_RADIUS_KM);
+ * ```
+ */
+export const EARTH_RADIUS_KM = 6371;
+/**
+ * Earth radii in one astronomical unit.
+ *
+ * @example
+ * ```ts
+ * import { AU_IN_EARTH_RADII } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(Math.round(AU_IN_EARTH_RADII));
+ * ```
+ */
+export const AU_IN_EARTH_RADII = AU_KM / EARTH_RADIUS_KM;
+/**
+ * The state of the sky at `ms`: nine vectors and an angle, in a few tenths of a millisecond. It needs astronomy-engine (an optional peer dependency).
+ *
+ * @param ms - A moment, in milliseconds since the Unix epoch.
+ * @returns The Sun, the Moon and the planets as seen from the Earth's centre, and how far the Earth has turned.
+ *
+ * @example
+ * ```ts
+ * import { frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const frame = frameAt(Date.UTC(2026, 10, 2, 12));
+ * console.log(frame.moon.map((n) => n.toFixed(4)));
+ * ```
+ */
+export function frameAt(ms) {
+    const date = new Date(ms);
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = scene(GeoVector(Body[name], date, true));
+    return {
+        ms,
+        sun: scene(GeoVector(Body.Sun, date, true)),
+        moon: scene(GeoVector(Body.Moon, date, true)),
+        planets,
+        spin: SiderealTime(date) * 15,
+    };
+}
+const lerp3 = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+/**
+ * A frame between two others, `t` from 0 to 1. The spin goes the short way round, so a step under half a turn is right.
+ *
+ * @param a - The earlier frame.
+ * @param b - The later frame.
+ * @param t - How far from `a` to `b`, from 0 to 1.
+ * @returns The frame at that fraction.
+ *
+ * @example
+ * ```ts
+ * import { blend, frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const start = Date.UTC(2026, 10, 2);
+ * const middle = blend(frameAt(start), frameAt(start + 1000), 0.5);
+ * console.log(middle.ms - start);
+ * ```
+ */
+export function blend(a, b, t) {
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = lerp3(a.planets[name], b.planets[name], t);
+    let turn = b.spin - a.spin;
+    turn -= 360 * Math.round(turn / 360);
+    return { ms: a.ms + (b.ms - a.ms) * t, sun: lerp3(a.sun, b.sun, t), moon: lerp3(a.moon, b.moon, t), planets, spin: a.spin + turn * t };
+}
+/**
+ * Answers for any moment from two real ones: `at(ms)` asks astronomy-engine only when `ms` leaves the span the last two answers cover, and then looks
+ * `stepMs` ahead, so playing time at a steady rate costs one pair of lookups every `stepMs` and every draw in between is arithmetic.
+ *
+ * @param initialStepMs - How far ahead the second answer looks, in milliseconds.
+ * @returns A track: `at(ms)` for a frame, `lookups` for how many times the ephemeris was asked, `reset()` and `setStep(ms)`.
+ *
+ * @example
+ * ```ts
+ * import { createTrack } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const track = createTrack(1000);
+ * const start = Date.UTC(2026, 10, 2);
+ * for (let step = 0; step < 10; step += 1) track.at(start + step * 50);
+ * console.log(track.lookups);
+ * ```
+ */
+export function createTrack(initialStepMs = 1000) {
+    let stepMs = initialStepMs;
+    let a;
+    let b;
+    let lookups = 0;
+    return {
+        at(ms) {
+            if (!a || !b || ms < a.ms || ms > b.ms) {
+                a = frameAt(ms);
+                b = frameAt(ms + stepMs);
+                lookups += 2;
+            }
+            return blend(a, b, (ms - a.ms) / (b.ms - a.ms));
+        },
+        /** How many times astronomy-engine has been asked for a frame. */
+        get lookups() {
+            return lookups;
+        },
+        reset() {
+            a = undefined;
+            b = undefined;
+        },
+        /** Look further ahead (a faster game clock): the next lookup uses it. */
+        setStep(ms) {
+            stepMs = Math.max(1, ms);
+            a = undefined;
+            b = undefined;
+        },
+    };
+}
+/** The path a planet takes round the Sun, as `count` points around the orbit that starts where the planet is at `ms`, relative to the Sun (scene axes, AU).
+ *
+ * @param name - The planet.
+ * @param ms - The moment the orbit starts at, in milliseconds since the Unix epoch.
+ * @param count - How many segments to cut the orbit into.
+ * @returns `count + 1` points, the last on the first.
+ *
+ * @example
+ * ```ts
+ * import { orbitPath } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const points = orbitPath("Jupiter", Date.UTC(2026, 10, 2), 12);
+ * console.log(points.length);
+ * ```
+ */
+export function orbitPath(name, ms, count = 96) {
+    const periodDays = { Mercury: 87.97, Venus: 224.7, Mars: 686.98, Jupiter: 4332.6, Saturn: 10759, Uranus: 30688, Neptune: 60182 }[name];
+    const points = [];
+    for (let i = 0; i <= count; i += 1)
+        points.push(scene(HelioVector(Body[name], new Date(ms + (i / count) * periodDays * 86_400_000))));
+    return points;
+}
+/** The Earth's own place relative to the Sun, for placing the orbits round the Sun's place in the Earth-centred scene. */

package/dist/space/index.d.ts

@@ -0,0 +1,3 @@
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS, type Frame, type PlanetName, type Vec3 } from "./ephemeris.ts";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition, type ScaleMode } from "./scale.ts";
+export { plainPainter, type BodyDrawing, type BodyPainter } from "./scene.ts";

package/dist/space/index.js

@@ -0,0 +1,5 @@
+// The space view's pure parts: where the bodies are (astronomy-engine, an optional peer) and the two scales. They import on a server. The element is
+// `@johnmorrisdotca/chikyu-earth/space/element`.
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS } from "./ephemeris.js";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition } from "./scale.js";
+export { plainPainter } from "./scene.js";

package/dist/space/satellite-layer.d.ts

@@ -0,0 +1,53 @@
+import type * as THREE from "three";
+import type { SatelliteRef, Satellites } from "../satellites/types.ts";
+import type { ThreeParts } from "../realistic/textures.ts";
+type Three = ThreeParts;
+/** How a group looks: the colour of its dots and their size in CSS pixels, and whether every orbit is drawn (only for a small group). */
+export interface SatelliteStyle {
+    color: string;
+    size: number;
+    orbits: boolean;
+}
+export interface SatelliteGroupState extends SatelliteStyle {
+    satellites: Satellites;
+    visible: boolean;
+}
+/** The part of the space view's model the satellites read and write. */
+export interface SatelliteState {
+    groups: Map<string, SatelliteGroupState>;
+    selected: SatelliteRef | null;
+    /** Written at each draw: satellites placed, whether the clock is too fast for the groups, and the milliseconds the last update took. */
+    drawn: {
+        placed: number;
+        tooFast: boolean;
+        updateMs: number;
+        maxUpdateMs: number;
+        updates: number;
+        totalMs: number;
+    };
+}
+export declare const newSatelliteState: () => SatelliteState;
+/** The most orbits a group may draw all at once, one line each. */
+export declare const MAX_ORBIT_GROUP = 40;
+export interface SatelliteLayer {
+    /** Place every shown group for `model.time` and the chosen satellite exactly. */
+    update(time: number, speed: number): void;
+    /** The satellite nearest to a point of the view (CSS pixels) within `radius`, if one is in front of the Earth. */
+    pick(x: number, y: number, camera: THREE.PerspectiveCamera, size: {
+        width: number;
+        height: number;
+    }, radius: number): SatelliteRef | null;
+    /** Where the chosen satellite is in the view, if it is. */
+    place(camera: THREE.PerspectiveCamera, size: {
+        width: number;
+        height: number;
+    }): {
+        x: number;
+        y: number;
+    } | null;
+    /** The chosen satellite's position and velocity now (Earth radii, km/s), or false. */
+    exact(ref: SatelliteRef, time: number, out: Float64Array): boolean;
+    dispose(): void;
+}
+export declare function createSatelliteLayer(three: Three, scene: THREE.Scene, state: SatelliteState, ratio: () => number): SatelliteLayer;
+export {};

package/dist/space/satellite-layer.js

@@ -0,0 +1,230 @@
+import { MAX_SATELLITE_SPEED } from "../satellites/limits.js";
+export const newSatelliteState = () => ({ groups: new Map(), selected: null, drawn: { placed: 0, tooFast: false, updateMs: 0, maxUpdateMs: 0, updates: 0, totalMs: 0 } });
+/** The most orbits a group may draw all at once, one line each. */
+export const MAX_ORBIT_GROUP = 40;
+const ORBIT_POINTS = 120;
+const ORBIT_REFRESH_GAME_MS = 30 * 60_000;
+const ORBIT_REFRESH_WALL_MS = 1000;
+const POINT_VERT = /* glsl */ `
+uniform float size;
+void main() {
+  gl_PointSize = size;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`;
+const POINT_FRAG = /* glsl */ `
+uniform vec3 tint;
+uniform float ring;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5));
+  if (d > 0.5) discard;
+  float a = ring > 0.5 ? smoothstep(0.30, 0.38, d) * (1.0 - smoothstep(0.44, 0.5, d)) : smoothstep(0.5, 0.2, d);
+  gl_FragColor = vec4(tint, a);
+}`;
+export function createSatelliteLayer(three, scene, state, ratio) {
+    if (!three.Points)
+        throw new Error("Satellites need `Points` from three.js: add it to the parts the three loader hands over (see setThreeLoader)");
+    const Points = three.Points;
+    const drawn = new Map();
+    const tmp = new Float64Array(6);
+    const projected = new three.Vector3();
+    const selectedMaterial = new three.ShaderMaterial({ vertexShader: POINT_VERT, fragmentShader: POINT_FRAG, uniforms: { size: { value: 14 }, tint: { value: new three.Color("#ffffff") }, ring: { value: 1 } }, transparent: true, depthWrite: false });
+    const selectedPosition = new Float32Array(3);
+    const selectedGeometry = new three.BufferGeometry();
+    selectedGeometry.setAttribute("position", new three.BufferAttribute(selectedPosition, 3));
+    const selectedPoints = new Points(selectedGeometry, selectedMaterial);
+    selectedPoints.frustumCulled = false;
+    selectedPoints.renderOrder = 6;
+    selectedPoints.visible = false;
+    scene.add(selectedPoints);
+    const selectedLine = { positions: new Float32Array(ORBIT_POINTS * 3), geometry: new three.BufferGeometry(), material: new three.LineBasicMaterial({ color: "#ffffff", transparent: true, opacity: 0.85 }) };
+    selectedLine.geometry.setAttribute("position", new three.BufferAttribute(selectedLine.positions, 3));
+    const selectedLoop = new three.LineLoop(selectedLine.geometry, selectedLine.material);
+    selectedLoop.frustumCulled = false;
+    selectedLoop.visible = false;
+    scene.add(selectedLoop);
+    let selectedKey = "";
+    let selectedAt = 0;
+    let selectedWall = 0;
+    const drop = (entry) => {
+        scene.remove(entry.points);
+        entry.geometry.dispose();
+        entry.material.dispose();
+        for (const line of entry.lines) {
+            scene.remove(line.loop);
+            line.geometry.dispose();
+            line.loop.material.dispose();
+        }
+    };
+    const orbitsOf = (entry, group, time, wall) => {
+        const wanted = group.orbits && group.satellites.count <= MAX_ORBIT_GROUP;
+        if (!wanted) {
+            for (const line of entry.lines)
+                line.loop.visible = false;
+            return;
+        }
+        if (entry.lines.length === group.satellites.count && Math.abs(time - entry.linesAt) < ORBIT_REFRESH_GAME_MS && wall - entry.linesWall < 60_000) {
+            for (const line of entry.lines)
+                line.loop.visible = true;
+            return;
+        }
+        if (entry.lines.length === group.satellites.count && wall - entry.linesWall < ORBIT_REFRESH_WALL_MS)
+            return;
+        while (entry.lines.length < group.satellites.count) {
+            const positions = new Float32Array(ORBIT_POINTS * 3);
+            const geometry = new three.BufferGeometry();
+            geometry.setAttribute("position", new three.BufferAttribute(positions, 3));
+            const material = new three.LineBasicMaterial({ color: group.color, transparent: true, opacity: 0.45 });
+            const loop = new three.LineLoop(geometry, material);
+            loop.frustumCulled = false;
+            scene.add(loop);
+            entry.lines.push({ loop, geometry, positions });
+        }
+        for (let i = 0; i < group.satellites.count; i += 1) {
+            const line = entry.lines[i];
+            const path = group.satellites.orbit(i, time, ORBIT_POINTS);
+            line.positions.set(path.subarray(0, ORBIT_POINTS * 3));
+            line.geometry.getAttribute("position").needsUpdate = true;
+            line.loop.visible = group.satellites.visible(i) || path.some((v) => v !== 0);
+        }
+        entry.linesAt = time;
+        entry.linesWall = wall;
+    };
+    const find = (ref) => state.groups.get(ref.group)?.satellites;
+    return {
+        update(time, speed) {
+            const started = performance.now();
+            const tooFast = Math.abs(speed) > MAX_SATELLITE_SPEED;
+            const step = Math.min(60_000, Math.max(1000, Math.abs(speed) * 1000));
+            for (const [name, entry] of drawn) {
+                if (state.groups.get(name)?.satellites !== entry.source) {
+                    drop(entry);
+                    drawn.delete(name);
+                }
+            }
+            let placed = 0;
+            for (const [name, group] of state.groups) {
+                let entry = drawn.get(name);
+                if (!entry) {
+                    const positions = new Float32Array(group.satellites.count * 3);
+                    const geometry = new three.BufferGeometry();
+                    const attribute = new three.BufferAttribute(positions, 3);
+                    geometry.setAttribute("position", attribute);
+                    const material = new three.ShaderMaterial({ vertexShader: POINT_VERT, fragmentShader: POINT_FRAG, uniforms: { size: { value: group.size * ratio() }, tint: { value: new three.Color(group.color) }, ring: { value: 0 } }, transparent: true, depthWrite: false });
+                    const points = new Points(geometry, material);
+                    points.frustumCulled = false;
+                    points.renderOrder = 5;
+                    scene.add(points);
+                    entry = { source: group.satellites, points, geometry, material, positions, attribute, lines: [], linesAt: Number.NaN, linesWall: 0, style: "" };
+                    drawn.set(name, entry);
+                }
+                const style = `${group.color}|${group.size}|${ratio()}`;
+                if (style !== entry.style) {
+                    entry.style = style;
+                    entry.material.uniforms["size"].value = group.size * ratio();
+                    entry.material.uniforms["tint"].value.set(group.color);
+                }
+                const show = group.visible && !tooFast;
+                entry.points.visible = show;
+                if (!show) {
+                    for (const line of entry.lines)
+                        line.loop.visible = false;
+                    continue;
+                }
+                group.satellites.setStep(step);
+                group.satellites.at(time, entry.positions);
+                entry.attribute.needsUpdate = true;
+                placed += group.satellites.placed;
+                orbitsOf(entry, group, time, started);
+            }
+            const chosen = state.selected;
+            const set = chosen ? find(chosen) : undefined;
+            if (chosen && set && set.exact(chosen.index, time, tmp)) {
+                selectedPosition[0] = tmp[0];
+                selectedPosition[1] = tmp[1];
+                selectedPosition[2] = tmp[2];
+                selectedGeometry.getAttribute("position").needsUpdate = true;
+                selectedPoints.visible = true;
+                const key = `${chosen.group}:${chosen.index}`;
+                if (key !== selectedKey || (Math.abs(time - selectedAt) > ORBIT_REFRESH_GAME_MS && started - selectedWall > ORBIT_REFRESH_WALL_MS)) {
+                    selectedKey = key;
+                    selectedAt = time;
+                    selectedWall = started;
+                    selectedLine.positions.set(set.orbit(chosen.index, time, ORBIT_POINTS).subarray(0, ORBIT_POINTS * 3));
+                    selectedLine.geometry.getAttribute("position").needsUpdate = true;
+                }
+                selectedLoop.visible = true;
+                selectedMaterial.uniforms["size"].value = 14 * ratio();
+            }
+            else {
+                selectedPoints.visible = false;
+                selectedLoop.visible = false;
+                selectedKey = "";
+            }
+            state.drawn.placed = placed;
+            state.drawn.tooFast = tooFast;
+            state.drawn.updateMs = performance.now() - started;
+            if (state.drawn.updateMs > state.drawn.maxUpdateMs)
+                state.drawn.maxUpdateMs = state.drawn.updateMs;
+            state.drawn.updates += 1;
+            state.drawn.totalMs += state.drawn.updateMs;
+        },
+        pick(x, y, camera, size, radius) {
+            let best = null;
+            let bestD = radius * radius;
+            const c = camera.position;
+            for (const [name, entry] of drawn) {
+                const group = state.groups.get(name);
+                if (!group || !entry.points.visible)
+                    continue;
+                const p = entry.positions;
+                for (let i = 0; i < group.satellites.count; i += 1) {
+                    if (!group.satellites.visible(i))
+                        continue;
+                    projected.set(p[i * 3], p[i * 3 + 1], p[i * 3 + 2]).project(camera);
+                    if (projected.z > 1 || projected.z < -1)
+                        continue;
+                    const dx = ((projected.x + 1) / 2) * size.width - x;
+                    const dy = ((1 - projected.y) / 2) * size.height - y;
+                    const d = dx * dx + dy * dy;
+                    if (d > bestD)
+                        continue;
+                    // behind the Earth: the line from the camera to the satellite passes through the unit sphere before it gets there
+                    const px = p[i * 3] - c.x;
+                    const py = p[i * 3 + 1] - c.y;
+                    const pz = p[i * 3 + 2] - c.z;
+                    const len2 = px * px + py * py + pz * pz;
+                    const t = Math.max(0, Math.min(1, -(c.x * px + c.y * py + c.z * pz) / len2));
+                    const nx = c.x + px * t;
+                    const ny = c.y + py * t;
+                    const nz = c.z + pz * t;
+                    if (nx * nx + ny * ny + nz * nz < 0.998)
+                        continue;
+                    best = { group: name, index: i };
+                    bestD = d;
+                }
+            }
+            return best;
+        },
+        place(camera, size) {
+            if (!selectedPoints.visible)
+                return null;
+            projected.set(selectedPosition[0], selectedPosition[1], selectedPosition[2]).project(camera);
+            if (projected.z > 1 || projected.z < -1)
+                return null;
+            return { x: ((projected.x + 1) / 2) * size.width, y: ((1 - projected.y) / 2) * size.height };
+        },
+        exact(ref, time, out) {
+            return find(ref)?.exact(ref.index, time, out) ?? false;
+        },
+        dispose() {
+            for (const entry of drawn.values())
+                drop(entry);
+            drawn.clear();
+            scene.remove(selectedPoints, selectedLoop);
+            selectedGeometry.dispose();
+            selectedMaterial.dispose();
+            selectedLine.geometry.dispose();
+            selectedLine.material.dispose();
+        },
+    };
+}

package/dist/space/scale.d.ts

@@ -0,0 +1,124 @@
+import { type Vec3 } from "./ephemeris.ts";
+/**
+ * The scale the space view is drawn in: `compressed` squeezes the distances so the Moon, the Sun and Neptune fit one view, and `true` keeps the real ones.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon, type ScaleMode } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const mode: ScaleMode = "compressed";
+ * console.log(placeMoon(mode, [0.00257, 0, 0]));
+ * ```
+ */
+export type ScaleMode = "compressed" | "true";
+/**
+ * The Moon's distance in a compressed view, in Earth radii (the true one is about 60).
+ *
+ * @example
+ * ```ts
+ * import { MOON_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(MOON_COMPRESSED);
+ * ```
+ */
+export declare const MOON_COMPRESSED = 10;
+/**
+ * The Sun's distance from the Earth in a compressed view, in Earth radii (the true one is about 23,500). One astronomical unit is this long there.
+ *
+ * @example
+ * ```ts
+ * import { SUN_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(SUN_COMPRESSED);
+ * ```
+ */
+export declare const SUN_COMPRESSED = 44;
+/**
+ * A place in astronomical units from the Earth's centre, at true distance, in Earth radii.
+ *
+ * @param v - The place, in astronomical units.
+ * @returns The same direction, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { truePosition } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(truePosition([0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const truePosition: (v: Vec3) => Vec3;
+/**
+ * The same direction at a compressed distance from the Earth: the Moon is 10 Earth radii away, and a body k times further than the Moon is k^0.25 times as far here.
+ *
+ * @param v - The place, in astronomical units from the Earth's centre.
+ * @returns The place in Earth radii, compressed; the centre stays at the centre.
+ *
+ * @example
+ * ```ts
+ * import { compress } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(compress([0.00257, 0, 0]), compress([0, 0, 0]));
+ * ```
+ */
+export declare function compress(v: Vec3): Vec3;
+/**
+ * The Moon, from the Earth's centre.
+ *
+ * @param mode - The scale.
+ * @param geo - The Moon's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeMoon("true", [0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const placeMoon: (mode: ScaleMode, geo: Vec3) => Vec3;
+/**
+ * The Sun, from the Earth's centre: in a compressed view always 44 Earth radii away, in its real direction.
+ *
+ * @param mode - The scale.
+ * @param geo - The Sun's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeSun } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeSun("compressed", [1, 0, 0]));
+ * ```
+ */
+export declare function placeSun(mode: ScaleMode, geo: Vec3): Vec3;
+/**
+ * A place `helio` astronomical units from the Sun (a planet, or a point on its orbit), round the Sun at `sun`. True: as it is. Compressed: the same direction from
+ * the Sun, at 44 Earth radii times its distance in astronomical units to the power 0.45, so the Earth's own orbit is the 44 and Neptune's is about 200 (30 times as far, really).
+ *
+ * @param mode - The scale.
+ * @param sun - Where the Sun is drawn, in Earth radii.
+ * @param helio - The place in astronomical units from the Sun.
+ * @returns Where to draw the place, in Earth radii from the Earth's centre.
+ *
+ * @example
+ * ```ts
+ * import { placeAround } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeAround("compressed", [44, 0, 0], [1, 0, 0]));
+ * ```
+ */
+export declare function placeAround(mode: ScaleMode, sun: Vec3, helio: Vec3): Vec3;
+/**
+ * Radii in Earth radii: the real ones, and ones large enough to see in a compressed view.
+ *
+ * @example
+ * ```ts
+ * import { RADIUS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(RADIUS["Moon"]);
+ * ```
+ */
+export declare const RADIUS: Record<string, {
+    true: number;
+    compressed: number;
+}>;