cozyclay 2.0.2 → 2.1.1

package/src/receipt-findings.js

@@ -0,0 +1,20 @@
+// Findings an edit receipt reports beside its readback: a value the domain
+// moved to stay inside its limits, so a request that did not land as asked is
+// never silent.
+const round = value => Number(value.toFixed(4));
+
+/** One CLAMPED warning for an entity when any requested number differs from
+ * the number the domain kept, or null. `requested` and `applied` are keyed by
+ * the same channel names (x, y, z, scaleX, scale, ...). */
+export function clampWarning(id, requested, applied) {
+	const parts = [];
+	for (const [key, asked] of Object.entries(requested)) {
+		const kept = applied?.[key];
+		if (!Number.isFinite(asked) || !Number.isFinite(kept) || Math.abs(asked - kept) < 1e-9) continue;
+		const limit = asked < kept ? 'minimum' : 'maximum';
+		parts.push(`${key} ${round(asked)}→${round(kept)} (${limit} ${round(kept)}${/^(x|y|z)$/.test(key) ? ' m' : ''})`);
+	}
+	if (!parts.length) return null;
+	const message = [...`Clamped: ${parts.join('; ')}`];
+	return { code: 'CLAMPED', id, message: message.length > 120 ? `${message.slice(0, 119).join('')}…` : message.join('') };
+}

package/src/render-passes.js

@@ -69,7 +69,6 @@ void main() {
 
 const BACKGROUND_FAR = new THREE.Color(0x000000);
 
-/** Build the override material for a pass. */
 function passMaterial(kind, camera, depthRange = null) {
 	if (kind === "depth") {
 		return new THREE.ShaderMaterial({

package/src/resource-status.jsx

@@ -26,7 +26,7 @@ export function resourceStatusLabel(item) {
 	return ko("Missing", "누락");
 }
 
-export function resourceKindLabel(kind) {
+function resourceKindLabel(kind) {
 	return KIND_LABELS[kind]?.() ?? String(kind ?? "");
 }
 

package/src/root-path.js

@@ -0,0 +1,48 @@
+import { isProxyFigure } from "./scenes.js";
+
+// Frame-addressed scene placement. No renderer or waypoint authoring state.
+export function sampleRootPath(character, frame, { fps = 24 } = {}) {
+	const waypoints = character.layer?.waypoints ?? [];
+	if (!waypoints.length) return null;
+	const base = { x: character.x, z: character.z, heading: character.rot };
+	if (frame <= 0) return base;
+	let previous = { frame: 0, ...base };
+	let sampled = base;
+	for (const pin of waypoints) {
+		const dx = pin.x - previous.x;
+		const dz = pin.z - previous.z;
+		const heading = pin.heading ?? (dx || dz ? Math.atan2(dx, dz) * 180 / Math.PI : sampled.heading);
+		const weight = Math.min(1, (frame / fps - previous.frame / fps) / (pin.frame / fps - previous.frame / fps));
+		sampled = {
+			x: previous.x + dx * weight,
+			z: previous.z + dz * weight,
+			heading,
+		};
+		if (frame <= pin.frame) return sampled;
+		previous = pin;
+	}
+	return sampled;
+}
+
+// takeRoot is an already sampled world-space { x, z, rot? } supplied by the
+// take owner. Shot lookup is injected so this module does not own a timeline.
+export function resolveCharacterPlacement(character, frame, { shotAt = () => null, takeRoot = null } = {}) {
+	const base = { x: character.x, z: character.z, rot: character.rot, posture: character.posture, pose: character.pose };
+	if (takeRoot) return { ...base, ...takeRoot };
+	const root = sampleRootPath(character, frame);
+	if (root) return { ...base, x: root.x, z: root.z, rot: root.heading };
+	return { ...base, ...shotAt(frame)?.cast?.[character.id] };
+}
+
+// Rendering and export share the same placement policy. A rigged character's
+// authored waypoints belong to its take, not its world transform; only proxy
+// figures use the root-path sampler without a take. Still cast overrides are
+// editorial placement and apply to either kind while the playhead is inside a
+// still.
+export function placementAt(character, frame, { shotAt = () => null, takeRoot = null } = {}) {
+	if (takeRoot) return resolveCharacterPlacement(character, frame, { takeRoot });
+	const shot = shotAt(frame);
+	if (isProxyFigure(character)) return resolveCharacterPlacement(character, frame, { shotAt: () => shot });
+	if (shot?.kind === "still") return { ...character, ...shot.cast?.[character.id] };
+	return character;
+}

package/src/route-owner.js

@@ -0,0 +1,52 @@
+/**
+ * Whose route the studio shows for a selection.
+ *
+ * A route belongs to one record, but a car is a group: "Vintage Car" (an
+ * Empty) → "Chassis" (owns the route) → parts. The operator selects the group,
+ * so the rail, its dots and the route strip follow the group to the record
+ * that actually owns the travel. Pure and flat-record based, like
+ * object-travel.js: `parent` is grouping only.
+ */
+
+const hasRoute = (object) => !!object && !!object.path;
+
+/**
+ * The record whose route a selection stands for: the selected record when it
+ * owns a path, else its nearest routed descendant (breadth-first; ties at one
+ * depth go to the first in record order), else null. A descendant carried by a
+ * character (`attach`) is skipped: its route never plays.
+ *
+ * @param {object[]|Map<string, object>} objects scene records
+ * @param {string|null} selectedId
+ */
+export function routeOwnerFor(objects, selectedId) {
+	if (!selectedId) return null;
+	const list = objects instanceof Map ? [...objects.values()] : Array.isArray(objects) ? objects : [];
+	const selected = list.find((object) => object && object.id === selectedId);
+	if (!selected) return null;
+	if (hasRoute(selected)) return selected;
+	const childrenOf = new Map();
+	for (const object of list) {
+		if (!object || typeof object.parent !== "string") continue;
+		if (!childrenOf.has(object.parent)) childrenOf.set(object.parent, []);
+		childrenOf.get(object.parent).push(object);
+	}
+	const order = new Map(list.map((object, index) => [object, index]));
+	const seen = new Set([selected.id]);
+	let level = [selected];
+	while (level.length) {
+		const next = [];
+		let best = null;
+		for (const node of level) {
+			for (const child of childrenOf.get(node.id) ?? []) {
+				if (seen.has(child.id)) continue;
+				seen.add(child.id);
+				if (!child.attach && hasRoute(child) && (!best || order.get(child) < order.get(best))) best = child;
+				next.push(child);
+			}
+		}
+		if (best) return best;
+		level = next;
+	}
+	return null;
+}

package/src/scene-asset-cache.js

@@ -128,7 +128,7 @@ export function createAssetTextureCache({
 		entry.promise = null;
 		// A GLB in this function would always hit createImageBitmap. Mesh import
 		// stores bytes with putAsset and leaves textures alone.
-		if (isMeshRecord(stored) || isMeshAssetId(stored.id)) return stored;
+		if (isMeshRecord(stored)) return stored;
 		const texture = await textureFromAsset(stored);
 		if (!texture || entry.generation !== generation) {
 			dispose(texture);
@@ -183,4 +183,3 @@ export const assetRecord = cache.assetRecord;
 export const rememberAsset = cache.rememberAsset;
 export const evictAssetTexture = cache.evictAssetTexture;
 export const subscribeToAssetTexture = cache.subscribeToAssetTexture;
-export const clearAssetTextures = cache.clearAssetTextures;

package/src/scene-assets.js

@@ -29,9 +29,9 @@ export const MESH_ID_PREFIX = "mesh-";
  * pictures, and short enough to read in a scene file. */
 const ASSET_ID_HEX = 32;
 
-export const ASSET_DB_NAME = "cozyclay.assets";
-export const ASSET_DB_VERSION = 1;
-export const ASSET_STORE_NAME = "images";
+const ASSET_DB_NAME = "cozyclay.assets";
+const ASSET_DB_VERSION = 1;
+const ASSET_STORE_NAME = "images";
 
 /** What an import will accept. SVG is excluded on purpose: it is a document
  * that can carry script, and a set piece is not worth that. */
@@ -308,7 +308,15 @@ export async function importImageFile(file, {
  * going away. This is the reachable set; `unreachableAssetIds` is the sweep.
  */
 export function referencedAssetIds(scenes) {
-	return new Set(assetUsageCounts(scenes).keys());
+	const ids = new Set(assetUsageCounts(scenes).keys());
+	// A storyboard panel's stylized picture is held by its shot, not by an object.
+	for (const scene of Array.isArray(scenes) ? scenes : []) {
+		const shots = scene?.shotDocument?.shots;
+		for (const shot of Array.isArray(shots) ? shots : []) {
+			if (isImageAssetId(shot?.stylizedAssetId)) ids.add(shot.stylizedAssetId);
+		}
+	}
+	return ids;
 }
 
 /**

package/src/scene-fbx.js

@@ -46,7 +46,7 @@ export function readFbxVersion(bytes) {
 	return Number.isFinite(version) ? version : null;
 }
 
-export function parseFbxGroup(bytes) {
+function parseFbxGroup(bytes) {
 	const buffer = arrayBufferOf(bytes);
 	if (!buffer || !buffer.byteLength) return null;
 	return new FBXLoader().parse(buffer, "");

package/src/scene-mesh-cache.js

@@ -132,4 +132,3 @@ const cache = createMeshSceneCache();
 export const loadMeshScene = cache.loadMeshScene;
 export const subscribeToMeshScene = cache.subscribeToMeshScene;
 export const evictMeshScene = cache.evictMeshScene;
-export const clearMeshScenes = cache.clearMeshScenes;