@dreamerbird/camera-studio 0.1.0 → 0.3.0

package/dist/materials/modelMaterials.js

@@ -0,0 +1,253 @@
+import { types as t } from '@dreamerbird/core';
+import { Mesh, SRGBColorSpace, } from 'three';
+const textureProperties = [
+    ['mapBlobId', 'map'],
+    ['normalMapBlobId', 'normalMap'],
+    ['roughnessMapBlobId', 'roughnessMap'],
+    ['metalnessMapBlobId', 'metalnessMap'],
+    ['emissiveMapBlobId', 'emissiveMap'],
+];
+const originalStates = new WeakMap();
+const configCache = new WeakMap();
+function materialRecord(material) {
+    return material;
+}
+function rememberOriginal(material) {
+    const existing = originalStates.get(material);
+    if (existing)
+        return existing;
+    const record = materialRecord(material);
+    const state = {
+        maps: {},
+        transparent: material.transparent,
+    };
+    for (const [, property] of textureProperties) {
+        state.maps[property] = record[property] ?? null;
+    }
+    originalStates.set(material, state);
+    return state;
+}
+function slotKey(slotId, meshName) {
+    let hash = 2166136261;
+    for (let index = 0; index < slotId.length; index++) {
+        hash ^= slotId.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    const name = meshName.replace(/[^a-zA-Z0-9_-]/g, '_') || 'mesh';
+    return `${name}_${(hash >>> 0).toString(36)}`;
+}
+function materialValues(material) {
+    const record = materialRecord(material);
+    const color = record.color;
+    const emissive = record.emissive;
+    return {
+        color: `#${color?.getHexString() ?? 'ffffff'}`,
+        metalness: typeof record.metalness === 'number' ? record.metalness : 0,
+        roughness: typeof record.roughness === 'number' ? record.roughness : 1,
+        emissive: `#${emissive?.getHexString() ?? '000000'}`,
+        opacity: material.opacity,
+        mapBlobId: '',
+        normalMapBlobId: '',
+        roughnessMapBlobId: '',
+        metalnessMapBlobId: '',
+        emissiveMapBlobId: '',
+    };
+}
+export function cloneModelMaterials(root) {
+    root.traverse((object) => {
+        if (!(object instanceof Mesh))
+            return;
+        const clone = (material) => {
+            const cloned = material.clone();
+            rememberOriginal(cloned);
+            return cloned;
+        };
+        object.material = Array.isArray(object.material)
+            ? object.material.map(clone)
+            : clone(object.material);
+    });
+}
+export function collectMaterialSlots(root) {
+    const slots = [];
+    const visit = (object, path) => {
+        if (object instanceof Mesh) {
+            const materials = Array.isArray(object.material)
+                ? object.material
+                : [object.material];
+            materials.forEach((material, materialIndex) => {
+                rememberOriginal(material);
+                const slotId = `${path.join('/') || 'root'}:${materialIndex}`;
+                slots.push({
+                    slotId,
+                    slotKey: slotKey(slotId, object.name),
+                    meshName: object.name,
+                    materialName: material.name,
+                    values: materialValues(material),
+                });
+            });
+        }
+        object.children.forEach((child, index) => visit(child, [...path, index]));
+    };
+    visit(root, []);
+    return slots;
+}
+function bindings(root, slots) {
+    const byId = new Map(slots.map((slot) => [slot.slotId, slot]));
+    const result = [];
+    const visit = (object, path) => {
+        if (object instanceof Mesh) {
+            const materials = Array.isArray(object.material)
+                ? object.material
+                : [object.material];
+            materials.forEach((material, materialIndex) => {
+                const slot = byId.get(`${path.join('/') || 'root'}:${materialIndex}`);
+                if (slot)
+                    result.push({ slot, material });
+            });
+        }
+        object.children.forEach((child, index) => visit(child, [...path, index]));
+    };
+    visit(root, []);
+    return result;
+}
+export function applyMaterialScalars(root, slots, overrides) {
+    for (const { slot, material } of bindings(root, slots)) {
+        const values = overrides[slot.slotKey];
+        if (!values)
+            continue;
+        const record = materialRecord(material);
+        if (values.color !== undefined) {
+            ;
+            record.color?.set(values.color);
+        }
+        if (values.emissive !== undefined) {
+            ;
+            record.emissive?.set(values.emissive);
+        }
+        for (const property of ['metalness', 'roughness']) {
+            const value = values[property];
+            if (value !== undefined && typeof record[property] === 'number') {
+                record[property] = value;
+            }
+        }
+        if (values.opacity !== undefined) {
+            material.opacity = values.opacity;
+            const original = rememberOriginal(material);
+            const transparent = original.transparent || values.opacity < 1;
+            if (material.transparent !== transparent) {
+                material.transparent = transparent;
+                material.needsUpdate = true;
+            }
+        }
+    }
+}
+function scalarConfig(values) {
+    return {
+        color: t.string(values.color),
+        metalness: t.number(values.metalness, { range: [0, 1] }),
+        roughness: t.number(values.roughness, { range: [0, 1] }),
+        emissive: t.string(values.emissive),
+        opacity: t.number(values.opacity, { range: [0, 1] }),
+        mapBlobId: t.string(''),
+        normalMapBlobId: t.string(''),
+        roughnessMapBlobId: t.string(''),
+        metalnessMapBlobId: t.string(''),
+        emissiveMapBlobId: t.string(''),
+    };
+}
+export function createMaterialOverridesConfig(slots) {
+    const cached = configCache.get(slots);
+    if (cached)
+        return cached;
+    const config = t.compound(Object.fromEntries(slots.map((slot) => [
+        slot.slotKey,
+        t.compound(scalarConfig(slot.values), {
+            label: `${slot.meshName || 'Mesh'} / ${slot.materialName || 'Material'}`,
+        }),
+    ])), { label: 'Materials' });
+    configCache.set(slots, config);
+    return config;
+}
+export function createMaterialTextureController(options) {
+    let generation = 0;
+    let disposed = false;
+    const loaded = new Map();
+    const disposeEntry = (material, property) => {
+        const entry = loaded.get(material)?.[property];
+        if (!entry)
+            return;
+        entry.texture.dispose();
+        delete loaded.get(material)[property];
+    };
+    const updateTexture = async (material, property, blobId, token) => {
+        const original = rememberOriginal(material);
+        const record = materialRecord(material);
+        if (!blobId) {
+            const originalMap = original.maps[property] ?? null;
+            if (record[property] !== originalMap ||
+                loaded.get(material)?.[property]) {
+                material.needsUpdate = true;
+            }
+            record[property] = originalMap;
+            disposeEntry(material, property);
+            return;
+        }
+        if (loaded.get(material)?.[property]?.blobId === blobId)
+            return;
+        const url = await options.getBlobUrl(blobId);
+        const texture = await options.loadTexture(url);
+        if (disposed || token !== generation) {
+            texture.dispose();
+            return;
+        }
+        texture.colorSpace =
+            property === 'map' || property === 'emissiveMap'
+                ? SRGBColorSpace
+                : texture.colorSpace;
+        disposeEntry(material, property);
+        record[property] = texture;
+        material.needsUpdate = true;
+        const entries = loaded.get(material) ?? {};
+        entries[property] = { blobId, texture };
+        loaded.set(material, entries);
+    };
+    return {
+        async update(root, slots, overrides) {
+            const token = ++generation;
+            const tasks = [];
+            for (const { slot, material } of bindings(root, slots)) {
+                const values = overrides[slot.slotKey];
+                if (!values)
+                    continue;
+                for (const [blobProperty, property] of textureProperties) {
+                    const blobId = values[blobProperty];
+                    if (blobId === undefined)
+                        continue;
+                    tasks.push(updateTexture(material, property, blobId, token).catch((error) => {
+                        if (!disposed && token === generation) {
+                            if (options.onError) {
+                                options.onError(error, slot.slotId, blobProperty);
+                            }
+                            else {
+                                console.warn(`[materials] 贴图加载失败: ${slot.slotId}/${blobProperty}`, error);
+                            }
+                        }
+                    }));
+                }
+            }
+            await Promise.all(tasks);
+            if (!disposed && token === generation)
+                options.invalidate();
+        },
+        dispose() {
+            disposed = true;
+            generation++;
+            for (const [material, entries] of loaded) {
+                for (const property of Object.keys(entries)) {
+                    disposeEntry(material, property);
+                }
+            }
+            loaded.clear();
+        },
+    };
+}

package/dist/materials/modelMaterials.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=modelMaterials.test.d.ts.map

package/dist/materials/modelMaterials.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelMaterials.test.d.ts","sourceRoot":"","sources":["../../src/materials/modelMaterials.test.ts"],"names":[],"mappings":""}

package/dist/materials/modelMaterials.test.js

@@ -0,0 +1,188 @@
+import { BoxGeometry, Group, Mesh, MeshStandardMaterial, Texture } from 'three';
+import { SkeletonUtils } from 'three-stdlib';
+import { applyMaterialScalars, cloneModelMaterials, collectMaterialSlots, createMaterialOverridesConfig, createMaterialTextureController, } from './modelMaterials';
+import { disposeObjectTree } from '../assetLibrary/dispose';
+function modelWithTwoMeshes() {
+    const root = new Group();
+    const a = new Mesh(new BoxGeometry(), new MeshStandardMaterial());
+    const b = new Mesh(new BoxGeometry(), new MeshStandardMaterial());
+    a.name = 'Body';
+    b.name = 'Body';
+    root.add(a, b);
+    return { root, a, b };
+}
+function values(overrides = {}) {
+    return {
+        color: '#ffffff',
+        metalness: 0,
+        roughness: 1,
+        emissive: '#000000',
+        opacity: 1,
+        mapBlobId: '',
+        normalMapBlobId: '',
+        roughnessMapBlobId: '',
+        metalnessMapBlobId: '',
+        emissiveMapBlobId: '',
+        ...overrides,
+    };
+}
+test('stable slot keys survive traversal and duplicate mesh names', () => {
+    const { root } = modelWithTwoMeshes();
+    const slots = collectMaterialSlots(root);
+    expect(slots).toHaveLength(2);
+    expect(slots[0].slotId).not.toBe(slots[1].slotId);
+    expect(slots[0].slotKey).not.toBe(slots[1].slotKey);
+    expect(collectMaterialSlots(root)).toEqual(slots);
+});
+test('SkeletonUtils.clone instances receive isolated materials and scalar updates stay instance-local', () => {
+    const { root } = modelWithTwoMeshes();
+    const first = SkeletonUtils.clone(root);
+    const second = SkeletonUtils.clone(root);
+    cloneModelMaterials(first);
+    cloneModelMaterials(second);
+    const firstSlots = collectMaterialSlots(first);
+    const secondSlots = collectMaterialSlots(second);
+    const firstMesh = first.children[0];
+    const secondMesh = second.children[0];
+    const firstMaterial = firstMesh.material;
+    const secondMaterial = secondMesh.material;
+    expect(firstMaterial).not.toBe(secondMaterial);
+    expect(firstMaterial).not.toBe(root.children[0].material);
+    applyMaterialScalars(first, firstSlots, {
+        [firstSlots[0].slotKey]: values({ roughness: 0.2, color: '#112233' }),
+    });
+    expect(firstMaterial.roughness).toBe(0.2);
+    expect(firstMaterial.color.getHexString()).toBe('112233');
+    expect(secondMaterial.roughness).toBe(1);
+    expect(secondMaterial.color.getHexString()).toBe('ffffff');
+});
+test('Theatre compound configs are cached and preserve slot defaults', () => {
+    const { root } = modelWithTwoMeshes();
+    const slots = collectMaterialSlots(root);
+    const first = createMaterialOverridesConfig(slots);
+    const second = createMaterialOverridesConfig(slots);
+    expect(second).toBe(first);
+});
+test('texture updates dispose replacements, and empty IDs restore immutable originals', async () => {
+    const { root, a } = modelWithTwoMeshes();
+    const original = new Texture();
+    const sourceMaterial = a.material;
+    sourceMaterial.map = original;
+    cloneModelMaterials(root);
+    const material = a.material;
+    const slots = collectMaterialSlots(root);
+    const first = new Texture();
+    const second = new Texture();
+    const firstDispose = jest.spyOn(first, 'dispose');
+    const secondDispose = jest.spyOn(second, 'dispose');
+    const textures = new Map([
+        ['blob:first', first],
+        ['blob:second', second],
+    ]);
+    const invalidate = jest.fn();
+    const controller = createMaterialTextureController({
+        getBlobUrl: async (blobId) => `url:${blobId}`,
+        loadTexture: async (url) => textures.get(url.slice(4)),
+        invalidate,
+    });
+    const initialVersion = material.version;
+    await controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'blob:first' },
+    });
+    expect(material.map).toBe(first);
+    expect(material.version).toBeGreaterThan(initialVersion);
+    await controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'blob:second' },
+    });
+    expect(material.map).toBe(second);
+    expect(firstDispose).toHaveBeenCalledTimes(1);
+    await controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: '' },
+    });
+    expect(material.map).toBe(original);
+    expect(secondDispose).toHaveBeenCalledTimes(1);
+    expect(invalidate).toHaveBeenCalled();
+    controller.dispose();
+});
+test('texture load failures report the slot and property through onError', async () => {
+    const { root } = modelWithTwoMeshes();
+    cloneModelMaterials(root);
+    const slots = collectMaterialSlots(root);
+    const cause = new Error('unsupported image');
+    const onError = jest.fn();
+    const controller = createMaterialTextureController({
+        getBlobUrl: async (blobId) => blobId,
+        loadTexture: async () => {
+            throw cause;
+        },
+        onError,
+        invalidate: () => { },
+    });
+    await controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'broken-texture' },
+    });
+    expect(onError).toHaveBeenCalledWith(cause, slots[0].slotId, 'mapBlobId');
+    controller.dispose();
+});
+test('stale texture loads cannot overwrite a newer selection and are disposed', async () => {
+    const { root, a } = modelWithTwoMeshes();
+    cloneModelMaterials(root);
+    const slots = collectMaterialSlots(root);
+    const stale = new Texture();
+    const current = new Texture();
+    const staleDispose = jest.spyOn(stale, 'dispose');
+    let resolveStale;
+    const controller = createMaterialTextureController({
+        getBlobUrl: async (blobId) => blobId,
+        loadTexture: (url) => url === 'stale'
+            ? new Promise((resolve) => {
+                resolveStale = resolve;
+            })
+            : Promise.resolve(current),
+        invalidate: () => { },
+    });
+    const staleUpdate = controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'stale' },
+    });
+    await controller.update(root, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'current' },
+    });
+    resolveStale(stale);
+    await staleUpdate;
+    expect(a.material.map).toBe(current);
+    expect(staleDispose).toHaveBeenCalledTimes(1);
+    controller.dispose();
+});
+test('placed-instance teardown preserves shared original textures and disposes overrides once', async () => {
+    const { root, a, b } = modelWithTwoMeshes();
+    const original = new Texture();
+    a.material.map = original;
+    b.material.map = original;
+    const first = SkeletonUtils.clone(root);
+    const second = SkeletonUtils.clone(root);
+    cloneModelMaterials(first);
+    cloneModelMaterials(second);
+    const slots = collectMaterialSlots(first);
+    const override = new Texture();
+    const originalDispose = jest.spyOn(original, 'dispose');
+    const overrideDispose = jest.spyOn(override, 'dispose');
+    const firstMaterial = first.children[0]
+        .material;
+    const secondMaterial = second.children[0]
+        .material;
+    const materialDispose = jest.spyOn(firstMaterial, 'dispose');
+    const controller = createMaterialTextureController({
+        getBlobUrl: async (blobId) => blobId,
+        loadTexture: async () => override,
+        invalidate: () => { },
+    });
+    await controller.update(first, slots, {
+        [slots[0].slotKey]: { mapBlobId: 'override' },
+    });
+    controller.dispose();
+    disposeObjectTree(first, { disposeTextures: false });
+    expect(originalDispose).not.toHaveBeenCalled();
+    expect(secondMaterial.map).toBe(original);
+    expect(overrideDispose).toHaveBeenCalledTimes(1);
+    expect(materialDispose).toHaveBeenCalledTimes(1);
+});

package/dist/materials/types.d.ts

@@ -0,0 +1,20 @@
+export type MaterialValues = {
+    color: string;
+    metalness: number;
+    roughness: number;
+    emissive: string;
+    opacity: number;
+    mapBlobId: string;
+    normalMapBlobId: string;
+    roughnessMapBlobId: string;
+    metalnessMapBlobId: string;
+    emissiveMapBlobId: string;
+};
+export type MaterialSlot = {
+    slotId: string;
+    slotKey: string;
+    meshName: string;
+    materialName: string;
+    values: MaterialValues;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/materials/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/materials/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,kBAAkB,EAAE,MAAM,CAAA;IAC1B,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,cAAc,CAAA;CACvB,CAAA"}

package/dist/materials/types.js

@@ -0,0 +1 @@
+export {};

package/dist/materials/useModelMaterials.d.ts

@@ -0,0 +1,10 @@
+import type { ISheetObject } from '@dreamerbird/core';
+import { type Group } from 'three';
+import type { MaterialSlot } from './types';
+export declare function useModelMaterials({ instance, sheetObject, slots, invalidate, }: {
+    instance: Group;
+    sheetObject: ISheetObject<any> | undefined;
+    slots: MaterialSlot[];
+    invalidate(): void;
+}): void;
+//# sourceMappingURL=useModelMaterials.d.ts.map

package/dist/materials/useModelMaterials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModelMaterials.d.ts","sourceRoot":"","sources":["../../src/materials/useModelMaterials.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAA;AAGnD,OAAO,EAAgB,KAAK,KAAK,EAAC,MAAM,OAAO,CAAA;AAO/C,OAAO,KAAK,EAAC,YAAY,EAAiB,MAAM,SAAS,CAAA;AAEzD,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,WAAW,EACX,KAAK,EACL,UAAU,GACX,EAAE;IACD,QAAQ,EAAE,KAAK,CAAA;IACf,WAAW,EAAE,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAA;IAC1C,KAAK,EAAE,YAAY,EAAE,CAAA;IACrB,UAAU,IAAI,IAAI,CAAA;CACnB,GAAG,IAAI,CA8BP"}

package/dist/materials/useModelMaterials.js

@@ -0,0 +1,26 @@
+import { useVal } from '@dreamerbird/react';
+import { useEffect, useMemo } from 'react';
+import { TextureLoader } from 'three';
+import { getLibrary } from '../assetLibrary/library';
+import { LibraryError } from '../assetLibrary/source';
+import { applyMaterialScalars, createMaterialTextureController, } from './modelMaterials';
+export function useModelMaterials({ instance, sheetObject, slots, invalidate, }) {
+    const overrides = useVal(sheetObject?.props.materialOverrides) ?? {};
+    const controller = useMemo(() => {
+        const loader = new TextureLoader();
+        return createMaterialTextureController({
+            getBlobUrl: (blobId) => getLibrary().getBlobUrl(blobId),
+            loadTexture: (url) => loader.loadAsync(url),
+            onError: (error, slotId, property) => {
+                getLibrary().reportError(new LibraryError('network', `材质贴图加载失败: ${slotId}/${property}`, error));
+            },
+            invalidate,
+        });
+    }, [instance, invalidate]);
+    useEffect(() => {
+        applyMaterialScalars(instance, slots, overrides);
+        invalidate();
+        void controller.update(instance, slots, overrides);
+    }, [instance, slots, overrides, controller, invalidate]);
+    useEffect(() => () => controller.dispose(), [controller]);
+}

package/dist/materials/useModelMaterials.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useModelMaterials.test.d.ts.map

package/dist/materials/useModelMaterials.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModelMaterials.test.d.ts","sourceRoot":"","sources":["../../src/materials/useModelMaterials.test.tsx"],"names":[],"mappings":""}

package/dist/materials/useModelMaterials.test.js

@@ -0,0 +1,75 @@
+let projectSeq = 0;
+jest.doMock('three', () => {
+    const actual = jest.requireActual('three');
+    return {
+        ...actual,
+        TextureLoader: class {
+            async loadAsync(_url) {
+                const texture = new actual.Texture();
+                loadedTextures.push(texture);
+                return texture;
+            }
+        },
+    };
+});
+jest.doMock('../assetLibrary/library', () => ({
+    ...jest.requireActual('../assetLibrary/library'),
+    getLibrary: () => ({ getBlobUrl: async (blobId) => blobId }),
+}));
+const loadedTextures = [];
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+const React = require('react');
+const ReactDOM = require('react-dom/client');
+const core = require('@dreamerbird/core');
+const three = require('three');
+const { useModelMaterials } = require('./useModelMaterials');
+const { cloneModelMaterials, collectMaterialSlots, createMaterialOverridesConfig, } = require('./modelMaterials');
+function makeInstance() {
+    const instance = new three.Group();
+    const mesh = new three.Mesh(new three.BoxGeometry(), new three.MeshStandardMaterial());
+    mesh.name = 'Body';
+    instance.add(mesh);
+    cloneModelMaterials(instance);
+    return instance;
+}
+function Harness({ instance, slots, sheetObject, }) {
+    useModelMaterials({ instance, slots, sheetObject, invalidate: () => { } });
+    return null;
+}
+test('instance replacement disposes the previous controller textures', async () => {
+    loadedTextures.length = 0;
+    const first = makeInstance();
+    const second = makeInstance();
+    const firstSlots = collectMaterialSlots(first);
+    const secondSlots = collectMaterialSlots(second);
+    const project = core.getProject(`material-hook-${++projectSeq}`);
+    const sheetObject = project.sheet('Scene').object('Foo', {
+        materialOverrides: createMaterialOverridesConfig(firstSlots),
+    });
+    sheetObject.initialValue = {
+        materialOverrides: {
+            [firstSlots[0].slotKey]: {
+                ...firstSlots[0].values,
+                mapBlobId: 'override',
+            },
+        },
+    };
+    const element = document.createElement('div');
+    const root = ReactDOM.createRoot(element);
+    try {
+        await React.act(async () => {
+            root.render(React.createElement(Harness, { instance: first, slots: firstSlots, sheetObject: sheetObject }));
+        });
+        const oldTexture = loadedTextures[0];
+        const oldDispose = jest.spyOn(oldTexture, 'dispose');
+        await React.act(async () => {
+            root.render(React.createElement(Harness, { instance: second, slots: secondSlots, sheetObject: sheetObject }));
+        });
+        expect(loadedTextures).toHaveLength(2);
+        expect(oldDispose).toHaveBeenCalledTimes(1);
+    }
+    finally {
+        await React.act(async () => root.unmount());
+    }
+});
+export {};

package/dist/poses.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 内置静态姿势库的公开入口(包根与 `@dreamerbird/camera-studio/poses`
+ * 子路径同时导出)。
+ *
+ * 姿势数据随包编译进 JS,不依赖 IndexedDB / 网络 / React。引用本包的
+ * 项目可以直接列出姿势、把 `entry.bones` 写进自己的 THREE 骨架,或交给
+ * Agent API 的 `poses.applyCustom`。
+ *
+ * - id 稳定:`seed-pose-<key>`,与场景里已保存的姿势引用一致。
+ * - rig 是内置族代表模型(Y Bot)的 Mixamo 骨架 id;导入同款 Mixamo
+ *   模型得到的 rig 与之相等,跨项目可直接复用。
+ * - QBX 手势条目只包含手指骨,是叠加片段,不覆盖身体姿势。
+ */
+import { applyPose, captureBindPose, capturePose } from './assetLibrary/pose';
+import type { PoseEntry } from './assetLibrary/types';
+export { applyPose, captureBindPose, capturePose };
+/** 内置姿势所属骨架族(内置 Y Bot 的 rig id) */
+export declare const BUILTIN_POSE_RIG: string;
+/** 内置姿势数据来源,用于署名/展示;不影响运行时行为 */
+export declare const BUILTIN_POSE_SOURCES: readonly [{
+    readonly id: "procedural";
+    readonly name: "内置程序化基础姿势";
+}, {
+    readonly id: "dpl";
+    readonly name: "Dynamic Pose Library Free (BlendAtlas)";
+}, {
+    readonly id: "qbx";
+    readonly name: "QBX Pose Asset Pack";
+}];
+export type BuiltinPoseSourceId = (typeof BUILTIN_POSE_SOURCES)[number]['id'];
+/**
+ * 列出全部内置静态姿势。返回的条目是包内共享的只读数据,请勿原地修改;
+ * 需要改骨骼时先拷贝 `bones`。
+ */
+export declare function listBuiltinPoses(): PoseEntry[];
+/** 按稳定 id 取内置姿势;未知 id 返回 undefined。 */
+export declare function getBuiltinPose(id: string): PoseEntry | undefined;
+//# sourceMappingURL=poses.d.ts.map

package/dist/poses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poses.d.ts","sourceRoot":"","sources":["../src/poses.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAC,SAAS,EAAE,eAAe,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAA;AAK3E,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAA;AAEnD,OAAO,EAAC,SAAS,EAAE,eAAe,EAAE,WAAW,EAAC,CAAA;AAEhD,mCAAmC;AACnC,eAAO,MAAM,gBAAgB,QAAmB,CAAA;AAEhD,gCAAgC;AAChC,eAAO,MAAM,oBAAoB;;;;;;;;;EAIvB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA;AAI7E;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,SAAS,EAAE,CAM9C;AAED,uCAAuC;AACvC,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAGhE"}