@wildshard/shard-format 0.0.1 → 0.4.5

package/src/format/pageLife.ts

@@ -0,0 +1,303 @@
+import * as v from 'valibot';
+import { AmbientFlockSchema, AmbientPerchesSchema, ForagerPopulationSchema } from './ambientLife.ts';
+import { CrowdWeaponTargetSchema } from './crowds.ts';
+
+const id = v.pipe(v.string(), v.minLength(1), v.maxLength(128));
+const number = v.pipe(v.number(), v.finite());
+const nonnegative = v.pipe(number, v.minValue(0), v.maxValue(1000000));
+const count = v.pipe(nonnegative, v.integer(), v.maxValue(256));
+const range = v.pipe(v.tuple([number, number]), v.check(([lo, hi]) => lo <= hi));
+const system = v.strictObject({ id, after: v.array(id), before: v.array(id) });
+/** Client ambient ownership over actual flock, journal, tool and actor services.
+ * Rules are stateless ABI-v1 projections; no executable shard ports cross rows. */
+export const PageLifeSchema: v.GenericSchema<PageLifeRowsInput, PageLifeRows> = v.strictObject({
+  version: v.literal(1), seed: number, system,
+  draw: v.nullable(v.strictObject({ library: id, capacity: v.pipe(number, v.integer(), v.minValue(1), v.maxValue(512)), glow: range })),
+  flocks: v.pipe(v.array(v.strictObject({ id, row: AmbientFlockSchema, perches: AmbientPerchesSchema,
+    packed: v.boolean(), borrowed: v.boolean(), audio: v.picklist(['bank', 'cue']),
+    /** its own posed library (a named product file) instead of the page draw's, ticked about a fixed `anchor` instead of
+     *  the player, its instances tinted in order (`0xRRGGBB`): Driftwood's reef fish school */
+    library: v.exactOptional(id), anchor: v.exactOptional(v.strictObject({ x: number, y: number, z: number })),
+    tints: v.exactOptional(v.pipe(v.array(v.pipe(number, v.integer(), v.minValue(0), v.maxValue(0xffffff))), v.maxLength(256))) })), v.maxLength(16)),
+  foragers: v.pipe(v.array(v.strictObject({ row: ForagerPopulationSchema, model: number, scale: number,
+    alertRate: number, alertGain: number, sitPitch: number,
+    combat: v.exactOptional(v.strictObject({ target: CrowdWeaponTargetSchema, preyY: number,
+      hits: v.pipe(v.array(v.tuple([number, number, v.pipe(number, v.minValue(0.001), v.maxValue(20))])), v.minLength(1), v.maxLength(16)) })),
+  })), v.maxLength(16)),
+  program: v.exactOptional(v.strictObject({ script: v.unknown(), bytes: v.string() })),
+  carcasses: v.exactOptional(v.strictObject({ group: id, arrival: range, visitors: v.record(id, count),
+    bodyWidths: v.record(id, nonnegative), defaultWidth: nonnegative, defaultVisitors: count,
+    giveUp: nonnegative, reach: nonnegative, tint: nonnegative, untrackedAge: nonnegative, harvestDelay: nonnegative })),
+  guide: v.exactOptional(v.strictObject({ group: id, policy: v.strictObject({ distance: v.literal('centre'), min: nonnegative, max: nonnegative,
+    schedule: v.strictObject({ kind: v.literal('periodic'), initial: nonnegative, period: v.pipe(range, v.check(([lo]) => lo >= 0.1)) }) }), cue: id, gain: nonnegative })),
+  harvest: v.exactOptional(v.strictObject({ len: nonnegative, kneelIn: nonnegative, cuts: v.array(nonnegative), rise: nonnegative,
+    camera: v.strictObject({ down: number, targetY: number, defaultPitch: number, maxPitch: nonnegative }),
+    surface: v.picklist(['litter', 'sand', 'rock', 'grass', 'planks']), sounds: v.tuple([id, id]), gain: nonnegative,
+    kick: v.tuple([number, number]), fallbackSurface: v.picklist(['wood', 'ground', 'flesh']), fallbackPan: number, fallbackGain: number })),
+  debug: v.exactOptional(v.strictObject({ id, window: id, flocks: v.record(id, id), visitors: v.record(id, id), populations: v.record(id, id),
+    commands: v.record(id, v.strictObject({ operation: v.picklist(['visit', 'scavenge']), group: id })) })),
+});
+
+export function parsePageLife(input: unknown): PageLifeRows {
+  const rows = v.parse(PageLifeSchema, input), ids = new Set(rows.flocks.map(row => row.id));
+  const packed = rows.flocks.reduce((sum, row) => sum + (row.packed ? row.row.count : 0), 0)
+    + rows.foragers.reduce((sum, row) => sum + row.row.count, 0);
+  if (ids.size !== rows.flocks.length || rows.flocks.some(row => row.packed && row.borrowed || row.library !== undefined && (row.packed || row.borrowed))
+    || (rows.draw === null ? packed > 0 : packed > rows.draw.capacity)
+    || (rows.carcasses !== undefined || rows.guide !== undefined) && rows.program === undefined
+    || rows.carcasses !== undefined && !rows.flocks.some(row => row.id === rows.carcasses?.group && row.row.scavenge !== null)
+    || rows.guide !== undefined && !rows.flocks.some(row => row.id === rows.guide?.group && row.row.guide !== null)) throw new Error('Invalid ambient ownership rows');
+  if (rows.debug !== undefined && [...Object.values(rows.debug.flocks), ...Object.values(rows.debug.visitors),
+    ...Object.values(rows.debug.commands).map(row => row.group)].some(name => !ids.has(name))) throw new Error('Unknown ambient debug group');
+  return rows;
+}
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+interface PageLifeRowsInputFields {
+    version: 1;
+    seed: number;
+    system: {
+        id: string;
+        after: (string)[];
+        before: (string)[];
+    };
+    draw: ({
+        library: string;
+        capacity: number;
+        glow: [
+            number,
+            number
+        ];
+    }) | null;
+    flocks: ({
+        id: string;
+        row: v.InferInput<typeof AmbientFlockSchema>;
+        perches: v.InferInput<typeof AmbientPerchesSchema>;
+        packed: boolean;
+        borrowed: boolean;
+        audio: 'bank' | 'cue';
+        library?: string;
+        anchor?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        tints?: (number)[];
+    })[];
+    foragers: ({
+        row: v.InferInput<typeof ForagerPopulationSchema>;
+        model: number;
+        scale: number;
+        alertRate: number;
+        alertGain: number;
+        sitPitch: number;
+        combat?: {
+            target: v.InferInput<typeof CrowdWeaponTargetSchema>;
+            preyY: number;
+            hits: ([
+                number,
+                number,
+                number
+            ])[];
+        };
+    })[];
+    program?: {
+        script: unknown;
+        bytes: string;
+    };
+    carcasses?: {
+        group: string;
+        arrival: [
+            number,
+            number
+        ];
+        visitors: Record<string, number>;
+        bodyWidths: Record<string, number>;
+        defaultWidth: number;
+        defaultVisitors: number;
+        giveUp: number;
+        reach: number;
+        tint: number;
+        untrackedAge: number;
+        harvestDelay: number;
+    };
+    guide?: {
+        group: string;
+        policy: {
+            distance: 'centre';
+            min: number;
+            max: number;
+            schedule: {
+                kind: 'periodic';
+                initial: number;
+                period: [
+                    number,
+                    number
+                ];
+            };
+        };
+        cue: string;
+        gain: number;
+    };
+    harvest?: {
+        len: number;
+        kneelIn: number;
+        cuts: (number)[];
+        rise: number;
+        camera: {
+            down: number;
+            targetY: number;
+            defaultPitch: number;
+            maxPitch: number;
+        };
+        surface: 'litter' | 'sand' | 'rock' | 'grass' | 'planks';
+        sounds: [
+            string,
+            string
+        ];
+        gain: number;
+        kick: [
+            number,
+            number
+        ];
+        fallbackSurface: 'wood' | 'ground' | 'flesh';
+        fallbackPan: number;
+        fallbackGain: number;
+    };
+    debug?: {
+        id: string;
+        window: string;
+        flocks: Record<string, string>;
+        visitors: Record<string, string>;
+        populations: Record<string, string>;
+        commands: Record<string, {
+            operation: 'visit' | 'scavenge';
+            group: string;
+        }>;
+    };
+}
+export type PageLifeRowsInput = { [Key in keyof PageLifeRowsInputFields]: PageLifeRowsInputFields[Key] };
+interface PageLifeRowsFields {
+    version: 1;
+    seed: number;
+    system: {
+        id: string;
+        after: (string)[];
+        before: (string)[];
+    };
+    draw: ({
+        library: string;
+        capacity: number;
+        glow: [
+            number,
+            number
+        ];
+    }) | null;
+    flocks: ({
+        id: string;
+        row: v.InferOutput<typeof AmbientFlockSchema>;
+        perches: v.InferOutput<typeof AmbientPerchesSchema>;
+        packed: boolean;
+        borrowed: boolean;
+        audio: 'bank' | 'cue';
+        library?: string;
+        anchor?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        tints?: (number)[];
+    })[];
+    foragers: ({
+        row: v.InferOutput<typeof ForagerPopulationSchema>;
+        model: number;
+        scale: number;
+        alertRate: number;
+        alertGain: number;
+        sitPitch: number;
+        combat?: {
+            target: v.InferOutput<typeof CrowdWeaponTargetSchema>;
+            preyY: number;
+            hits: ([
+                number,
+                number,
+                number
+            ])[];
+        };
+    })[];
+    program?: {
+        script: unknown;
+        bytes: string;
+    };
+    carcasses?: {
+        group: string;
+        arrival: [
+            number,
+            number
+        ];
+        visitors: Record<string, number>;
+        bodyWidths: Record<string, number>;
+        defaultWidth: number;
+        defaultVisitors: number;
+        giveUp: number;
+        reach: number;
+        tint: number;
+        untrackedAge: number;
+        harvestDelay: number;
+    };
+    guide?: {
+        group: string;
+        policy: {
+            distance: 'centre';
+            min: number;
+            max: number;
+            schedule: {
+                kind: 'periodic';
+                initial: number;
+                period: [
+                    number,
+                    number
+                ];
+            };
+        };
+        cue: string;
+        gain: number;
+    };
+    harvest?: {
+        len: number;
+        kneelIn: number;
+        cuts: (number)[];
+        rise: number;
+        camera: {
+            down: number;
+            targetY: number;
+            defaultPitch: number;
+            maxPitch: number;
+        };
+        surface: 'litter' | 'sand' | 'rock' | 'grass' | 'planks';
+        sounds: [
+            string,
+            string
+        ];
+        gain: number;
+        kick: [
+            number,
+            number
+        ];
+        fallbackSurface: 'wood' | 'ground' | 'flesh';
+        fallbackPan: number;
+        fallbackGain: number;
+    };
+    debug?: {
+        id: string;
+        window: string;
+        flocks: Record<string, string>;
+        visitors: Record<string, string>;
+        populations: Record<string, string>;
+        commands: Record<string, {
+            operation: 'visit' | 'scavenge';
+            group: string;
+        }>;
+    };
+}
+export type PageLifeRows = { [Key in keyof PageLifeRowsFields]: PageLifeRowsFields[Key] };

package/src/format/pagePreparation.ts

@@ -0,0 +1,60 @@
+import * as v from 'valibot';
+import { isJsonData } from './json.ts';
+
+const n = v.pipe(v.number(), v.finite()), id = v.pipe(v.string(), v.minLength(1), v.maxLength(512));
+/** A generated cave cut consists of physics rectangles and triangle-AABB holes. */
+export const PageTerrainCutSchema: v.GenericSchema<PageTerrainCutRowsInput, PageTerrainCutRows> = v.pipe(v.unknown(), v.check(isJsonData), v.strictObject({
+  frame: v.strictObject({ x: n, z: n, yaw: n }),
+  cuts: v.pipe(v.array(v.strictObject({ lx: n, lz: n, hw: n, hd: n, below: n })), v.maxLength(128)),
+  holes: v.pipe(v.array(v.strictObject({ lx: n, lz: n, hw: n, hd: n, y0: n, y1: n })), v.maxLength(128)),
+}));
+
+/** Material bindings over a real engine pond surface and its probe. */
+export const PageWaterBindingSchema: v.GenericSchema<PageWaterBindingRowsInput, PageWaterBindingRows> = v.strictObject({ object: id, look: id, looks: v.pipe(v.array(id), v.maxLength(8)),
+  ripples: id, skyline: id, centre: id, probe: id });
+
+/** Native path ramps use the bound floor and registered deck carriers. */
+export const PagePathRampSchema: v.GenericSchema<PagePathRampRowsInput, PagePathRampRows> = v.strictObject({ id, name: id });
+
+/** Admitted data contracts, independent of validator implementation metadata. */
+export type PageTerrainCutRowsInput = unknown;
+interface PageTerrainCutRowsFields {
+    frame: {
+        x: number;
+        z: number;
+        yaw: number;
+    };
+    cuts: ({
+        lx: number;
+        lz: number;
+        hw: number;
+        hd: number;
+        below: number;
+    })[];
+    holes: ({
+        lx: number;
+        lz: number;
+        hw: number;
+        hd: number;
+        y0: number;
+        y1: number;
+    })[];
+}
+export type PageTerrainCutRows = { [Key in keyof PageTerrainCutRowsFields]: PageTerrainCutRowsFields[Key] };
+export type PageWaterBindingRowsInput = PageWaterBindingRows;
+interface PageWaterBindingRowsFields {
+    object: string;
+    look: string;
+    looks: (string)[];
+    ripples: string;
+    skyline: string;
+    centre: string;
+    probe: string;
+}
+export type PageWaterBindingRows = { [Key in keyof PageWaterBindingRowsFields]: PageWaterBindingRowsFields[Key] };
+export type PagePathRampRowsInput = PagePathRampRows;
+interface PagePathRampRowsFields {
+    id: string;
+    name: string;
+}
+export type PagePathRampRows = { [Key in keyof PagePathRampRowsFields]: PagePathRampRowsFields[Key] };

package/src/format/paintedLook.ts

@@ -0,0 +1,55 @@
+import * as v from 'valibot';
+import { CurveSchema } from './materials.ts';
+import { isJsonData } from './json.ts';
+
+const scalar = v.pipe(v.number(), v.finite()), rgb = v.tuple([scalar, scalar, scalar]), pair = v.tuple([scalar, scalar]);
+const colour = v.union([scalar, rgb]);
+const painterRow = v.object({ bounce: rgb, bounceLift: scalar, rim: rgb, floor: rgb, prefix: v.string(), optOut: v.string(),
+  rimBack: v.exactOptional(pair), rimSide: v.exactOptional(pair), lift: v.exactOptional(rgb) });
+const clockRow = v.object({ units: v.picklist(['hour', 'phase']), start: scalar,
+  schedule: v.array(v.object({ phase: v.picklist(['dawn', 'day', 'golden', 'dusk', 'night']), from: scalar, to: scalar, minutes: scalar })),
+  sun: v.object({ maxElevation: scalar, azimuthOffset: scalar }), fixed: v.object({ midday: scalar, golden: scalar, sunset: scalar, night: scalar }),
+  presets: v.object({ dawn: scalar, noon: scalar, dusk: scalar, night: scalar }), dayFraction: v.exactOptional(scalar), pauseOnPin: v.exactOptional(v.boolean()) });
+const stripRow = v.object({ name: v.string(), maps: v.tuple([v.string(), v.string()]), elevation: pair, window: pair, firstGain: pair, hold: scalar,
+  strips: v.tuple([v.object({ key: v.string(), url: v.string() }), v.object({ key: v.string(), url: v.string() })]), tag: v.string(), fault: v.string(), scope: v.string() });
+const hazeRow = v.object({ strip: v.array(scalar), tint: rgb, near: scalar, far: scalar, max: scalar, sunHaze: scalar, name: v.string(), prefix: v.string() });
+const duskRow = v.object({ fog: v.object({ color: scalar, near: scalar, far: scalar }), clock: clockRow,
+  sun: v.object({ dir: v.object({ x: scalar, y: scalar, z: scalar }), colour, intensity: scalar }), light: painterRow, lightScope: v.picklist(['page', 'material']),
+  hold: v.exactOptional(v.boolean()), neutral: v.exactOptional(v.boolean()), horizon: v.exactOptional(scalar),
+  rays: v.exactOptional(v.object({ azimuth: scalar, elevation: scalar })),
+  state: v.exactOptional(v.object({ deep: colour, curves: v.object({ key: CurveSchema, fill: CurveSchema, fogSun: CurveSchema, farHaze: CurveSchema, aerialFog: CurveSchema }) })),
+  sky: v.variant('kind', [v.object({ kind: v.literal('strips'), row: stripRow }), v.object({ kind: v.literal('haze'), row: hazeRow })]) });
+
+/** Numeric painted light, fog, clock and sky contract shared by page and material looks. */
+export const PaintedNumbersSchema: v.GenericSchema<PaintedNumbersInput, PaintedNumbers> = duskRow;
+
+const id = v.pipe(v.string(), v.minLength(1), v.maxLength(256));
+const sampler = v.strictObject({ release: v.exactOptional(v.boolean()), wrapS: v.exactOptional(v.picklist([1000,1001,1002])), wrapT: v.exactOptional(v.picklist([1000,1001,1002])), mips: v.exactOptional(v.boolean()), minFilter: v.exactOptional(v.picklist([1003,1004,1005,1006,1007,1008])), magFilter: v.exactOptional(v.picklist([1003,1006])), anisotropy: v.exactOptional(scalar) });
+const image = v.strictObject({ url: id, name: id, warn: id, sampler });
+const tierImage = v.union([image, v.strictObject({ phone: image, desktop: image })]);
+const width=v.pipe(scalar,v.integer(),v.minValue(1),v.maxValue(4));
+/** Raw attribute counts are float32 components, bounded by the original inline byte ceiling. */
+const attributes = v.pipe(v.record(id,v.union([v.strictObject({size:width,float32:v.pipe(v.string(),v.maxLength(262144))}),
+  v.pipe(v.strictObject({size:width,count:v.pipe(scalar,v.integer(),v.minValue(0),v.maxValue(49152)),file:id}),v.check(row=>row.count%row.size===0))])),v.maxEntries(16),
+  v.check(rows=>{const counts=Object.values(rows).flatMap(row=>'file'in row?[row.count/row.size]:[]);return counts.every(count=>count===counts[0]);}));
+const draw = v.strictObject({ name: id, graph: id, image: v.exactOptional(id), order: scalar, at: v.optional(v.tuple([scalar,scalar,scalar]), [0,0,0]), spin: v.optional(scalar, 0),
+  geometry: v.variant('kind', [v.strictObject({ kind: v.literal('disc'), radius: v.pipe(scalar,v.minValue(.001)), segments: v.pipe(scalar,v.integer(),v.minValue(3),v.maxValue(1024)) }),
+    v.strictObject({ kind: v.literal('plane'), size: pair, instances: v.exactOptional(attributes) })]) });
+/** Client-only product presentation. Graph ids resolve from look.materials; no executable resource ports cross admission. */
+export const PaintedLookSchema: v.GenericSchema<PaintedLookRowInput, PaintedLookRow> = v.pipe(v.unknown(), v.check(isJsonData, 'Painted look requires plain JSON'), v.strictObject({ look: PaintedNumbersSchema, materialSun: v.exactOptional(v.strictObject({ x: scalar, y: scalar, z: scalar })), materialOptOut: v.exactOptional(id), state: v.exactOptional(id), lut: v.exactOptional(id),
+  terrain: v.exactOptional(v.literal('declared')),
+  images: v.optional(v.pipe(v.record(id,tierImage),v.maxEntries(16)), {}),
+  bumps: v.exactOptional(v.pipe(v.array(v.strictObject({ material: id, image: id, channel: v.picklist([0, 1, 2, 3]), scale: scalar })), v.maxLength(16))),
+  dome: v.exactOptional(v.strictObject({ graph: v.strictObject({phone:id,desktop:id}), image:id })),
+  dressing: v.exactOptional(v.strictObject({ name:id, draws:v.pipe(v.array(draw),v.maxLength(64)) })),
+}), v.check(row => (row.look.state === undefined) === (row.state === undefined) && (row.dome === undefined || row.images[row.dome.image] !== undefined)
+  && (row.bumps?.every(entry => row.images[entry.image] !== undefined) ?? true)
+  && (row.dressing?.draws.every(entry => entry.image === undefined || row.images[entry.image] !== undefined) ?? true), 'Declared state and image bindings'));
+
+export function parsePaintedLook(input: unknown): PaintedLookRow { return v.parse(PaintedLookSchema,input); }
+
+/** Admitted painted presentation data, independent of validator implementation metadata. */
+export interface PaintedNumbersInput { fog: { color: number; near: number; far: number; }; clock: { units: 'hour' | 'phase'; start: number; schedule: ({ phase: 'dawn' | 'day' | 'golden' | 'dusk' | 'night'; from: number; to: number; minutes: number; })[]; sun: { maxElevation: number; azimuthOffset: number; }; fixed: { midday: number; golden: number; sunset: number; night: number; }; presets: { dawn: number; noon: number; dusk: number; night: number; }; dayFraction?: number; pauseOnPin?: boolean; }; sun: { dir: { x: number; y: number; z: number; }; colour: (number) | ([number, number, number]); intensity: number; }; light: { bounce: [number, number, number]; bounceLift: number; rim: [number, number, number]; floor: [number, number, number]; prefix: string; optOut: string; rimBack?: [number, number]; rimSide?: [number, number]; lift?: [number, number, number]; }; lightScope: 'page' | 'material'; hold?: boolean; neutral?: boolean; horizon?: number; rays?: { azimuth: number; elevation: number; }; state?: { deep: (number) | ([number, number, number]); curves: { key: v.InferInput<typeof CurveSchema>; fill: v.InferInput<typeof CurveSchema>; fogSun: v.InferInput<typeof CurveSchema>; farHaze: v.InferInput<typeof CurveSchema>; aerialFog: v.InferInput<typeof CurveSchema>; }; }; sky: ({ kind: 'strips'; row: { name: string; maps: [string, string]; elevation: [number, number]; window: [number, number]; firstGain: [number, number]; hold: number; strips: [{ key: string; url: string; }, { key: string; url: string; }]; tag: string; fault: string; scope: string; }; }) | ({ kind: 'haze'; row: { strip: (number)[]; tint: [number, number, number]; near: number; far: number; max: number; sunHaze: number; name: string; prefix: string; }; }); }
+export interface PaintedNumbers { fog: { color: number; near: number; far: number; }; clock: { units: 'hour' | 'phase'; start: number; schedule: ({ phase: 'dawn' | 'day' | 'golden' | 'dusk' | 'night'; from: number; to: number; minutes: number; })[]; sun: { maxElevation: number; azimuthOffset: number; }; fixed: { midday: number; golden: number; sunset: number; night: number; }; presets: { dawn: number; noon: number; dusk: number; night: number; }; dayFraction?: number; pauseOnPin?: boolean; }; sun: { dir: { x: number; y: number; z: number; }; colour: (number) | ([number, number, number]); intensity: number; }; light: { bounce: [number, number, number]; bounceLift: number; rim: [number, number, number]; floor: [number, number, number]; prefix: string; optOut: string; rimBack?: [number, number]; rimSide?: [number, number]; lift?: [number, number, number]; }; lightScope: 'page' | 'material'; hold?: boolean; neutral?: boolean; horizon?: number; rays?: { azimuth: number; elevation: number; }; state?: { deep: (number) | ([number, number, number]); curves: { key: v.InferOutput<typeof CurveSchema>; fill: v.InferOutput<typeof CurveSchema>; fogSun: v.InferOutput<typeof CurveSchema>; farHaze: v.InferOutput<typeof CurveSchema>; aerialFog: v.InferOutput<typeof CurveSchema>; }; }; sky: ({ kind: 'strips'; row: { name: string; maps: [string, string]; elevation: [number, number]; window: [number, number]; firstGain: [number, number]; hold: number; strips: [{ key: string; url: string; }, { key: string; url: string; }]; tag: string; fault: string; scope: string; }; }) | ({ kind: 'haze'; row: { strip: (number)[]; tint: [number, number, number]; near: number; far: number; max: number; sunHaze: number; name: string; prefix: string; }; }); }
+export type PaintedLookRowInput = unknown;
+export interface PaintedLookRow { look: PaintedNumbers; materialSun?: { x: number; y: number; z: number; }; materialOptOut?: string; state?: string; lut?: string; terrain?: 'declared'; images: Record<string, ({ url: string; name: string; warn: string; sampler: { release?: boolean; wrapS?: 1000 | 1001 | 1002; wrapT?: 1000 | 1001 | 1002; mips?: boolean; minFilter?: 1003 | 1004 | 1005 | 1006 | 1007 | 1008; magFilter?: 1003 | 1006; anisotropy?: number; }; }) | ({ phone: { url: string; name: string; warn: string; sampler: { release?: boolean; wrapS?: 1000 | 1001 | 1002; wrapT?: 1000 | 1001 | 1002; mips?: boolean; minFilter?: 1003 | 1004 | 1005 | 1006 | 1007 | 1008; magFilter?: 1003 | 1006; anisotropy?: number; }; }; desktop: { url: string; name: string; warn: string; sampler: { release?: boolean; wrapS?: 1000 | 1001 | 1002; wrapT?: 1000 | 1001 | 1002; mips?: boolean; minFilter?: 1003 | 1004 | 1005 | 1006 | 1007 | 1008; magFilter?: 1003 | 1006; anisotropy?: number; }; }; })>; bumps?: ({ material: string; image: string; channel: 0 | 1 | 2 | 3; scale: number; })[]; dome?: { graph: { phone: string; desktop: string; }; image: string; }; dressing?: { name: string; draws: ({ name: string; graph: string; image?: string; order: number; at: [number, number, number]; spin: number; geometry: ({ kind: 'disc'; radius: number; segments: number; }) | ({ kind: 'plane'; size: [number, number]; instances?: Record<string, ({ size: number; float32: string; }) | ({ size: number; count: number; file: string; })>; }); })[]; }; }

package/src/format/paintedResources.ts

@@ -0,0 +1,158 @@
+import * as v from 'valibot';
+
+// The original native painted-world data contracts, independent of rendering.
+const finite = v.pipe(v.number(), v.finite()), real = finite;
+const shapeId = v.pipe(v.string(), v.regex(/^[a-z][a-zA-Z0-9-]*$/u));
+const tiers = <T extends v.GenericSchema>(schema: T) => v.strictObject({ phone: schema, desktop: schema });
+const triple = v.tuple([finite, finite, finite]);
+
+/** Native drifting cloud-shadow rows; no rendering code. */
+export const PaintedAirSchema: v.GenericSchema<BoundedPaintedAirInput, BoundedPaintedAir> = v.strictObject({ tile: v.pipe(finite, v.minValue(1)), threshold: finite, strength: v.pipe(finite, v.minValue(0), v.maxValue(1)),
+  softness: v.pipe(finite, v.minValue(0)), drift: v.tuple([finite, finite]) });
+
+type BoundedPaintedAirInput = BoundedPaintedAir;
+interface BoundedPaintedAirFields {
+    tile: number;
+    threshold: number;
+    strength: number;
+    softness: number;
+    drift: [
+        number,
+        number
+    ];
+}
+type BoundedPaintedAir = { [Key in keyof BoundedPaintedAirFields]: BoundedPaintedAirFields[Key] };
+/** Native ground binding; its surface retains material-family admission. */
+export const PaintedGroundSchema: v.GenericSchema<BoundedPaintedGroundInput, BoundedPaintedGround> = v.strictObject({ surface: v.unknown(), layers: v.pipe(v.array(shapeId), v.minLength(1), v.maxLength(8)),
+  material: v.strictObject({ bands: finite, rim: finite, shade: finite }), colour: shapeId,
+  shapes: v.pipe(v.array(shapeId), v.minLength(1), v.maxLength(8)), recipe: v.strictObject({ file: v.string(), key: shapeId }), mesh: shapeId,
+  tiles: v.exactOptional(v.literal(true)) });
+
+/** Native panorama resource and lent-parameter bindings. */
+export const PaintedPanoramaSchema: v.GenericSchema<BoundedPaintedPanoramaInput, BoundedPaintedPanorama> = v.strictObject({
+  dome: v.strictObject({ name: shapeId, look: shapeId, image: tiers(v.pipe(v.string(), v.regex(/^\/assets\/[a-zA-Z0-9/_.-]+$/u))), pad: finite, fallbackWidth: v.pipe(finite, v.minValue(1)),
+    zenith: tiers(triple), radius: v.pipe(finite, v.minValue(1)),
+    segments: v.tuple([v.pipe(finite, v.integer(), v.minValue(3), v.maxValue(256)), v.pipe(finite, v.integer(), v.minValue(2), v.maxValue(256))]), order: v.pipe(finite, v.integer()),
+    night: v.tuple([finite, finite]), params: v.strictObject({ image: shapeId, ridge: shapeId, lut: shapeId, pad: shapeId, zenith: shapeId, sun: shapeId, night: shapeId }) }),
+  sea: v.strictObject({ name: shapeId, look: shapeId, y: finite, lut: shapeId, sun: shapeId }),
+  lit: v.strictObject({ looks: v.pipe(v.array(shapeId), v.maxLength(16)), shade: shapeId, rim: shapeId, wet: shapeId }),
+});
+
+/** Native key-light adjustment rows. */
+export const PainterKeyLightSchema: v.GenericSchema<BoundedPainterKeyLightInput, BoundedPainterKeyLight> = v.strictObject({ turn: finite, lift: finite, ease: v.tuple([finite, finite]), sky: triple, ground: triple,
+  mix: v.pipe(finite, v.minValue(0), v.maxValue(1)), fill: v.pipe(finite, v.minValue(0)) });
+
+type BoundedPaintedGroundInput = BoundedPaintedGround;
+interface BoundedPaintedGroundFields {
+    surface: unknown;
+    layers: string[];
+    material: {
+        bands: number;
+        rim: number;
+        shade: number;
+    };
+    colour: string;
+    shapes: string[];
+    recipe: {
+        file: string;
+        key: string;
+    };
+    mesh: string;
+    tiles?: true;
+}
+type BoundedPaintedGround = { [Key in keyof BoundedPaintedGroundFields]: BoundedPaintedGroundFields[Key] };
+type BoundedPaintedPanoramaInput = BoundedPaintedPanorama;
+interface BoundedPaintedPanoramaFields {
+    dome: {
+        name: string;
+        look: string;
+        image: {
+            phone: string;
+            desktop: string;
+        };
+        pad: number;
+        fallbackWidth: number;
+        zenith: {
+            phone: [
+                number,
+                number,
+                number
+            ];
+            desktop: [
+                number,
+                number,
+                number
+            ];
+        };
+        radius: number;
+        segments: [
+            number,
+            number
+        ];
+        order: number;
+        night: [
+            number,
+            number
+        ];
+        params: {
+            image: string;
+            ridge: string;
+            lut: string;
+            pad: string;
+            zenith: string;
+            sun: string;
+            night: string;
+        };
+    };
+    sea: {
+        name: string;
+        look: string;
+        y: number;
+        lut: string;
+        sun: string;
+    };
+    lit: {
+        looks: string[];
+        shade: string;
+        rim: string;
+        wet: string;
+    };
+}
+type BoundedPaintedPanorama = { [Key in keyof BoundedPaintedPanoramaFields]: BoundedPaintedPanoramaFields[Key] };
+type BoundedPainterKeyLightInput = BoundedPainterKeyLight;
+interface BoundedPainterKeyLightFields {
+    turn: number;
+    lift: number;
+    ease: [
+        number,
+        number
+    ];
+    sky: [
+        number,
+        number,
+        number
+    ];
+    ground: [
+        number,
+        number,
+        number
+    ];
+    mix: number;
+    fill: number;
+}
+type BoundedPainterKeyLight = { [Key in keyof BoundedPainterKeyLightFields]: BoundedPainterKeyLightFields[Key] };
+/** Native capture cadence and caster identities. */
+export const PainterlyWorldSchema: v.GenericSchema<BoundedPainterlyWorldInput, BoundedPainterlyWorld> = v.strictObject({ casters: v.pipe(v.array(shapeId), v.maxLength(16)), sweep: v.pipe(real, v.minValue(0.1)),
+  liveMap: v.pipe(real, v.integer(), v.minValue(64), v.maxValue(4096)), dusk: v.tuple([real, real]) });
+
+type BoundedPainterlyWorldInput = BoundedPainterlyWorld;
+interface BoundedPainterlyWorldFields {
+    casters: string[];
+    sweep: number;
+    liveMap: number;
+    dusk: [
+        number,
+        number
+    ];
+}
+type BoundedPainterlyWorld = { [Key in keyof BoundedPainterlyWorldFields]: BoundedPainterlyWorldFields[Key] };