@johnmorrisdotca/wakusei-planets 0.7.0 → 0.11.1

package/dist/facts.d.ts

@@ -10,7 +10,18 @@
  */
 export declare const PLANET_IDS: readonly ["mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"];
 /**
- * The moons the package draws, by planet.
+ * The dwarf planets besides Pluto, nearest the Sun first (by the size of their orbits).
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * console.log(DWARF_IDS.join(", "));
+ * ```
+ */
+export declare const DWARF_IDS: readonly ["ceres", "orcus", "haumea", "quaoar", "makemake", "gonggong", "eris", "sedna"];
+/**
+ * The moons the package draws, by planet or dwarf planet.
  *
  * @example
  * ```ts
@@ -27,6 +38,9 @@ export declare const MOONS_OF: {
     readonly uranus: readonly ["miranda", "ariel", "umbriel", "titania", "oberon"];
     readonly neptune: readonly ["proteus", "triton", "nereid"];
     readonly pluto: readonly ["charon", "nix", "hydra"];
+    readonly orcus: readonly ["vanth"];
+    readonly haumea: readonly ["hiiaka", "namaka"];
+    readonly eris: readonly ["dysnomia"];
 };
 /**
  * The name of a planet or of Pluto: `mercury` to `pluto`.
@@ -40,6 +54,30 @@ export declare const MOONS_OF: {
  * ```
  */
 export type PlanetId = (typeof PLANET_IDS)[number];
+/**
+ * The name of a dwarf planet besides Pluto: `ceres`, `eris`, `haumea`...
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS, type DwarfId } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * const id: DwarfId = DWARF_IDS[0];
+ * console.log(id);
+ * ```
+ */
+export type DwarfId = (typeof DWARF_IDS)[number];
+/**
+ * A body a moon can go round: a planet, Pluto or another dwarf planet.
+ *
+ * @example
+ * ```ts
+ * import { MOONS_OF, type HostId } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * const host: HostId = "eris";
+ * console.log(MOONS_OF[host]);
+ * ```
+ */
+export type HostId = PlanetId | DwarfId;
 /**
  * The name of a moon the package draws, such as `moon`, `io` or `titan`.
  *
@@ -53,7 +91,7 @@ export type PlanetId = (typeof PLANET_IDS)[number];
  */
 export type MoonId = (typeof MOONS_OF)[keyof typeof MOONS_OF][number];
 /**
- * The name of a body: `sun`, a planet or a moon.
+ * The name of a body: `sun`, a planet, a dwarf planet or a moon.
  *
  * @example
  * ```ts
@@ -63,7 +101,7 @@ export type MoonId = (typeof MOONS_OF)[keyof typeof MOONS_OF][number];
  * console.log(lineSvg(id, { size: 64 }).length > 100);
  * ```
  */
-export type BodyId = "sun" | PlanetId | MoonId;
+export type BodyId = "sun" | PlanetId | DwarfId | MoonId;
 /**
  * How a body is drawn: `line` (an outline drawing), `realistic` (shaded, from the numbers) or `painted` (a real surface map).
  *
@@ -139,8 +177,8 @@ export type Feature = {
 export interface BodyFacts {
     id: BodyId;
     kind: "star" | "planet" | "dwarf-planet" | "moon";
-    /** The planet a moon goes round. */
-    parent?: PlanetId;
+    /** The planet or dwarf planet a moon goes round. */
+    parent?: HostId;
     name: {
         en: string;
         ja: string;
@@ -186,7 +224,7 @@ export interface BodyFacts {
  */
 export declare const BODIES: Readonly<Record<BodyId, BodyFacts>>;
 /**
- * Every body's name: the Sun, the planets outward, then the moons of each planet.
+ * Every body's name: the Sun, the planets outward, the dwarf planets, then the moons of each.
  *
  * @example
  * ```ts

package/dist/facts.js

@@ -12,7 +12,18 @@
  */
 export const PLANET_IDS = ["mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"];
 /**
- * The moons the package draws, by planet.
+ * The dwarf planets besides Pluto, nearest the Sun first (by the size of their orbits).
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * console.log(DWARF_IDS.join(", "));
+ * ```
+ */
+export const DWARF_IDS = ["ceres", "orcus", "haumea", "quaoar", "makemake", "gonggong", "eris", "sedna"];
+/**
+ * The moons the package draws, by planet or dwarf planet.
  *
  * @example
  * ```ts
@@ -29,6 +40,9 @@ export const MOONS_OF = {
     uranus: ["miranda", "ariel", "umbriel", "titania", "oberon"],
     neptune: ["proteus", "triton", "nereid"],
     pluto: ["charon", "nix", "hydra"],
+    orcus: ["vanth"],
+    haumea: ["hiiaka", "namaka"],
+    eris: ["dysnomia"],
 };
 const f = (id, kind, en, ja, radiusKm, flattening, tiltDeg, ra, dec, w0, rate, rotationHours, colour, more = {}) => ({
     id,
@@ -131,6 +145,17 @@ export const BODIES = {
             ...dots([[-60, 20, 6], [-100, -20, 7], [60, 40, 5]]),
         ],
     }),
+    ceres: f("ceres", "dwarf-planet", "Ceres", "ケレス", 481.05, 0.0731, 4.04, 291.42744, 66.76033, 170.65, 952.1532, 9.07417, "#7b7873", {
+        showLon: 239,
+        features: [{ kind: "circle", lon: 239, lat: 20, radius: 6 }, { kind: "circle", lon: 239, lat: 20, radius: 1.5, fill: true }, { kind: "circle", lon: 10, lat: -42, radius: 10 }, ...dots([[-60, 30, 8], [100, 15, 9], [160, -20, 7], [-120, -35, 8], [40, 45, 6], [-20, 0, 5]])],
+    }),
+    orcus: f("orcus", "dwarf-planet", "Orcus", "オルクス", 455, 0, 73.83, 142.474, 15.004, 0, 655.15, 13.188, "#9a9a9c", { features: dots([[-60, 20, 9], [40, -15, 7], [130, 30, 8], [-130, -30, 6]]) }),
+    haumea: f("haumea", "dwarf-planet", "Haumea", "ハウメア", 798, 0, 90.15, 282.6, -13, 0, 2206.6, 3.915341, "#dfe0e3", { showLon: 90, axesKm: [1161, 852, 513], features: [{ kind: "oval", lon: 40, lat: 5, rx: 22, ry: 12, fill: true }, { kind: "band", lat: 0 }, ...dots([[-80, 25, 7]])] }),
+    quaoar: f("quaoar", "dwarf-planet", "Quaoar", "クワオアー", 557.8, 0, 0, 265.4, 74.409, 0, 488.72, 17.6788, "#a3735a", { showLon: 90, axesKm: [620.7, 546.5, 511.5], features: dots([[-40, 20, 8], [70, -15, 9], [150, 35, 7], [-110, -30, 6]]) }),
+    makemake: f("makemake", "dwarf-planet", "Makemake", "マケマケ", 715, 0.01, 0, 317.92, 50.03, 0, 378.5, 22.8266, "#b87f5d", { features: [{ kind: "oval", lon: 30, lat: 10, rx: 30, ry: 18, fill: true }, ...dots([[-70, -20, 8], [120, 25, 7]])] }),
+    gonggong: f("gonggong", "dwarf-planet", "Gonggong", "ゴンゴン", 615, 0, 0, 255.383, 36.831, 0, 385.7, 22.4, "#9c4f3b", { features: dots([[-50, 10, 9], [60, -25, 8], [140, 30, 7]]) }),
+    eris: f("eris", "dwarf-planet", "Eris", "エリス", 1163, 0, 78.22, 36.17, 44.51, 0, 22.805163, 378.8616, "#e8e4dc", { features: [{ kind: "band", lat: 0 }, ...dots([[-30, 30, 8], [80, -20, 9]])] }),
+    sedna: f("sedna", "dwarf-planet", "Sedna", "セドナ", 453, 0, 0, 297.062, 74.71, 0, 840.95, 10.273, "#9a3f2b", { features: dots([[-40, 20, 9], [70, -30, 8], [150, 10, 7]]) }),
     moon: f("moon", "moon", "Moon", "月", 1737.4, 0.0012, 6.68, 269.9949, 66.5392, 38.3213, 13.17635815, 655.728, "#b8b5ae", {
         parent: "earth",
         synchronous: true,
@@ -169,9 +194,13 @@ export const BODIES = {
     charon: f("charon", "moon", "Charon", "カロン", 606, 0, 0, 132.993, -6.163, 122.695, 56.3625225, 153.2935, "#9c9189", { parent: "pluto", synchronous: true, features: [{ kind: "oval", lon: 0, lat: 76, rx: 90, ry: 14, fill: true }, { kind: "circle", lon: 40, lat: -15, radius: 12 }, ...dots([[-60, 10, 8], [120, 30, 7]])] }),
     nix: f("nix", "moon", "Nix", "ニクス", 19.3, 0.3, 0, 132.993, -6.163, 0, 14.48, 0, "#b3ada7", { parent: "pluto", axesKm: [24.9, 16.6, 15.6], features: [{ kind: "circle", lon: 0, lat: 0, radius: 18 }] }),
     hydra: f("hydra", "moon", "Hydra", "ヒドラ", 19.5, 0.4, 0, 132.993, -6.163, 0, 9.42, 0, "#c4beb6", { parent: "pluto", axesKm: [32.5, 22.5, 12.5], features: [{ kind: "circle", lon: 30, lat: 10, radius: 20 }] }),
+    vanth: f("vanth", "moon", "Vanth", "ヴァント", 221, 0, 0, 142.474, 15.004, 0, 37.738618, 228.9488, "#6e6a66", { parent: "orcus", synchronous: true, features: dots([[-50, 15, 10], [80, -20, 9], [150, 30, 8]]) }),
+    hiiaka: f("hiiaka", "moon", "Hiʻiaka", "ヒイアカ", 185, 0, 0, 282.6, -13, 0, 0, 0, "#e0e0e0", { parent: "haumea", features: dots([[-30, 20, 12], [70, -25, 10]]) }),
+    namaka: f("namaka", "moon", "Namaka", "ナマカ", 75, 0, 0, 282.6, -13, 0, 0, 0, "#d0d0d0", { parent: "haumea", features: dots([[0, 0, 14]]) }),
+    dysnomia: f("dysnomia", "moon", "Dysnomia", "ディスノミア", 308, 0, 0, 36.17, 44.51, 0, 22.805163, 378.8616, "#5a5856", { parent: "eris", synchronous: true, features: dots([[-60, 20, 10], [50, -25, 9], [140, 30, 8]]) }),
 };
 /**
- * Every body's name: the Sun, the planets outward, then the moons of each planet.
+ * Every body's name: the Sun, the planets outward, the dwarf planets, then the moons of each.
  *
  * @example
  * ```ts
@@ -180,7 +209,7 @@ export const BODIES = {
  * console.log(BODY_IDS.length, BODY_IDS[0]);
  * ```
  */
-export const BODY_IDS = ["sun", ...PLANET_IDS, ...Object.values(MOONS_OF).flat()];
+export const BODY_IDS = ["sun", ...PLANET_IDS, ...DWARF_IDS, ...Object.values(MOONS_OF).flat()];
 /** A body's polar radius as a fraction of its equatorial radius. */
 export const polarRatio = (facts) => 1 - facts.flattening;
 /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { BODIES, BODY_IDS, MOONS_OF, PLANET_IDS, ringReach, type BodyFacts, type BodyId, type Feature, type Look, type MoonId, type PlanetId, type RingBand } from "./facts.ts";
+export { BODIES, BODY_IDS, DWARF_IDS, MOONS_OF, PLANET_IDS, ringReach, type BodyFacts, type BodyId, type DwarfId, type Feature, type HostId, type Look, type MoonId, type PlanetId, type RingBand } from "./facts.ts";
 export { apparent, moonGeocentric, heliocentric, orbitPath, system, type Apparent, type MoonPlace, type Pose, type System } from "./ephemeris.ts";
 export { drawnTilt, portrait, type PortraitOptions } from "./pose.ts";
 export { lineSvg, mix, type LineOptions } from "./line.ts";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { BODIES, BODY_IDS, MOONS_OF, PLANET_IDS, ringReach } from "./facts.js";
+export { BODIES, BODY_IDS, DWARF_IDS, MOONS_OF, PLANET_IDS, ringReach } from "./facts.js";
 export { apparent, moonGeocentric, heliocentric, orbitPath, system } from "./ephemeris.js";
 export { drawnTilt, portrait } from "./pose.js";
 export { lineSvg, mix } from "./line.js";

package/dist/line.js

@@ -54,12 +54,15 @@ function around(lon, lat, rx, ry, steps = 28) {
     }
     return out;
 }
+/** The semi-axes of a body that is far from round, as fractions of its radius. */
+const axesOf = (facts) => (facts.axesKm === undefined ? undefined : [facts.axesKm[0] / facts.radiusKm, facts.axesKm[1] / facts.radiusKm, facts.axesKm[2] / facts.radiusKm]);
 function featurePaths(facts, pose, frame, stroke, hair) {
     const f = facts.flattening;
-    const visible = (lon, lat) => facing(pose, lon, lat, f) > 0.02;
+    const axes = axesOf(facts);
+    const visible = (lon, lat) => facing(pose, lon, lat, f, axes) > 0.02;
     const out = [];
     const draw = (pts, close, fill) => {
-        const parts = runs(pts.map((p) => surfacePoint(pose, p.lon, p.lat, f)), (_, i) => visible(pts[i].lon, pts[i].lat));
+        const parts = runs(pts.map((p) => surfacePoint(pose, p.lon, p.lat, f, axes)), (_, i) => visible(pts[i].lon, pts[i].lat));
         for (const part of parts) {
             const whole = close && part.length === pts.length;
             if (part.length < 2)
@@ -176,7 +179,7 @@ function cachedOrbit(id, time) {
 }
 function bodyGroup(id, pose, frame, o, hair, ringScale) {
     const facts = BODIES[id];
-    const sil = silhouette(pose, facts.flattening);
+    const sil = silhouette(pose, facts.flattening, axesOf(facts));
     const disc = `<ellipse cx="${n(frame.cx)}" cy="${n(frame.cy)}" rx="${n(frame.r * sil.a)}" ry="${n(frame.r * sil.b)}" transform="rotate(${n(sil.angle)} ${n(frame.cx)} ${n(frame.cy)})"`;
     const rings = ringPaths(facts, pose, frame, o.stroke, hair, ringScale);
     const dark = id === "sun" || facts.kind === "star" ? "" : nightPath(pose, frame);
@@ -227,7 +230,7 @@ export function lineSvg(id, options = {}) {
     if (options.moons === true && facts.parent === undefined && id !== "sun")
         return systemSvg(id, options, size, stroke, paper, hair, head);
     const pose = poseFor(id, options);
-    const reach = Math.max(ringReach(facts), id === "sun" ? 1.08 : 1);
+    const reach = Math.max(ringReach(facts), id === "sun" ? 1.08 : 1, ...(axesOf(facts) ?? []));
     const fit = options.fill === undefined ? 0.94 / reach : options.fill;
     const zoom = options.zoom ?? 1;
     const frame = { cx: (size / 2) * (1 - (options.panX ?? 0)), cy: (size / 2) * (1 + (options.panY ?? 0)), r: (size / 2) * fit * zoom };

package/dist/portrait/model.d.ts

@@ -108,7 +108,7 @@ export interface Resolved {
 }
 export declare const ASPECTS: readonly (readonly [string, number])[];
 export declare const MAX_ITEMS = 40;
-/** The Sun, then each planet followed by its moons nearest first: the order a layout and a row of buttons use. */
+/** The Sun, then each planet and dwarf planet followed by its moons nearest first: the order a layout and a row of buttons use. */
 export declare const ORDER: readonly BodyId[];
 export declare const rankOf: (id: BodyId) => number;
 /**
@@ -285,7 +285,7 @@ export interface Preset {
     scene: Portrait;
 }
 /**
- * Ready-made scenes to start from: a family photo of the Sun and the planets, the gas giants to scale, Jupiter and the Galileans, and the Earth and the Moon to scale.
+ * Ready-made scenes to start from: a family photo of the Sun and the planets, the gas giants to scale, Jupiter and the Galileans, the Earth and the Moon to scale (size and distance), Mars and its moons at their true distance, and the inner planets round the Sun.
  *
  * @example
  * ```ts

package/dist/portrait/model.js

@@ -1,11 +1,12 @@
 // The portrait builder's scene as plain data, and everything that can be worked out from it without a screen: where each body goes when the layout is automatic, the camera that fits them,
 // which body is under a pointer, where a dragged body snaps, the order they are drawn in, the history for undo, and the short text that keeps a scene in the address. Pure: no DOM, no three.js.
 import { ORBITS } from "../data/orbits.js";
-import { BODIES, MOONS_OF, PLANET_IDS, ringReach } from "../facts.js";
+import { heliocentric, moonVector } from "../ephemeris.js";
+import { BODIES, DWARF_IDS, MOONS_OF, PLANET_IDS, ringReach } from "../facts.js";
 export const ASPECTS = [["16:9", 16 / 9], ["4:3", 4 / 3], ["1:1", 1], ["3:4", 3 / 4]];
 export const MAX_ITEMS = 40;
-/** The Sun, then each planet followed by its moons nearest first: the order a layout and a row of buttons use. */
-export const ORDER = ["sun", ...PLANET_IDS.flatMap((planet) => [planet, ...(planet in MOONS_OF ? [...MOONS_OF[planet]].sort(byDistance) : [])])];
+/** The Sun, then each planet and dwarf planet followed by its moons nearest first: the order a layout and a row of buttons use. */
+export const ORDER = ["sun", ...[...PLANET_IDS, ...DWARF_IDS].flatMap((planet) => [planet, ...(planet in MOONS_OF ? [...MOONS_OF[planet]].sort(byDistance) : [])])];
 function byDistance(a, b) {
     return (ORBITS[a]?.a ?? 0) - (ORBITS[b]?.a ?? 0);
 }
@@ -122,6 +123,130 @@ function arrangeUnits(units, how, aspect) {
     }
     return out;
 }
+// --- the true orbit distance layout ---------------------------------------------------------------------------------------------------------------------
+const AU_KM = 149_597_870.7;
+const J2000 = Date.UTC(2000, 0, 1, 12);
+/**
+ * The orbit layout, in kilometres: the Sun (if it is in the scene) with the planets at their true distance, each planet with its moons at theirs; or each planet with its moons, side by side.
+ * With a date the bodies are where they really are, seen from above the ecliptic; without one they are in a line to the right of their centre. Sizes are true, or squeezed so the smallest can be seen.
+ */
+function orbitLayout(p) {
+    const items = p.items;
+    const ms = p.date === undefined ? undefined : Date.parse(p.date);
+    const when = ms !== undefined && Number.isFinite(ms) ? ms : undefined;
+    const index = new Map(items.map((i, k) => [i.body, k]));
+    const planetKind = (id) => BODIES[id].parent === undefined && id !== "sun";
+    const planetSpot = (id) => {
+        const v = heliocentric(id, when ?? J2000);
+        return when === undefined ? { x: Math.hypot(v[0], v[1], v[2]) * AU_KM, y: 0 } : { x: v[0] * AU_KM, y: v[1] * AU_KM };
+    };
+    const moonSpot = (id) => {
+        if (when === undefined)
+            return { x: ORBITS[id]?.a ?? 0, y: 0 };
+        const v = moonVector(id, when);
+        return { x: v[0], y: v[1] };
+    };
+    const systems = [];
+    const taken = new Set();
+    const sun = index.get("sun");
+    const attachMoons = (system, planet, at) => {
+        for (const [k, item] of items.entries()) {
+            if (BODIES[item.body].parent !== items[planet].body || taken.has(k))
+                continue;
+            const m = moonSpot(item.body);
+            system.members.push(k);
+            system.spot.set(k, { x: at.x + m.x, y: at.y + m.y });
+            system.centre.set(k, planet);
+            taken.add(k);
+        }
+    };
+    if (sun !== undefined) {
+        const system = { members: [sun], spot: new Map([[sun, { x: 0, y: 0 }]]), centre: new Map() };
+        taken.add(sun);
+        for (const [k, item] of items.entries()) {
+            if (!planetKind(item.body))
+                continue;
+            const at = planetSpot(item.body);
+            system.members.push(k);
+            system.spot.set(k, at);
+            system.centre.set(k, sun);
+            taken.add(k);
+            attachMoons(system, k, at);
+        }
+        systems.push(system);
+    }
+    for (const [k, item] of items.entries()) {
+        if (taken.has(k) || !planetKind(item.body))
+            continue;
+        const system = { members: [k], spot: new Map([[k, { x: 0, y: 0 }]]), centre: new Map() };
+        taken.add(k);
+        if (p.moons === "auto")
+            attachMoons(system, k, { x: 0, y: 0 });
+        systems.push(system);
+    }
+    for (const [k] of items.entries()) {
+        if (taken.has(k))
+            continue;
+        systems.push({ members: [k], spot: new Map([[k, { x: 0, y: 0 }]]), centre: new Map() });
+        taken.add(k);
+    }
+    // sizes: true, or squeezed against the size of the picture the distances make
+    const ids = items.map((i) => i.body);
+    let span = 0;
+    for (const system of systems) {
+        for (const k of system.members) {
+            const c = system.centre.get(k);
+            if (c === undefined)
+                continue;
+            const a = system.spot.get(k);
+            const b = system.spot.get(c);
+            span = Math.max(span, Math.hypot(a.x - b.x, a.y - b.y));
+        }
+    }
+    const biggest = Math.max(...ids.map((id) => BODIES[id].radiusKm));
+    span = Math.max(span, biggest * 8);
+    const radius = (id) => (p.scale === "true" ? BODIES[id].radiusKm : Math.max(0.014 * span, 0.06 * span * (BODIES[id].radiusKm / biggest) ** 0.4));
+    const raw = items.map((item, index2) => ({ ...item, index: index2, x: 0, y: 0, r: radius(item.body), reach: radius(item.body) * reachOf(item.body) }));
+    // the circle each body goes round its centre on reaches this far every way
+    const extent = (system) => {
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minY = Infinity;
+        let maxY = -Infinity;
+        for (const k of system.members) {
+            const a = system.spot.get(k);
+            const reach = raw[k].reach;
+            minX = Math.min(minX, a.x - reach);
+            maxX = Math.max(maxX, a.x + reach);
+            minY = Math.min(minY, a.y - reach);
+            maxY = Math.max(maxY, a.y + reach);
+            const c = system.centre.get(k);
+            if (c !== undefined) {
+                const b = system.spot.get(c);
+                const d = Math.hypot(a.x - b.x, a.y - b.y);
+                minX = Math.min(minX, b.x - d);
+                maxX = Math.max(maxX, b.x + d);
+                minY = Math.min(minY, b.y - d);
+                maxY = Math.max(maxY, b.y + d);
+            }
+        }
+        return { minX, maxX, minY, maxY };
+    };
+    const extents = systems.map(extent);
+    const units = systems.map((s, k) => ({ members: s.members, at: [], minX: extents[k].minX, maxX: extents[k].maxX, halfH: Math.max(extents[k].maxY, -extents[k].minY) }));
+    const spots = arrangeUnits(units, "row", p.aspect);
+    const reachPoints = [];
+    systems.forEach((s, k) => {
+        const dy = (extents[k].minY + extents[k].maxY) / 2;
+        for (const m of s.members) {
+            const a = s.spot.get(m);
+            raw[m].x = spots[k].ox + a.x;
+            raw[m].y = a.y - dy;
+        }
+        reachPoints.push({ x: spots[k].ox + extents[k].minX, y: extents[k].minY - dy }, { x: spots[k].ox + extents[k].maxX, y: extents[k].maxY - dy });
+    });
+    return { placed: raw, reachPoints };
+}
 /** The camera that holds every body with a margin: its centre and half-height. */
 export function fitCamera(placed, aspect, margin = 1.1, labels = false) {
     if (placed.length === 0)
@@ -161,6 +286,12 @@ export function resolve(scene) {
     if (p.layout === "manual" || p.items.length === 0) {
         return { placed: p.items.map((item, index) => ({ ...item, index, reach: item.r * reachOf(item.body) })), camera: p.camera };
     }
+    if (p.arrange === "orbit") {
+        const { placed: raw, reachPoints } = orbitLayout(p);
+        const cam = fitCamera([...raw, ...reachPoints.map((q) => ({ x: q.x, y: q.y, reach: 0 }))], p.aspect, 1.1, p.labels);
+        const k = 1 / cam.h;
+        return { placed: raw.map((it) => ({ ...it, x: (it.x - cam.x) * k, y: (it.y - cam.y) * k, r: it.r * k, reach: it.reach * k })), camera: { x: 0, y: 0, h: 1 } };
+    }
     const ids = p.items.map((item) => item.body);
     const sizes = sizesFor(ids, p.scale);
     const grouped = groups(p.items, p.moons);
@@ -561,7 +692,7 @@ export function decodeScene(text) {
 }
 const fromList = (ids, change = {}) => ids.reduce((p, id) => addBody(p, id), { ...defaultPortrait(), ...change });
 /**
- * Ready-made scenes to start from: a family photo of the Sun and the planets, the gas giants to scale, Jupiter and the Galileans, and the Earth and the Moon to scale.
+ * Ready-made scenes to start from: a family photo of the Sun and the planets, the gas giants to scale, Jupiter and the Galileans, the Earth and the Moon to scale (size and distance), Mars and its moons at their true distance, and the inner planets round the Sun.
  *
  * @example
  * ```ts
@@ -574,5 +705,7 @@ export const PRESETS = [
     { id: "family", name: { en: "Family photo", ja: "家族写真" }, scene: fromList(["sun", ...PLANET_IDS], { arrange: "arc", scale: "readable", moons: "manual", orbits: false }) },
     { id: "giants", name: { en: "Gas giants", ja: "巨大ガス惑星" }, scene: fromList(["jupiter", "saturn", "uranus", "neptune"], { arrange: "row", scale: "true", moons: "manual", bg: "gradient" }) },
     { id: "galileans", name: { en: "Jupiter and the Galileans", ja: "木星とガリレオ衛星" }, scene: fromList(["jupiter", "io", "europa", "ganymede", "callisto"], { arrange: "row", scale: "readable", moons: "auto", orbits: true }) },
-    { id: "earthmoon", name: { en: "Earth and Moon to scale", ja: "地球と月 (大きさの比)" }, scene: fromList(["earth", "moon"], { arrange: "row", scale: "true", moons: "auto", orbits: true }) },
+    { id: "earthmoon", name: { en: "Earth and Moon to scale", ja: "地球と月 (大きさと距離の比)" }, scene: fromList(["earth", "moon"], { arrange: "orbit", scale: "true", moons: "auto", orbits: true }) },
+    { id: "marsmoons", name: { en: "Mars and its moons at true distance", ja: "火星と衛星 (本当の距離)" }, scene: fromList(["mars", "phobos", "deimos"], { arrange: "orbit", scale: "readable", moons: "auto", orbits: true }) },
+    { id: "orrery", name: { en: "The inner planets round the Sun", ja: "太陽と内側の惑星 (本当の距離)" }, scene: fromList(["sun", "mercury", "venus", "earth", "mars"], { arrange: "orbit", scale: "readable", moons: "auto", orbits: true, bg: "black" }) },
 ];

package/dist/portrait/overlay.js

@@ -64,8 +64,9 @@ export function shapesOf(p, resolved, width, height, lang = "en", edit) {
     const out = { circles: [], lines: [], texts: [] };
     const byBody = new Map(resolved.placed.map((q) => [q.body, q]));
     if (p.orbits) {
+        const sun = p.arrange === "orbit" ? byBody.get("sun") : undefined;
         for (const moon of resolved.placed) {
-            const host = BODIES[moon.body].parent === undefined ? undefined : byBody.get(BODIES[moon.body].parent);
+            const host = BODIES[moon.body].parent === undefined ? (moon.body === "sun" ? undefined : sun) : byBody.get(BODIES[moon.body].parent);
             if (host === undefined)
                 continue;
             const d = Math.hypot(moon.x - host.x, moon.y - host.y) * at.scale;

package/dist/pose.d.ts

@@ -50,12 +50,14 @@ export declare const drawnTilt: (facts: BodyFacts) => number;
  * ```
  */
 export declare function portrait(id: BodyId, options?: PortraitOptions): Pose;
-/** A longitude and latitude (degrees) as a point on the body, in the viewer's frame (unit radius): x right, y up, z toward the viewer. The flattening squeezes it along the pole. */
-export declare function surfacePoint(pose: Pose, lon: number, lat: number, flattening?: number): Vec3;
+/** The semi-axes of a body that is not a spheroid, as fractions of its radius: along its longitude 0, along its east and along its pole. */
+export type Axes = readonly [number, number, number];
+/** A longitude and latitude (degrees) as a point on the body, in the viewer's frame (unit radius): x right, y up, z toward the viewer. The flattening squeezes it along the pole; `axes` shape a triaxial body instead. */
+export declare function surfacePoint(pose: Pose, lon: number, lat: number, flattening?: number, axes?: Axes): Vec3;
 /** The outward normal's z at a longitude and latitude: positive when that point faces the viewer. */
-export declare function facing(pose: Pose, lon: number, lat: number, flattening?: number): number;
-/** The silhouette of a body: its half-width, half-height along the pole's direction and the angle of the pole from straight up, clockwise, in degrees. */
-export declare function silhouette(pose: Pose, flattening: number): {
+export declare function facing(pose: Pose, lon: number, lat: number, flattening?: number, axes?: Axes): number;
+/** The silhouette of a body: its half-width, half-height along the pole's direction and the angle of the pole from straight up, clockwise, in degrees. With `axes` it is the outline of a triaxial body: its long half-width, its short one and the angle of the long one from straight right, clockwise. */
+export declare function silhouette(pose: Pose, flattening: number, axes?: Axes): {
     a: number;
     b: number;
     angle: number;

package/dist/pose.js

@@ -43,26 +43,40 @@ export function portrait(id, options = {}) {
     const light = unit([-Math.sin(phase) * Math.cos(lift), Math.sin(lift), Math.cos(phase) * Math.cos(lift)]);
     return { pole, meridian, light };
 }
-/** A longitude and latitude (degrees) as a point on the body, in the viewer's frame (unit radius): x right, y up, z toward the viewer. The flattening squeezes it along the pole. */
-export function surfacePoint(pose, lon, lat, flattening = 0) {
+/** A longitude and latitude (degrees) as a point on the body, in the viewer's frame (unit radius): x right, y up, z toward the viewer. The flattening squeezes it along the pole; `axes` shape a triaxial body instead. */
+export function surfacePoint(pose, lon, lat, flattening = 0, axes) {
     const cl = Math.cos(lat * RAD);
     const east = cross(pose.pole, pose.meridian);
-    const x = cl * Math.cos(lon * RAD);
-    const y = cl * Math.sin(lon * RAD);
-    const z = Math.sin(lat * RAD) * (1 - flattening);
+    const x = cl * Math.cos(lon * RAD) * (axes?.[0] ?? 1);
+    const y = cl * Math.sin(lon * RAD) * (axes?.[1] ?? 1);
+    const z = Math.sin(lat * RAD) * (axes?.[2] ?? 1 - flattening);
     return [pose.meridian[0] * x + east[0] * y + pose.pole[0] * z, pose.meridian[1] * x + east[1] * y + pose.pole[1] * z, pose.meridian[2] * x + east[2] * y + pose.pole[2] * z];
 }
 /** The outward normal's z at a longitude and latitude: positive when that point faces the viewer. */
-export function facing(pose, lon, lat, flattening = 0) {
+export function facing(pose, lon, lat, flattening = 0, axes) {
     const cl = Math.cos(lat * RAD);
     const east = cross(pose.pole, pose.meridian);
-    const x = cl * Math.cos(lon * RAD);
-    const y = cl * Math.sin(lon * RAD);
-    const z = Math.sin(lat * RAD) / (1 - flattening);
+    const x = (cl * Math.cos(lon * RAD)) / (axes?.[0] ?? 1);
+    const y = (cl * Math.sin(lon * RAD)) / (axes?.[1] ?? 1);
+    const z = Math.sin(lat * RAD) / (axes?.[2] ?? 1 - flattening);
     return pose.meridian[2] * x + east[2] * y + pose.pole[2] * z;
 }
-/** The silhouette of a body: its half-width, half-height along the pole's direction and the angle of the pole from straight up, clockwise, in degrees. */
-export function silhouette(pose, flattening) {
+/** The silhouette of a body: its half-width, half-height along the pole's direction and the angle of the pole from straight up, clockwise, in degrees. With `axes` it is the outline of a triaxial body: its long half-width, its short one and the angle of the long one from straight right, clockwise. */
+export function silhouette(pose, flattening, axes) {
+    if (axes !== undefined) {
+        const east = cross(pose.pole, pose.meridian);
+        const cols = [
+            [pose.meridian[0] * axes[0], pose.meridian[1] * axes[0]],
+            [east[0] * axes[1], east[1] * axes[1]],
+            [pose.pole[0] * axes[2], pose.pole[1] * axes[2]],
+        ];
+        const sxx = cols.reduce((t, c) => t + c[0] * c[0], 0);
+        const syy = cols.reduce((t, c) => t + c[1] * c[1], 0);
+        const sxy = cols.reduce((t, c) => t + c[0] * c[1], 0);
+        const mean = (sxx + syy) / 2;
+        const spread = Math.sqrt(((sxx - syy) / 2) ** 2 + sxy * sxy);
+        return { a: Math.sqrt(mean + spread), b: Math.sqrt(Math.max(0, mean - spread)), angle: -0.5 * Math.atan2(2 * sxy, sxx - syy) * DEG };
+    }
     const c = 1 - flattening;
     const s = pose.pole[2];
     return { a: 1, b: Math.sqrt(c * c * (1 - s * s) + s * s), angle: Math.atan2(pose.pole[0], pose.pole[1]) * DEG };

package/dist/scene/glsl.d.ts

@@ -1,6 +1,6 @@
 export declare const VERTEX = "\nvarying vec3 vObj;\nvarying vec3 vN;\nvarying vec3 vW;\nvoid main() {\n  vObj = vec3(position.z, position.x, position.y);\n  vN = normalize(normalMatrix * normal);\n  vec4 w = modelMatrix * vec4(position, 1.0);\n  vW = w.xyz;\n  gl_Position = projectionMatrix * viewMatrix * w;\n}";
 /** Noise, craters and the band palette, for the surface code of a body to call. */
-export declare const PRELUDE = "\nfloat hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nvec3 hash33(vec3 p) { p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.xxy + p.yxx) * p.zyx); }\nfloat vnoise(vec3 p) {\n  vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(mix(hash13(i), hash13(i + vec3(1,0,0)), f.x), mix(hash13(i + vec3(0,1,0)), hash13(i + vec3(1,1,0)), f.x), f.y),\n             mix(mix(hash13(i + vec3(0,0,1)), hash13(i + vec3(1,0,1)), f.x), mix(hash13(i + vec3(0,1,1)), hash13(i + vec3(1,1,1)), f.x), f.y), f.z);\n}\nfloat fbm(vec3 p) { float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * vnoise(p); p = p * 2.03 + vec3(1.7, 9.2, 3.1); a *= 0.5; } return s; }\n// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl.\nfloat craters(vec3 p, float freq, float amp, float seed) {\n  vec3 q = p * freq + seed; vec3 ip = floor(q); float h = 0.0;\n  for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) {\n    vec3 c = ip + vec3(float(x), float(y), float(z));\n    float on = step(0.52, hash13(c + 3.7));\n    vec3 ctr = c + hash33(c);\n    float rad = mix(0.12, 0.36, hash13(c + 17.3));\n    float d = length(q - ctr) / rad;\n    float bowl = d < 1.0 ? (d * d - 1.0) : 0.0;\n    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 : 0.0;\n    h += on * amp * rad * (bowl + rim);\n  }\n  return h;\n}\nfloat lon(vec3 p) { return atan(p.y, p.x); }\nfloat lat(vec3 p) { return asin(clamp(p.z, -1.0, 1.0)); }\nfloat wrapPi(float a) { return a - 6.2831853 * floor((a + 3.1415927) / 6.2831853); }\nvec3 dirOf(float lonDeg, float latDeg) { float lo = radians(lonDeg); float la = radians(latDeg); return vec3(cos(la) * cos(lo), cos(la) * sin(lo), sin(la)); }\n// One big round bowl with a rim, by longitude, latitude and angular radius in degrees. Negative inside.\nfloat bowl(vec3 p, float lonDeg, float latDeg, float radDeg, float depth) {\n  float d = acos(clamp(dot(p, dirOf(lonDeg, latDeg)), -1.0, 1.0)) / radians(radDeg);\n  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3;\n}\n// A soft oval on the body, 1 inside and 0 outside, by longitude and latitude in degrees.\nfloat oval(vec3 p, float lon0, float lat0, float rx, float ry, float soft) {\n  float dx = wrapPi(lon(p) - radians(lon0)) * cos(radians(lat0)) / radians(rx);\n  float dy = (lat(p) - radians(lat0)) / radians(ry);\n  return 1.0 - smoothstep(1.0 - soft, 1.0, sqrt(dx * dx + dy * dy));\n}";
+export declare const PRELUDE = "\nfloat hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nvec3 hash33(vec3 p) { p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.xxy + p.yxx) * p.zyx); }\nfloat vnoise(vec3 p) {\n  vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(mix(hash13(i), hash13(i + vec3(1,0,0)), f.x), mix(hash13(i + vec3(0,1,0)), hash13(i + vec3(1,1,0)), f.x), f.y),\n             mix(mix(hash13(i + vec3(0,0,1)), hash13(i + vec3(1,0,1)), f.x), mix(hash13(i + vec3(0,1,1)), hash13(i + vec3(1,1,1)), f.x), f.y), f.z);\n}\n// Noise that knows how big a pixel is: an octave finer than the pixel can show is replaced by its average (0.5) instead of being sampled, so a small body is smooth and not a spray of pixel-sized specks.\nfloat fbm(vec3 p) { float fw = length(fwidth(p)); float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * mix(0.5, vnoise(p), 1.0 - smoothstep(0.3, 0.7, fw)); p = p * 2.03 + vec3(1.7, 9.2, 3.1); fw *= 2.03; a *= 0.5; } return s; }\n// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl. A crater smaller than about two pixels fades out (it would only be noise).\nfloat craters(vec3 p, float freq, float amp, float seed) {\n  vec3 q = p * freq + seed; vec3 ip = floor(q); float h = 0.0;\n  float fw = length(fwidth(q));\n  for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) {\n    vec3 c = ip + vec3(float(x), float(y), float(z));\n    float on = step(0.52, hash13(c + 3.7));\n    vec3 ctr = c + hash33(c);\n    float rad = mix(0.12, 0.36, hash13(c + 17.3));\n    float d = length(q - ctr) / rad;\n    float bowl = d < 1.0 ? (d * d - 1.0) : 0.0;\n    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d) : 0.0;\n    h += on * amp * rad * (bowl + rim) * (1.0 - smoothstep(0.35, 0.9, fw / rad));\n  }\n  return h;\n}\nfloat lon(vec3 p) { return atan(p.y, p.x); }\nfloat lat(vec3 p) { return asin(clamp(p.z, -1.0, 1.0)); }\nfloat wrapPi(float a) { return a - 6.2831853 * floor((a + 3.1415927) / 6.2831853); }\nvec3 dirOf(float lonDeg, float latDeg) { float lo = radians(lonDeg); float la = radians(latDeg); return vec3(cos(la) * cos(lo), cos(la) * sin(lo), sin(la)); }\n// One big round bowl with a rim, by longitude, latitude and angular radius in degrees. Negative inside.\nfloat bowl(vec3 p, float lonDeg, float latDeg, float radDeg, float depth) {\n  float d = acos(clamp(dot(p, dirOf(lonDeg, latDeg)), -1.0, 1.0)) / radians(radDeg);\n  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d);\n}\n// A soft oval on the body, 1 inside and 0 outside, by longitude and latitude in degrees.\nfloat oval(vec3 p, float lon0, float lat0, float rx, float ry, float soft) {\n  float dx = wrapPi(lon(p) - radians(lon0)) * cos(radians(lat0)) / radians(rx);\n  float dy = (lat(p) - radians(lat0)) / radians(ry);\n  return 1.0 - smoothstep(1.0 - soft, 1.0, sqrt(dx * dx + dy * dy));\n}";
 /** The fragment shader of a body: the surface code goes between the prelude and `main`. */
 export declare function bodyFragment(surface: string, painted: boolean, world?: boolean): string;
 /** A painted body's surface code: the map by longitude and latitude, with the seam at 180 degrees left alone. */
@@ -19,4 +19,4 @@ export declare const RING_FRAGMENT_WORLD: string;
 export declare const GLOW_VERTEX = "\nvarying vec2 vP;\nvoid main() { vP = position.xy; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }";
 export declare const GLOW_FRAGMENT = "\nprecision highp float;\nvarying vec2 vP;\nuniform vec3 uColour;\nvoid main() {\n  float r = length(vP);\n  if (r < 0.98) discard;\n  float a = exp(-(r - 1.0) * 2.4) * 0.62;\n  float streak = 0.82 + 0.18 * sin(atan(vP.y, vP.x) * 9.0 + r * 3.0);\n  a *= streak * smoothstep(3.0, 1.6, r);\n  gl_FragColor = vec4(uColour * a, a);\n}";
 /** A cheap lit ball for a moon seen small beside its planet. */
-export declare const BALL_FRAGMENT = "\nprecision highp float;\nuniform vec3 uLight;\nuniform vec3 uColour;\nvarying vec3 vObj;\nvarying vec3 vN;\nvarying vec3 vW;\n\nfloat hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nvec3 hash33(vec3 p) { p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.xxy + p.yxx) * p.zyx); }\nfloat vnoise(vec3 p) {\n  vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(mix(hash13(i), hash13(i + vec3(1,0,0)), f.x), mix(hash13(i + vec3(0,1,0)), hash13(i + vec3(1,1,0)), f.x), f.y),\n             mix(mix(hash13(i + vec3(0,0,1)), hash13(i + vec3(1,0,1)), f.x), mix(hash13(i + vec3(0,1,1)), hash13(i + vec3(1,1,1)), f.x), f.y), f.z);\n}\nfloat fbm(vec3 p) { float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * vnoise(p); p = p * 2.03 + vec3(1.7, 9.2, 3.1); a *= 0.5; } return s; }\n// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl.\nfloat craters(vec3 p, float freq, float amp, float seed) {\n  vec3 q = p * freq + seed; vec3 ip = floor(q); float h = 0.0;\n  for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) {\n    vec3 c = ip + vec3(float(x), float(y), float(z));\n    float on = step(0.52, hash13(c + 3.7));\n    vec3 ctr = c + hash33(c);\n    float rad = mix(0.12, 0.36, hash13(c + 17.3));\n    float d = length(q - ctr) / rad;\n    float bowl = d < 1.0 ? (d * d - 1.0) : 0.0;\n    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 : 0.0;\n    h += on * amp * rad * (bowl + rim);\n  }\n  return h;\n}\nfloat lon(vec3 p) { return atan(p.y, p.x); }\nfloat lat(vec3 p) { return asin(clamp(p.z, -1.0, 1.0)); }\nfloat wrapPi(float a) { return a - 6.2831853 * floor((a + 3.1415927) / 6.2831853); }\nvec3 dirOf(float lonDeg, float latDeg) { float lo = radians(lonDeg); float la = radians(latDeg); return vec3(cos(la) * cos(lo), cos(la) * sin(lo), sin(la)); }\n// One big round bowl with a rim, by longitude, latitude and angular radius in degrees. Negative inside.\nfloat bowl(vec3 p, float lonDeg, float latDeg, float radDeg, float depth) {\n  float d = acos(clamp(dot(p, dirOf(lonDeg, latDeg)), -1.0, 1.0)) / radians(radDeg);\n  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3;\n}\n// A soft oval on the body, 1 inside and 0 outside, by longitude and latitude in degrees.\nfloat oval(vec3 p, float lon0, float lat0, float rx, float ry, float soft) {\n  float dx = wrapPi(lon(p) - radians(lon0)) * cos(radians(lat0)) / radians(rx);\n  float dy = (lat(p) - radians(lat0)) / radians(ry);\n  return 1.0 - smoothstep(1.0 - soft, 1.0, sqrt(dx * dx + dy * dy));\n}\nvoid main() {\n  vec3 n = normalize(vN);\n  float shade = 0.82 + 0.3 * (fbm(normalize(vObj) * 4.0) - 0.5);\n  float diff = max(dot(n, uLight), 0.0);\n  vec3 c = pow(uColour * shade, vec3(2.2)) * (0.04 + 1.1 * diff);\n  gl_FragColor = vec4(pow(c, vec3(1.0 / 2.2)), 1.0);\n}";
+export declare const BALL_FRAGMENT = "\nprecision highp float;\nuniform vec3 uLight;\nuniform vec3 uColour;\nvarying vec3 vObj;\nvarying vec3 vN;\nvarying vec3 vW;\n\nfloat hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nvec3 hash33(vec3 p) { p = fract(p * vec3(0.1031, 0.1030, 0.0973)); p += dot(p, p.yxz + 33.33); return fract((p.xxy + p.yxx) * p.zyx); }\nfloat vnoise(vec3 p) {\n  vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n  return mix(mix(mix(hash13(i), hash13(i + vec3(1,0,0)), f.x), mix(hash13(i + vec3(0,1,0)), hash13(i + vec3(1,1,0)), f.x), f.y),\n             mix(mix(hash13(i + vec3(0,0,1)), hash13(i + vec3(1,0,1)), f.x), mix(hash13(i + vec3(0,1,1)), hash13(i + vec3(1,1,1)), f.x), f.y), f.z);\n}\n// Noise that knows how big a pixel is: an octave finer than the pixel can show is replaced by its average (0.5) instead of being sampled, so a small body is smooth and not a spray of pixel-sized specks.\nfloat fbm(vec3 p) { float fw = length(fwidth(p)); float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * mix(0.5, vnoise(p), 1.0 - smoothstep(0.3, 0.7, fw)); p = p * 2.03 + vec3(1.7, 9.2, 3.1); fw *= 2.03; a *= 0.5; } return s; }\n// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl. A crater smaller than about two pixels fades out (it would only be noise).\nfloat craters(vec3 p, float freq, float amp, float seed) {\n  vec3 q = p * freq + seed; vec3 ip = floor(q); float h = 0.0;\n  float fw = length(fwidth(q));\n  for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) {\n    vec3 c = ip + vec3(float(x), float(y), float(z));\n    float on = step(0.52, hash13(c + 3.7));\n    vec3 ctr = c + hash33(c);\n    float rad = mix(0.12, 0.36, hash13(c + 17.3));\n    float d = length(q - ctr) / rad;\n    float bowl = d < 1.0 ? (d * d - 1.0) : 0.0;\n    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d) : 0.0;\n    h += on * amp * rad * (bowl + rim) * (1.0 - smoothstep(0.35, 0.9, fw / rad));\n  }\n  return h;\n}\nfloat lon(vec3 p) { return atan(p.y, p.x); }\nfloat lat(vec3 p) { return asin(clamp(p.z, -1.0, 1.0)); }\nfloat wrapPi(float a) { return a - 6.2831853 * floor((a + 3.1415927) / 6.2831853); }\nvec3 dirOf(float lonDeg, float latDeg) { float lo = radians(lonDeg); float la = radians(latDeg); return vec3(cos(la) * cos(lo), cos(la) * sin(lo), sin(la)); }\n// One big round bowl with a rim, by longitude, latitude and angular radius in degrees. Negative inside.\nfloat bowl(vec3 p, float lonDeg, float latDeg, float radDeg, float depth) {\n  float d = acos(clamp(dot(p, dirOf(lonDeg, latDeg)), -1.0, 1.0)) / radians(radDeg);\n  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d);\n}\n// A soft oval on the body, 1 inside and 0 outside, by longitude and latitude in degrees.\nfloat oval(vec3 p, float lon0, float lat0, float rx, float ry, float soft) {\n  float dx = wrapPi(lon(p) - radians(lon0)) * cos(radians(lat0)) / radians(rx);\n  float dy = (lat(p) - radians(lat0)) / radians(ry);\n  return 1.0 - smoothstep(1.0 - soft, 1.0, sqrt(dx * dx + dy * dy));\n}\nvoid main() {\n  vec3 n = normalize(vN);\n  float shade = 0.82 + 0.3 * (fbm(normalize(vObj) * 4.0) - 0.5);\n  float diff = max(dot(n, uLight), 0.0);\n  vec3 c = pow(uColour * shade, vec3(2.2)) * (0.04 + 1.1 * diff);\n  gl_FragColor = vec4(pow(c, vec3(1.0 / 2.2)), 1.0);\n}";

package/dist/scene/glsl.js

@@ -19,10 +19,12 @@ float vnoise(vec3 p) {
   return mix(mix(mix(hash13(i), hash13(i + vec3(1,0,0)), f.x), mix(hash13(i + vec3(0,1,0)), hash13(i + vec3(1,1,0)), f.x), f.y),
              mix(mix(hash13(i + vec3(0,0,1)), hash13(i + vec3(1,0,1)), f.x), mix(hash13(i + vec3(0,1,1)), hash13(i + vec3(1,1,1)), f.x), f.y), f.z);
 }
-float fbm(vec3 p) { float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * vnoise(p); p = p * 2.03 + vec3(1.7, 9.2, 3.1); a *= 0.5; } return s; }
-// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl.
+// Noise that knows how big a pixel is: an octave finer than the pixel can show is replaced by its average (0.5) instead of being sampled, so a small body is smooth and not a spray of pixel-sized specks.
+float fbm(vec3 p) { float fw = length(fwidth(p)); float a = 0.5; float s = 0.0; for (int i = 0; i < 5; i++) { s += a * mix(0.5, vnoise(p), 1.0 - smoothstep(0.3, 0.7, fw)); p = p * 2.03 + vec3(1.7, 9.2, 3.1); fw *= 2.03; a *= 0.5; } return s; }
+// Craters: a bowl and a raised rim in each cell that has one. Returns a height, negative in a bowl. A crater smaller than about two pixels fades out (it would only be noise).
 float craters(vec3 p, float freq, float amp, float seed) {
   vec3 q = p * freq + seed; vec3 ip = floor(q); float h = 0.0;
+  float fw = length(fwidth(q));
   for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++) for (int z = -1; z <= 1; z++) {
     vec3 c = ip + vec3(float(x), float(y), float(z));
     float on = step(0.52, hash13(c + 3.7));
@@ -30,8 +32,8 @@ float craters(vec3 p, float freq, float amp, float seed) {
     float rad = mix(0.12, 0.36, hash13(c + 17.3));
     float d = length(q - ctr) / rad;
     float bowl = d < 1.0 ? (d * d - 1.0) : 0.0;
-    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 : 0.0;
-    h += on * amp * rad * (bowl + rim);
+    float rim = d >= 1.0 ? exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d) : 0.0;
+    h += on * amp * rad * (bowl + rim) * (1.0 - smoothstep(0.35, 0.9, fw / rad));
   }
   return h;
 }
@@ -42,7 +44,7 @@ vec3 dirOf(float lonDeg, float latDeg) { float lo = radians(lonDeg); float la =
 // One big round bowl with a rim, by longitude, latitude and angular radius in degrees. Negative inside.
 float bowl(vec3 p, float lonDeg, float latDeg, float radDeg, float depth) {
   float d = acos(clamp(dot(p, dirOf(lonDeg, latDeg)), -1.0, 1.0)) / radians(radDeg);
-  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3;
+  return d < 1.0 ? depth * (d * d - 1.0) : depth * exp(-pow((d - 1.0) * 5.0, 2.0)) * 0.3 * smoothstep(1.0, 1.08, d);
 }
 // A soft oval on the body, 1 inside and 0 outside, by longitude and latitude in degrees.
 float oval(vec3 p, float lon0, float lat0, float rx, float ry, float soft) {
@@ -90,7 +92,9 @@ void main() {
   float hx = dFdx(s.a); float hy = dFdy(s.a);
   vec3 grad = cross(dpy, n) * hx + cross(n, dpx) * hy;
   float det = dot(dpx, cross(dpy, n));
-  vec3 nb = normalize(abs(det) * n - sign(det) * uRelief * grad * 22.0);
+  // relief is worked out from differences between neighbouring pixels, which cannot show a bump only a few pixels wide: on a small disc it fades out and the colour alone carries the craters
+  float reliefLod = 1.0 - smoothstep(0.008, 0.024, length(fwidth(p)));
+  vec3 nb = normalize(abs(det) * n - sign(det) * uRelief * reliefLod * grad * 22.0);
   float d = dot(nb, uLight);
   float diff = clamp((d + uWrap) / (1.0 + uWrap), 0.0, 1.0) * smoothstep(-0.02 - uWrap * 0.6, 0.1 + uWrap * 0.8, dg);
   if (uRingOn > 0.5) {