@scenoco-three/unity 0.0.0-stage → 0.7.0

package/README.md

@@ -1,3 +1,31 @@
-# Temporary Holding Version
+# @scenoco-three/unity
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A SceNoCo game's prefabs and scenes, written into a Unity project as Unity's own assets.
+
+```bash
+npx scenoco-unity path/to/UnityProject --root path/to/game
+```
+
+Unity builds them the next time it compiles (or from **SceNoCo ▸ Import**):
+
+- **Prefabs** in `Assets/Prefabs/`, one per prefab a `.tsx` file exports. `<ArrowBase />` written with
+  no attributes stays a nested prefab; a prefab given attributes is copied in.
+- **Scenes** in `Assets/Scenes/`, listed in Build Settings with the one `main.ts` plays first: lights,
+  camera, fog, background and ambient light.
+- **Meshes** in `Assets/Meshes/`, from three.js's own geometry, so a cone or a torus is exactly the
+  shape the web game draws. Two geometries with the same vertices are one mesh.
+- **Materials** in `Assets/Materials/` (URP Lit or Unlit), shared exactly as three.js shares them: one
+  made in `assets.ts` is one asset for every renderer that uses it, so Unity batches them; one written
+  inside an element is that element's own, even if another looks the same.
+- **Behaviours** as MonoBehaviours. A game behaviour gets a C# stub in `Assets/Scripts/` with the
+  fields its elements write, already set on every prefab and scene; its logic is yours to port. The
+  stub is written once and never overwritten. Rapier's and Box2D's components become Unity's own
+  rigidbodies and colliders.
+
+The game is read in its own page, through its own Vite dev server and a headless Chrome: every
+module but the entry is imported, so nothing starts, and each prefab is built with its behaviours
+dormant. What a behaviour builds at runtime is not exported — only what the TSX declares. Whatever
+cannot be carried across is listed as a warning, with the file and line it was written at.
+
+three.js is right-handed and Unity left-handed: the export mirrors Z, and divides light intensities
+by π.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * scenoco-unity <unity-project> [--root <game>] [--headed]
+ *
+ * Writes the game's prefabs, scenes, meshes and materials into a Unity project: Unity builds them
+ * with its own API the next time it compiles (or from the menu, SceNoCo ▸ Import).
+ */
+import { resolve } from 'node:path';
+import { snapshotProject, writeUnity } from './export.js';
+const args = process.argv.slice(2);
+const flag = (name) => {
+    const i = args.indexOf(name);
+    if (i < 0)
+        return undefined;
+    const value = args[i + 1];
+    args.splice(i, 2);
+    return value;
+};
+const headed = args.includes('--headed');
+if (headed)
+    args.splice(args.indexOf('--headed'), 1);
+const root = resolve(flag('--root') ?? '.');
+const project = args[0];
+if (!project || args.length > 1) {
+    console.error('usage: scenoco-unity <unity-project> [--root <game>] [--headed]');
+    process.exit(2);
+}
+try {
+    const snap = await snapshotProject(root, { headed });
+    const { converted, scripts } = writeUnity(snap, project, root);
+    const d = converted.data;
+    console.log(`${d.prefabs.length} prefabs, ${d.scenes.length} scenes, ${d.meshes.length} meshes, ${d.materials.length} materials → ${resolve(project)}`);
+    if (scripts.length)
+        console.log(`C# stubs for ${scripts.join(', ')} in Assets/Scripts — the fields are wired, the logic is yours to port.`);
+    for (const w of d.warnings)
+        console.log(`warning: ${w}`);
+    console.log('Unity builds them when it next compiles, or from SceNoCo ▸ Import.');
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}

package/dist/convert.d.ts

@@ -0,0 +1,157 @@
+/**
+ * A snapshot in Unity's terms: its handedness, its units, its asset paths, and C# for every game
+ * behaviour a prefab carries.
+ *
+ * three.js is right-handed and Unity left-handed, both Y up: mirroring Z maps one onto the other.
+ * A position or vector negates z, a rotation negates x and y of its quaternion, a mesh negates z of
+ * its vertices and normals, and reverses its triangles. A camera looks down its local -Z in three and
+ * +Z in Unity, which the same mirror carries across — so every vertex lands on the same pixel, and a
+ * triangle winds on screen as it did in three: counter-clockwise, which Unity culls as a back face. A light's intensity divides by π:
+ * three's lights are physical, Unity folds π into its own.
+ *
+ * Everything here is data in and data out; the importer in Unity only creates what it is told.
+ */
+import type { Snapshot } from '@scenoco-three/core/snapshot';
+export type UnityValue = null | number | boolean | string | {
+    v2: number[];
+} | {
+    v3: number[];
+} | {
+    v4: number[];
+} | {
+    quat: number[];
+} | {
+    color: string;
+} | {
+    array: UnityValue[];
+} | {
+    node: string;
+} | {
+    component: string;
+    node: string;
+} | {
+    asset: string;
+};
+export interface UnityComponent {
+    type: string;
+    /** A game behaviour, as opposed to one of Unity's own (physics). */
+    game: boolean;
+    fields: Record<string, UnityValue>;
+    source?: string;
+}
+export interface UnityLight {
+    type: 'Directional' | 'Point' | 'Spot';
+    color: string;
+    intensity: number;
+    shadows: boolean;
+    range?: number;
+    /** Full cone angle in degrees, Unity's spotAngle. */
+    spotAngle?: number;
+    innerSpotAngle?: number;
+}
+export interface UnityCamera {
+    orthographic: boolean;
+    near: number;
+    far: number;
+    fov?: number;
+    size?: number;
+}
+export interface UnityNode {
+    name: string;
+    position: number[];
+    rotation: number[];
+    scale: number[];
+    /** Hidden in three with nothing on it to keep running: an inactive GameObject. */
+    active: boolean;
+    /** Hidden in three while a behaviour on it still runs: its renderers off, the object active. */
+    renderersEnabled: boolean;
+    mesh?: string;
+    materials?: string[];
+    castShadows?: boolean;
+    receiveShadows?: boolean;
+    light?: UnityLight;
+    camera?: UnityCamera;
+    components: UnityComponent[];
+    /** A nested prefab's asset path. */
+    prefab?: string;
+    children: UnityNode[];
+    source?: string;
+}
+export interface UnityMesh {
+    path: string;
+    vertices: number[];
+    normals?: number[];
+    uv?: number[];
+    /** One triangle list per submesh, wound for Unity. */
+    submeshes: number[][];
+}
+export interface UnityMaterial {
+    path: string;
+    shader: 'lit' | 'unlit';
+    color: string;
+    opacity: number;
+    transparent: boolean;
+    alphaClip?: number;
+    /** Unity's CullMode: 0 off, 1 front, 2 back. */
+    cull: number;
+    zWrite: boolean;
+    smoothness?: number;
+    metallic?: number;
+    emission?: string;
+    emissionIntensity?: number;
+    /** The texture's asset path, once the exporter copied it in. */
+    texture?: string;
+}
+export interface UnityPrefab {
+    path: string;
+    root: UnityNode;
+}
+export interface UnityScene {
+    path: string;
+    roots: UnityNode[];
+    /** Components the scene's own element carried: Unity has no scene object, so a root holds them. */
+    background?: string;
+    fog?: {
+        mode: 'linear';
+        color: string;
+        start: number;
+        end: number;
+    } | {
+        mode: 'exp2';
+        color: string;
+        density: number;
+    };
+    ambient?: {
+        sky: string;
+        equator: string;
+        ground: string;
+        intensity: number;
+    };
+}
+export interface UnityExport {
+    meshes: UnityMesh[];
+    materials: UnityMaterial[];
+    /** Ordered so a nested prefab comes before the prefabs that use it. */
+    prefabs: UnityPrefab[];
+    /** The first is the one to play first. */
+    scenes: UnityScene[];
+    warnings: string[];
+}
+/** A texture's URL as the page loaded it, and where its file is in the project. */
+export type TextureSource = (url: string) => {
+    file: string;
+    name: string;
+} | null;
+export interface Converted {
+    data: UnityExport;
+    /** C# for each game behaviour, by class name. */
+    scripts: Map<string, string>;
+    /** Files to copy into the Unity project: source → path under it. */
+    copies: Map<string, string>;
+}
+/** A game behaviour's C# class name. */
+export declare const csName: (type: string) => string;
+export declare function convert(snap: Snapshot, options?: {
+    firstScene?: string;
+    textures?: TextureSource;
+}): Converted;

package/dist/convert.js

@@ -0,0 +1,423 @@
+/**
+ * Names Unity already gives a component or a class every script sees. A game behaviour called one
+ * of them cannot be added to an object (Unity refuses a script named `Grid`), or shadows what a port
+ * writes (`Time.deltaTime`), so its C# class is `GridBehaviour`.
+ */
+const UNITY_NAMES = new Set(('Transform RectTransform Camera Light Animator Animation AudioSource AudioListener Rigidbody Rigidbody2D Collider ' +
+    'BoxCollider SphereCollider CapsuleCollider MeshCollider CharacterController Joint HingeJoint FixedJoint SpringJoint Cloth ' +
+    'MeshFilter MeshRenderer SkinnedMeshRenderer Renderer LineRenderer TrailRenderer SpriteRenderer ParticleSystem Terrain Tree ' +
+    'WindZone LODGroup Projector Skybox Grid Tilemap TilemapRenderer Canvas CanvasGroup CanvasRenderer Text Image RawImage Button ' +
+    'Toggle Slider Scrollbar Dropdown InputField Mask Outline Shadow LayoutElement EventSystem NavMeshAgent NavMeshObstacle ' +
+    'ReflectionProbe LightProbeGroup Halo LensFlare FlareLayer VideoPlayer PlayableDirector ConstantForce SortingGroup Behaviour ' +
+    'MonoBehaviour Component GameObject Object Physics Physics2D Input Time Random Debug Mathf Vector2 Vector3 Vector4 Quaternion ' +
+    'Color Material Mesh Texture Texture2D Shader Application Screen Cursor Gizmos Resources SceneManager Event Ray Plane Bounds')
+    .split(' '));
+/** A game behaviour's C# class name. */
+export const csName = (type) => (UNITY_NAMES.has(type) ? `${type}Behaviour` : type);
+const flipV = ([x, y, z]) => [x, y, z === 0 ? 0 : -z];
+const flipQ = ([x, y, z, w]) => [x === 0 ? 0 : -x, y === 0 ? 0 : -y, z, w];
+export function convert(snap, options = {}) {
+    const warnings = [...snap.warnings];
+    const paths = new Paths();
+    const copies = new Map();
+    // three draws a geometry's groups only for a mesh given a list of materials; with one material it
+    // draws everything with it. A BoxGeometry has six groups, so this decides whether it is one submesh or six.
+    const multi = new Set();
+    const scan = (n) => {
+        if (n.geometry && (n.materials?.length ?? 0) > 1)
+            multi.add(n.geometry);
+        n.children.forEach(scan);
+    };
+    snap.prefabs.forEach((p) => scan(p.root));
+    const meshPath = new Map();
+    const meshes = Object.entries(snap.geometries).map(([id, g]) => {
+        const path = paths.take('Assets/Meshes', g.name, '.asset');
+        meshPath.set(id, path);
+        return mesh(multi.has(id) ? g : { ...g, groups: [] }, path);
+    });
+    const materialPath = new Map();
+    const materials = Object.entries(snap.materials).map(([id, m]) => {
+        const path = paths.take('Assets/Materials', m.name, '.mat');
+        materialPath.set(id, path);
+        return material(m, path, options.textures, copies, warnings);
+    });
+    const prefabPath = new Map();
+    const sceneName = new Map();
+    for (const p of snap.prefabs) {
+        if (p.scene)
+            sceneName.set(p.id, paths.take('Assets/Scenes', p.name, '.unity').replace(/^.*\/|\.unity$/g, ''));
+        else
+            prefabPath.set(p.id, paths.take('Assets/Prefabs', p.name, '.prefab'));
+    }
+    const value = (v) => {
+        if (v === null || typeof v !== 'object')
+            return v;
+        if ('v3' in v)
+            return { v3: flipV(v.v3) };
+        if ('quat' in v)
+            return { quat: flipQ(v.quat) };
+        if ('array' in v)
+            return { array: v.array.map(value) };
+        if ('prefab' in v)
+            return sceneName.get(v.prefab) ?? (prefabPath.has(v.prefab) ? { asset: prefabPath.get(v.prefab) } : null);
+        if ('component' in v)
+            return { component: csName(v.component), node: v.node };
+        if ('material' in v)
+            return { asset: materialPath.get(v.material) };
+        if ('geometry' in v)
+            return { asset: meshPath.get(v.geometry) };
+        return v;
+    };
+    let ambient;
+    const node = (n) => {
+        const out = {
+            name: n.name,
+            position: flipV(n.position),
+            rotation: flipQ(n.quaternion),
+            scale: n.scale,
+            active: true,
+            renderersEnabled: true,
+            components: n.components.map((c) => {
+                const fields = {};
+                for (const [k, v] of Object.entries(c.fields))
+                    fields[k] = value(v);
+                const component = { type: c.game ? csName(c.type) : c.type, game: c.game, fields };
+                if (c.source)
+                    component.source = c.source;
+                return component;
+            }),
+            children: n.children.map(node),
+        };
+        if (n.source)
+            out.source = n.source;
+        if (!n.visible) {
+            // three hides the subtree and keeps its behaviours running; Unity's inactive object stops them.
+            if (hasComponents(n))
+                out.renderersEnabled = false;
+            else
+                out.active = false;
+        }
+        if (n.prefab) {
+            const path = prefabPath.get(n.prefab);
+            if (path)
+                out.prefab = path;
+            else
+                warnings.push(`${n.source ?? n.name}: nested ${n.prefab} is not a prefab of its own — left empty.`);
+        }
+        if (n.geometry)
+            out.mesh = meshPath.get(n.geometry);
+        if (n.materials && n.geometry)
+            out.materials = n.materials.map((id) => materialPath.get(id));
+        if (n.geometry) {
+            out.castShadows = n.castShadow;
+            out.receiveShadows = n.receiveShadow;
+        }
+        if (n.camera) {
+            const c = n.camera;
+            out.camera = c.fov !== undefined
+                ? { orthographic: false, near: c.near, far: c.far, fov: c.fov / c.zoom }
+                : { orthographic: true, near: c.near, far: c.far, size: (c.top - c.bottom) / 2 / c.zoom };
+        }
+        if (n.light) {
+            const l = n.light;
+            if (l.type === 'HemisphereLight' || l.type === 'AmbientLight') {
+                if (ambient)
+                    warnings.push(`${n.source ?? n.name}: a second ambient light — only the first sets the scene's ambient.`);
+                else
+                    ambient = { sky: l.color, equator: l.groundColor ? mix(l.color, l.groundColor) : l.color, ground: l.groundColor ?? l.color, intensity: l.intensity / Math.PI };
+            }
+            else if (l.type === 'DirectionalLight' || l.type === 'PointLight' || l.type === 'SpotLight') {
+                const light = { type: l.type.replace('Light', ''), color: l.color, intensity: l.intensity / Math.PI, shadows: l.castShadow };
+                if (l.type !== 'DirectionalLight')
+                    light.range = l.distance || Math.sqrt(l.intensity / Math.PI) * 10;
+                if (l.type === 'SpotLight') {
+                    light.spotAngle = ((l.angle ?? Math.PI / 3) * 2 * 180) / Math.PI;
+                    light.innerSpotAngle = light.spotAngle * (1 - (l.penumbra ?? 0));
+                }
+                if (l.direction)
+                    out.rotation = lookRotation(flipV(l.direction));
+                out.light = light;
+            }
+            else
+                warnings.push(`${n.source ?? n.name}: a ${l.type} is not exported.`);
+        }
+        return out;
+    };
+    const prefabs = [];
+    const scenes = [];
+    for (const p of order(snap.prefabs)) {
+        if (!p.scene) {
+            prefabs.push({ path: prefabPath.get(p.id), root: node(p.root) });
+            continue;
+        }
+        ambient = undefined;
+        const root = node(p.root);
+        // The scene's own components, if any, need an object to live on.
+        const roots = root.components.length ? [{ ...root, name: p.name, position: [0, 0, 0], rotation: [0, 0, 0, 1], scale: [1, 1, 1], children: [] }, ...root.children] : root.children;
+        const scene = { path: `Assets/Scenes/${sceneName.get(p.id)}.unity`, roots };
+        if (p.background)
+            scene.background = p.background;
+        if (p.fog)
+            scene.fog = p.fog.type === 'linear' ? { mode: 'linear', color: p.fog.color, start: p.fog.near, end: p.fog.far } : { mode: 'exp2', color: p.fog.color, density: p.fog.density };
+        if (ambient)
+            scene.ambient = ambient;
+        scenes.push(scene);
+    }
+    if (options.firstScene) {
+        const first = scenes.findIndex((s) => s.path.endsWith(`/${options.firstScene}.unity`));
+        if (first > 0)
+            scenes.unshift(...scenes.splice(first, 1));
+    }
+    return { data: { meshes, materials, prefabs, scenes, warnings }, scripts: scripts(snap, value), copies };
+}
+function hasComponents(n) {
+    return n.components.length > 0 || n.children.some(hasComponents);
+}
+/** Asset paths, one per name per folder, made safe for a file system and for Unity. */
+class Paths {
+    taken = new Set();
+    take(folder, name, ext) {
+        const base = name.replace(/[^\w.-]+/g, '_').replace(/^_+|_+$/g, '') || 'Unnamed';
+        let path = `${folder}/${base}${ext}`;
+        for (let i = 2; this.taken.has(path.toLowerCase()); i++)
+            path = `${folder}/${base}_${i}${ext}`;
+        this.taken.add(path.toLowerCase());
+        return path;
+    }
+}
+function mesh(g, path) {
+    const vertices = g.position.map((v, i) => (i % 3 === 2 && v !== 0 ? -v : v));
+    const out = { path, vertices, submeshes: [] };
+    if (g.normal)
+        out.normals = g.normal.map((v, i) => (i % 3 === 2 && v !== 0 ? -v : v));
+    if (g.uv)
+        out.uv = g.uv;
+    // Mirrored with its camera, a triangle still winds counter-clockwise on screen — three's front, Unity's back.
+    const wind = (from, count) => {
+        const out = [];
+        for (let i = from; i + 2 < from + count; i += 3)
+            out.push(g.index[i], g.index[i + 2], g.index[i + 1]);
+        return out;
+    };
+    if (!g.groups.length)
+        out.submeshes.push(wind(0, g.index.length));
+    else {
+        const count = Math.max(...g.groups.map((gr) => gr.materialIndex)) + 1;
+        out.submeshes = Array.from({ length: count }, () => []);
+        for (const gr of g.groups)
+            out.submeshes[gr.materialIndex].push(...wind(gr.start, Math.min(gr.count, g.index.length - gr.start)));
+    }
+    return out;
+}
+function material(m, path, textures, copies, warnings) {
+    const lit = !/Basic/.test(m.type);
+    const out = {
+        path,
+        shader: lit ? 'lit' : 'unlit',
+        color: m.color ?? '#ffffff',
+        opacity: m.opacity,
+        transparent: m.transparent,
+        cull: m.side === 2 ? 0 : m.side === 1 ? 1 : 2,
+        zWrite: m.depthWrite,
+    };
+    if (m.alphaTest > 0)
+        out.alphaClip = m.alphaTest;
+    if (lit) {
+        out.smoothness = m.roughness !== undefined ? 1 - m.roughness : m.shininess !== undefined ? Math.min(1, m.shininess / 100) : 0.5;
+        out.metallic = m.metalness ?? 0;
+    }
+    if (m.emissive && m.emissive !== '#000000' && (m.emissiveIntensity ?? 1) > 0) {
+        out.emission = m.emissive;
+        out.emissionIntensity = m.emissiveIntensity ?? 1;
+    }
+    if (m.map) {
+        const found = textures?.(m.map);
+        if (found) {
+            out.texture = `Assets/Textures/${found.name}`;
+            copies.set(found.file, out.texture);
+        }
+        else
+            warnings.push(`${m.source ?? m.name}: texture ${m.map} was not found in the project — left off.`);
+    }
+    if (m.vertexColors)
+        warnings.push(`${m.source ?? m.name}: vertex colours are not exported.`);
+    if (m.flatShading)
+        warnings.push(`${m.source ?? m.name}: flat shading is not exported — the mesh keeps its normals.`);
+    return out;
+}
+/** Prefabs before the prefabs and scenes that nest them, so each exists when it is placed. */
+function order(prefabs) {
+    const byId = new Map(prefabs.map((p) => [p.id, p]));
+    const done = new Set();
+    const out = [];
+    const visit = (p, path) => {
+        if (done.has(p.id) || path.has(p.id))
+            return;
+        path.add(p.id);
+        const deps = (n) => [...(n.prefab ? [n.prefab] : []), ...n.children.flatMap(deps)];
+        for (const dep of deps(p.root)) {
+            const d = byId.get(dep);
+            if (d)
+                visit(d, path);
+        }
+        done.add(p.id);
+        out.push(p);
+    };
+    for (const p of prefabs)
+        visit(p, new Set());
+    return out;
+}
+/** Unity's Quaternion.LookRotation(forward, up = Y). */
+function lookRotation([fx, fy, fz]) {
+    let f = [fx, fy, fz];
+    const len = Math.hypot(...f) || 1;
+    f = f.map((v) => v / len);
+    let up = [0, 1, 0];
+    if (Math.abs(f[1]) > 0.999)
+        up = [0, 0, 1];
+    const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+    let r = cross(up, f);
+    const rl = Math.hypot(...r) || 1;
+    r = r.map((v) => v / rl);
+    const u = cross(f, r);
+    // Columns r, u, f are the rotated axes; turn the matrix into a quaternion.
+    const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = [r[0], u[0], f[0], r[1], u[1], f[1], r[2], u[2], f[2]];
+    const trace = m00 + m11 + m22;
+    let x, y, z, w;
+    if (trace > 0) {
+        const s = Math.sqrt(trace + 1) * 2;
+        w = s / 4;
+        x = (m21 - m12) / s;
+        y = (m02 - m20) / s;
+        z = (m10 - m01) / s;
+    }
+    else if (m00 > m11 && m00 > m22) {
+        const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
+        w = (m21 - m12) / s;
+        x = s / 4;
+        y = (m01 + m10) / s;
+        z = (m02 + m20) / s;
+    }
+    else if (m11 > m22) {
+        const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
+        w = (m02 - m20) / s;
+        x = (m01 + m10) / s;
+        y = s / 4;
+        z = (m12 + m21) / s;
+    }
+    else {
+        const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
+        w = (m10 - m01) / s;
+        x = (m02 + m20) / s;
+        y = (m12 + m21) / s;
+        z = s / 4;
+    }
+    return [x, y, z, w].map((v) => Math.round(v * 1e6) / 1e6);
+}
+function mix(a, b) {
+    const p = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
+    const [x, y] = [p(a), p(b)];
+    return `#${x.map((v, i) => Math.round((v + y[i]) / 2).toString(16).padStart(2, '0')).join('')}`;
+}
+// --- C# for game behaviours ----------------------------------------------------------------------
+/**
+ * One MonoBehaviour per game behaviour, with the fields its elements write — typed from the values
+ * written, started from the defaults a fresh instance holds. The logic is a port's to write; these
+ * exist so the prefabs can carry the components and their settings now.
+ */
+function scripts(snap, value) {
+    const seen = new Map();
+    const visit = (n) => {
+        for (const c of n.components) {
+            if (!c.game)
+                continue;
+            const fields = seen.get(c.type) ?? new Map();
+            seen.set(c.type, fields);
+            for (const [k, v] of Object.entries(c.fields))
+                fields.set(k, [...(fields.get(k) ?? []), value(v)]);
+        }
+        n.children.forEach(visit);
+    };
+    snap.prefabs.forEach((p) => visit(p.root));
+    const out = new Map();
+    for (const [type, fields] of seen) {
+        const info = snap.classes[type];
+        const lines = [...fields].map(([name, values]) => {
+            const cs = csType(values);
+            const fallback = info?.defaults[name];
+            const init = fallback === undefined ? '' : csValue(value(fallback), cs);
+            return cs ? `    public ${cs} ${name}${init ? ` = ${init}` : ''};` : `    // ${name}: always empty where it is written, so its type is unknown`;
+        });
+        const name = csName(type);
+        out.set(name, [
+            'using UnityEngine;',
+            '',
+            `// The fields ${info?.file ?? 'the game'} sets on ${type} in its scenes and prefabs. Port its logic here;`,
+            '// keep the field names, the prefabs are wired by them. Written by scenoco-unity once, never overwritten.',
+            ...(name !== type ? [`// Named ${name}: Unity has its own ${type}.`] : []),
+            `public class ${name} : MonoBehaviour`,
+            '{',
+            ...lines,
+            '}',
+            '',
+        ].join('\n'));
+    }
+    return out;
+}
+function csType(values) {
+    const known = values.find((v) => v !== null && !(typeof v === 'object' && 'array' in v && v.array.length === 0)) ?? values[0];
+    if (known === undefined || known === null)
+        return undefined;
+    if (typeof known === 'number')
+        return 'float';
+    if (typeof known === 'boolean')
+        return 'bool';
+    if (typeof known === 'string')
+        return 'string';
+    if ('v2' in known)
+        return 'Vector2';
+    if ('v3' in known)
+        return 'Vector3';
+    if ('v4' in known)
+        return 'Vector4';
+    if ('quat' in known)
+        return 'Quaternion';
+    if ('color' in known)
+        return 'Color';
+    if ('component' in known)
+        return known.component;
+    if ('node' in known)
+        return 'Transform';
+    if ('asset' in known)
+        return known.asset.endsWith('.prefab') ? 'GameObject' : known.asset.endsWith('.mat') ? 'Material' : 'Mesh';
+    if ('array' in known) {
+        const inner = csType(values.flatMap((v) => (v && typeof v === 'object' && 'array' in v ? v.array : [])));
+        return inner ? `${inner}[]` : undefined;
+    }
+    return undefined;
+}
+function csValue(v, type) {
+    const f = (n) => `${Number.isInteger(n) ? n : n}f`;
+    if (v === null || type === undefined)
+        return '';
+    if (typeof v === 'number')
+        return type === 'float' ? f(v) : '';
+    if (typeof v === 'boolean')
+        return type === 'bool' ? String(v) : '';
+    if (typeof v === 'string')
+        return type === 'string' ? JSON.stringify(v) : '';
+    if ('v2' in v && type === 'Vector2')
+        return `new Vector2(${v.v2.map(f).join(', ')})`;
+    if ('v3' in v && type === 'Vector3')
+        return `new Vector3(${v.v3.map(f).join(', ')})`;
+    if ('color' in v && type === 'Color') {
+        const [r, g, b] = [1, 3, 5].map((i) => parseInt(v.color.slice(i, i + 2), 16) / 255);
+        return `new Color(${[r, g, b].map((n) => f(Math.round(n * 1000) / 1000)).join(', ')})`;
+    }
+    if ('array' in v && type.endsWith('[]')) {
+        const inner = type.slice(0, -2);
+        const items = v.array.map((i) => csValue(i, inner));
+        return items.length && items.every(Boolean) ? `{ ${items.join(', ')} }` : '';
+    }
+    return '';
+}

package/dist/export.d.ts

@@ -0,0 +1,15 @@
+import type { Snapshot } from '@scenoco-three/core/snapshot';
+import { type Converted } from './convert.js';
+/** Every module under `src/` the page may import: TypeScript and TSX, the game's entries left out. */
+export declare function gameModules(root: string): string[];
+/** Build the project's prefabs and scenes in its own page, and describe them. */
+export declare function snapshotProject(root: string, options?: {
+    headed?: boolean;
+}): Promise<Snapshot>;
+export interface Written {
+    converted: Converted;
+    /** Stubs written; the rest already had a class of that name in the project. */
+    scripts: string[];
+}
+/** Convert a snapshot and write it into the Unity project: data for the importer, the importer, C# stubs, textures. */
+export declare function writeUnity(snap: Snapshot, project: string, root: string): Written;