@ringozz/godot 4.7.2-659 → 4.7.2-664

package/src/planRefs.ts

@@ -1,209 +0,0 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-// A level's refs, read from its **plan**. A `.gltfx` level scene carries the converter's derived
-// render state under `extras.wartales.plan`: it names the level's terrain by *directory* and its
-// ground/environment textures by resource route. A host's closure walk cannot see any of it — the
-// routes are relative to the manifest that names them, a layered container's layers are plain text
-// lines, and a runtime script reads the plan dynamically (so no scene names them literally any more).
-// Reading it here keeps a `.gltfx` source's closure complete without a baked scene.
-//
-// Pure filesystem: a project directory plus the `res://` roots a host scans in, the refs out. No
-// engine, no editor — so it is unit-testable and runs before the pack bake.
-
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-/** The refs a `.gltfx`'s plan implies, ready to merge into a dump. */
-export interface PlanRefs {
-	/** The level source's own extra loose refs: its terrain data, layered-container manifests, and the
-	 *  ground/environment textures its plan names. */
-	loose: string[];
-}
-
-// Two of the refs a plan names are plain files rather than imported sources — the terrain's header
-// JSONs, which a plan-built level reads at run time. They are in the level's `loose` list, so a
-// *staging* host writes them; a *pack* needs no help either, because Godot loads a `.json` as a
-// `JSON` resource (verified: `ResourceLoader.exists` is true and the class is `JSON`), so an
-// `all_resources` preset packs it — and since no pack *owns* a source it is not excluded from any,
-// every pack carries those few KB.
-
-const isObject = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
-
-/** The `extras.wartales.plan` of a parsed gltfx document, or null for a foreign/older document. */
-export function planOf(doc: unknown): Record<string, unknown> | null {
-	if (!isObject(doc) || !isObject(doc.extras)) return null;
-	const w = (doc.extras as Record<string, unknown>)['wartales'];
-	if (!isObject(w) || !isObject(w.plan)) return null;
-	return w.plan as Record<string, unknown>;
-}
-
-/** Every `src/<dir>`-style root as an absolute disk directory, paired with its `res://` prefix. */
-function rootDirs(projectDir: string, roots: string[]): { disk: string; res: string }[] {
-	const out: { disk: string; res: string }[] = [];
-	for (const root of roots) {
-		const rel = root.replace(/^res:\/\//, '');
-		out.push({ disk: join(projectDir, ...rel.split('/')), res: `res://${rel}` });
-	}
-	return out;
-}
-
-/** A path's last segment. */
-const base = (p: string) => p.slice(p.lastIndexOf('/') + 1);
-
-/** Every file under `dir`, as paths relative to `dir` (posix, one level of nesting per entry). */
-function walk(dir: string, prefix = ''): string[] {
-	const out: string[] = [];
-	let entries: string[];
-	try {
-		entries = readdirSync(dir);
-	} catch {
-		return out;
-	}
-	for (const name of entries) {
-		if (name.startsWith('.')) continue;
-		const full = join(dir, name);
-		const rel = prefix ? `${prefix}/${name}` : name;
-		try {
-			if (readdirSync(full).length >= 0) {
-				out.push(...walk(full, rel));
-				continue;
-			}
-		} catch {
-			// not a directory
-		}
-		out.push(rel);
-	}
-	return out;
-}
-
-/**
- * The environment a **host renders**: the level's authored stage — `stages[0].env`, which the plan
- * also carries as `lighting.env`. A host shows one time of day, so the other stages (a viewer's
- * blend material) and the reflection probe (which a host does not sample) are not runtime refs.
- */
-function authoredEnvMap(lighting: Record<string, unknown>): string | null {
-	const stages = Array.isArray(lighting.stages) ? lighting.stages : [];
-	const stage0 = stages.length && isObject(stages[0]) ? (stages[0] as Record<string, unknown>) : null;
-	const env = (stage0 && isObject(stage0.env) ? stage0.env : null) ?? (isObject(lighting.env) ? lighting.env : null);
-	return env && typeof env.map === 'string' ? env.map : null;
-}
-
-/**
- * The layer file names the `.webparray` manifests in `dir` name, one per line. Those layers are read
- * by their *importer* and live inside the imported product afterwards, so nothing loads them at run
- * time: they are import-time inputs, and the directory walk must not stage them.
- */
-function layerSources(dir: string): Set<string> {
-	const names = new Set<string>();
-	for (const manifest of walk(dir)) {
-		if (!manifest.toLowerCase().endsWith(".webparray")) continue;
-		let text: string;
-		try {
-			text = readFileSync(join(dir, ...manifest.split("/")), "utf8");
-		} catch {
-			continue;
-		}
-		for (const line of text.split("\n")) {
-			const ref = line.trim();
-			if (ref && !ref.startsWith("#")) names.add(base(ref));
-		}
-	}
-	return names;
-}
-
-/** The resource route of a ref the plan names, probing the served `.webp` suffix a texture carries. */
-function routeOf(root: { disk: string; res: string }, route: string): string | null {
-	for (const candidate of [route, `${route}.webp`]) {
-		if (existsSync(join(root.disk, ...candidate.split('/')))) return `${root.res}/${candidate}`;
-	}
-	return null;
-}
-
-/**
- * Every `.gltfx` under `roots` with its plan-derived refs. A level's terrain is discovered by
- * *listing* its directory (the tree holds exactly the level's atlas there, so no name list to keep in
- * step), its manifests' layers are read from the manifests, and its ground/environment textures are
- * probed per route (a plan route may or may not carry the served `.webp` suffix).
- */
-export function planRefs(projectDir: string, roots: string[]): Map<string, PlanRefs> {
-	const out = new Map<string, PlanRefs>();
-	for (const root of rootDirs(projectDir, roots)) {
-		for (const file of walk(root.disk)) {
-			if (!file.toLowerCase().endsWith('.gltfx')) continue;
-			let doc: unknown;
-			try {
-				doc = JSON.parse(readFileSync(join(root.disk, ...file.split('/')), 'utf8'));
-			} catch {
-				continue;
-			}
-			const plan = planOf(doc);
-			if (!plan) continue;
-			const levelRoute = `${root.res}/${file}`;
-			const loose = new Set<string>();
-
-			// The terrain: the plan names its directory, and the tree holds exactly the level's own atlas
-			// there (the height and tile-normal maps, the composed weight planes, the passmap and its
-			// meta, the header JSON and the layered containers) — so the directory *is* the list. A
-			// container's *layers* are deliberately not listed: they live inside its imported product,
-			// and are import-time inputs, so nothing stages them at run time.
-			const terrain = isObject(plan.terrain) ? plan.terrain : null;
-			if (terrain && typeof terrain.dir === 'string') {
-				const dir = terrain.dir;
-				const abs = join(root.disk, ...dir.split('/'));
-				const layers = layerSources(abs);
-				for (const name of walk(abs)) {
-					if (name.endsWith(".import") || layers.has(base(name))) continue;
-					loose.add(`${root.res}/${dir}/${name}`);
-				}
-			}
-
-			// The ground's patches and the rig's skies: plain resource routes with the served suffix.
-			const ground = Array.isArray(plan.ground) ? plan.ground : [];
-			for (const g of ground) {
-				if (!isObject(g)) continue;
-				const fields = g.source === 'overlay' ? [isObject(g.material) ? g.material : {}] : [isObject(g.water) ? g.water : {}];
-				for (const f of fields) {
-					for (const key of ['diffuse', 'normal', 'orm']) {
-						if (typeof f[key] !== 'string') continue;
-						const route = routeOf(root, f[key] as string);
-						if (route) loose.add(route);
-					}
-				}
-			}
-			const lighting = isObject(plan.lighting) ? plan.lighting : {};
-			const map = authoredEnvMap(lighting);
-			const route = map ? routeOf(root, map) : null;
-			if (route) loose.add(route);
-
-			out.set(levelRoute, { loose: [...loose].sort() });
-		}
-	}
-	return out;
-}
-
-/**
- * Merge `planRefs` into a dump's `graph`/`loose` halves: a `.gltfx` source gains its plan's refs, and
- * so does every source that reaches it (a scene that instances it, so mounting the scene stages the
- * level's terrain and ground too — a union, and a no-op for a project with no plan).
- */
-export function mergePlanRefs(
-	graph: Record<string, string[]>,
-	deps: Record<string, string[]>,
-	refs: Map<string, PlanRefs>,
-): void {
-	for (const [level, r] of refs) {
-		if (!(level in graph)) continue;
-		deps[level] = [...new Set([...(deps[level] ?? []), ...r.loose])].sort();
-	}
-	// A scene that instances a `.gltfx` carries that plan's refs too: mounting the scene must stage the
-	// level's terrain and ground, not only its model composition. (The scene may already name some of
-	// them — a baked one does — so this is a union, and a no-op for a project with no plan.)
-	for (const source of Object.keys(graph)) {
-		const plans = graph[source].filter((dep) => refs.has(dep));
-		if (!plans.length || refs.has(source)) continue;
-		const extra = plans.flatMap((p) => refs.get(p)!.loose);
-		deps[source] = [...new Set([...(deps[source] ?? []), ...extra])].sort();
-	}
-}