@dreamerbird/camera-studio 0.0.0-stage → 0.1.0

package/dist/pathModel.test.js

@@ -0,0 +1,394 @@
+import { Matrix4, Quaternion, Vector3 } from 'three';
+import { autoHandles, buildCurve, buildLinePositions, composePathMatrix, directionArrowMatrices, effectiveHandles, effectiveUs, extendPathPoint, IDENTITY_PATH_TRANSFORM, nextPointKey, parsePathPoints, sampleEntries, seedArcPoints, serializePathPoints, withDraggedHandle, withMovedPoint, withMovedU, withResetU, } from './pathModel';
+const pt = (key, x, y = 0, z = 0) => ({
+    key,
+    position: { x, y, z },
+});
+describe('parsePathPoints / serializePathPoints', () => {
+    it('往返一致(含手柄)', () => {
+        const entries = [
+            { key: 'P1', position: { x: 1, y: 2, z: 3 } },
+            {
+                key: 'P2',
+                position: { x: -1, y: 0, z: 0.5 },
+                handles: { left: { x: -0.5, y: 0, z: 0 }, right: { x: 0.5, y: 0, z: 0 } },
+            },
+        ];
+        expect(parsePathPoints(serializePathPoints(entries))).toEqual(entries);
+    });
+    it('坏 JSON / 非数组 / 缺字段都当空名单', () => {
+        expect(parsePathPoints('not json')).toEqual([]);
+        expect(parsePathPoints('{"a":1}')).toEqual([]);
+        expect(parsePathPoints('[{"key":"P1"}]')).toEqual([]);
+        expect(parsePathPoints('[{"key":"P1","position":{"x":1,"y":"bad","z":3}}]')).toEqual([]);
+    });
+    it('坏手柄被丢弃(回自动),点本身保留', () => {
+        const parsed = parsePathPoints('[{"key":"P1","position":{"x":1,"y":2,"z":3},"handles":{"left":{"x":"bad"}}}]');
+        expect(parsed).toEqual([{ key: 'P1', position: { x: 1, y: 2, z: 3 } }]);
+    });
+    it('进度锚点 u 往返一致;坏 u 丢弃,越界夹回 0~1', () => {
+        const parsed = parsePathPoints('[{"key":"P1","position":{"x":0,"y":0,"z":0},"u":0.3},' +
+            '{"key":"P2","position":{"x":1,"y":0,"z":0},"u":"bad"},' +
+            '{"key":"P3","position":{"x":2,"y":0,"z":0},"u":7}]');
+        expect(parsed[0].u).toBe(0.3);
+        expect(parsed[1].u).toBeUndefined();
+        expect(parsed[2].u).toBe(1);
+        // 显式 u 序列化后再读回来不变
+        const round = parsePathPoints(serializePathPoints(parsed));
+        expect(round[0].u).toBe(0.3);
+        expect(round[2].u).toBe(1);
+    });
+});
+describe('nextPointKey', () => {
+    it('空名单从 P1 开始', () => {
+        expect(nextPointKey([])).toBe('P1');
+    });
+    it('取最大编号 +1,删过的号不复用', () => {
+        expect(nextPointKey([pt('P1', 0), pt('P3', 0)])).toBe('P4');
+    });
+    it('忽略不符合命名规范的 key', () => {
+        expect(nextPointKey([{ key: 'foo', position: { x: 0, y: 0, z: 0 } }])).toBe('P1');
+    });
+});
+describe('seedArcPoints', () => {
+    it('三个点,起点就是当前机位', () => {
+        const [p0, p1, p2] = seedArcPoints({ x: 8, y: 3, z: 0 }, { x: 0, y: 0, z: 0 });
+        expect(p0).toEqual({ x: 8, y: 3, z: 0 });
+        // 绕 Y 轴转 60° 后离目标距离不变
+        const r0 = Math.hypot(8, 0);
+        const r2 = Math.hypot(p2.x, p2.z);
+        expect(r2).toBeCloseTo(r0, 5);
+        // 中点向外鼓:离目标比首尾连线的中点更远
+        const midDist = Math.hypot((8 + p2.x) / 2, (0 + p2.z) / 2);
+        expect(Math.hypot(p1.x, p1.z)).toBeGreaterThan(midDist);
+    });
+});
+describe('extendPathPoint', () => {
+    it('沿最后一段方向延伸等长', () => {
+        expect(extendPathPoint([pt('P1', 0), pt('P2', 1, 2, 3)])).toEqual({
+            x: 2,
+            y: 4,
+            z: 6,
+        });
+    });
+    it('只有一个点时往 +x 挪 2', () => {
+        expect(extendPathPoint([pt('P1', 5, 1, 1)])).toEqual({ x: 7, y: 1, z: 1 });
+    });
+});
+describe('autoHandles / effectiveHandles', () => {
+    it('中间点:两侧等长共线,方向沿前后点差分', () => {
+        const h = autoHandles([
+            { x: 0, y: 0, z: 0 },
+            { x: 3, y: 0, z: 0 },
+            { x: 3, y: 6, z: 0 },
+        ], 1);
+        // 差分 (3,6,0)/6 = (0.5,1,0)
+        expect(h.right).toEqual({ x: 0.5, y: 1, z: 0 });
+        expect(h.left).toEqual({ x: -0.5, y: -1, z: 0 });
+    });
+    it('端点:单侧差分的 1/3,另一侧镜像', () => {
+        const positions = [
+            { x: 0, y: 0, z: 0 },
+            { x: 3, y: 0, z: 0 },
+            { x: 6, y: 0, z: 0 },
+        ];
+        const first = autoHandles(positions, 0);
+        expect(first.right).toEqual({ x: 1, y: 0, z: 0 });
+        expect(first.left).toEqual({ x: -1, y: 0, z: 0 });
+        const last = autoHandles(positions, 2);
+        expect(last.left).toEqual({ x: -1, y: 0, z: 0 });
+        expect(last.right).toEqual({ x: 1, y: 0, z: 0 });
+    });
+    it('有手动手柄时优先手动', () => {
+        const manual = { left: { x: -2, y: 0, z: 0 }, right: { x: 2, y: 0, z: 0 } };
+        const entries = [{ ...pt('P1', 0), handles: manual }, pt('P2', 5)];
+        expect(effectiveHandles(entries, 0)).toBe(manual);
+    });
+});
+describe('withMovedPoint', () => {
+    it('只换位置,手柄偏移原样保留(跟着点走)', () => {
+        const handles = { left: { x: -1, y: 0, z: 0 }, right: { x: 1, y: 0, z: 0 } };
+        const entries = [{ ...pt('P1', 0), handles }, pt('P2', 5)];
+        const next = withMovedPoint(entries, 'P1', { x: 1, y: 1, z: 1 });
+        expect(next[0]).toEqual({ key: 'P1', position: { x: 1, y: 1, z: 1 }, handles });
+        expect(next[1]).toBe(entries[1]);
+    });
+});
+describe('withDraggedHandle', () => {
+    it('自动点一拖变手动:被拖侧取新值,另一侧镜像方向、保留自动长度', () => {
+        // P2 的自动切线:差分 (P3-P1)/6 = (1,0,0),左长 1 右长 1
+        const entries = [pt('P1', 0), pt('P2', 3), pt('P3', 6)];
+        const next = withDraggedHandle(entries, 'P2', 'right', { x: 0, y: 2, z: 0 });
+        const h = next[1].handles;
+        expect(h.right).toEqual({ x: 0, y: 2, z: 0 });
+        // 左侧镜像到 (0,-1,0) 方向,长度保留自动值 1
+        expect(h.left.x).toBeCloseTo(0, 6);
+        expect(h.left.y).toBeCloseTo(-1, 6);
+        expect(h.left.z).toBeCloseTo(0, 6);
+    });
+    it('手动点再拖:另一侧长度保留手动值', () => {
+        const entries = [
+            pt('P1', 0),
+            {
+                ...pt('P2', 3),
+                handles: { left: { x: -4, y: 0, z: 0 }, right: { x: 4, y: 0, z: 0 } },
+            },
+            pt('P3', 6),
+        ];
+        const next = withDraggedHandle(entries, 'P2', 'left', { x: 0, y: 1, z: 0 });
+        const h = next[1].handles;
+        expect(h.left).toEqual({ x: 0, y: 1, z: 0 });
+        // 右侧镜像到 (0,-4,0):长度保留 4
+        expect(h.right.x).toBeCloseTo(0, 6);
+        expect(h.right.y).toBeCloseTo(-4, 6);
+    });
+    it('找不到 key 时原样返回副本', () => {
+        const entries = [pt('P1', 0), pt('P2', 3)];
+        const next = withDraggedHandle(entries, 'PX', 'left', { x: 1, y: 0, z: 0 });
+        expect(next).toEqual(entries);
+        expect(next).not.toBe(entries);
+    });
+});
+describe('effectiveUs / 锚点采样', () => {
+    const out = new Vector3();
+    it('无显式锚点:端点 0/1,单调,与弧长等比采样结果一致', () => {
+        const entries = [pt('P1', 0), pt('P2', 3, 4, 0), pt('P3', 6, 4, 0)];
+        const us = effectiveUs(entries);
+        expect(us[0]).toBe(0);
+        expect(us[2]).toBe(1);
+        expect(us[1]).toBeGreaterThan(0);
+        expect(us[1]).toBeLessThan(1);
+        // 全部自动时和旧的全程弧长采样一致(弧长是数值近似,两者细分档不同,放到小数点后 3 位)
+        const curve = buildCurve(entries);
+        for (const p of [0, 0.25, 0.5, 0.75, 1]) {
+            const legacy = curve.getPointAt(p);
+            sampleEntries(entries, p, out);
+            expect(out.x).toBeCloseTo(legacy.x, 3);
+            expect(out.y).toBeCloseTo(legacy.y, 3);
+            expect(out.z).toBeCloseTo(legacy.z, 3);
+        }
+    });
+    it('显式锚点生效:进度=u 时正好落在该点上,其余点自动插值', () => {
+        // 共线四点,弧长分数本来是 0, 1/3, 2/3, 1;把 P2 钉到 0.5
+        const entries = [
+            pt('P1', 0),
+            { ...pt('P2', 1), u: 0.5 },
+            pt('P3', 2),
+            pt('P4', 3),
+        ];
+        const us = effectiveUs(entries);
+        expect(us[1]).toBe(0.5);
+        // P3 在锚点 P2(0.5) 和终点(1) 之间按弧长比例:(2-1)/(3-1)=0.5 → 0.75
+        expect(us[2]).toBeCloseTo(0.75, 6);
+        // 进度 0.5 正好过 P2
+        sampleEntries(entries, 0.5, out);
+        expect(out.x).toBeCloseTo(1, 6);
+        // 进度 0.75 正好过 P3
+        sampleEntries(entries, 0.75, out);
+        expect(out.x).toBeCloseTo(2, 6);
+        // 0.25 落在 P1→P2 段中点(局部弧长一半)
+        sampleEntries(entries, 0.25, out);
+        expect(out.x).toBeCloseTo(0.5, 3);
+    });
+    it('违反单调的显式锚点被夹到前锚点值', () => {
+        const entries = [
+            pt('P1', 0),
+            { ...pt('P2', 1), u: 0.6 },
+            { ...pt('P3', 2), u: 0.2 },
+            pt('P4', 3),
+        ];
+        const us = effectiveUs(entries);
+        expect(us[1]).toBe(0.6);
+        expect(us[2]).toBe(0.6);
+        // 夹出来的零宽段采样不炸,连续过渡
+        sampleEntries(entries, 0.6, out);
+        expect(Number.isFinite(out.x)).toBe(true);
+    });
+    it('withMovedU:写入并夹在相邻锚点之间;端点不可调', () => {
+        const entries = [pt('P1', 0), pt('P2', 1), pt('P3', 2)];
+        const next = withMovedU(entries, 'P2', 0.9);
+        expect(next[1].u).toBeCloseTo(0.9, 6);
+        // 超过右邻(1)被夹回
+        const clamped = withMovedU(entries, 'P2', 5);
+        expect(clamped[1].u).toBeLessThan(1);
+        // 端点不动
+        expect(withMovedU(entries, 'P1', 0.5)[0].u).toBeUndefined();
+    });
+    it('withResetU:清掉显式锚点回自动', () => {
+        const entries = [pt('P1', 0), { ...pt('P2', 1), u: 0.5 }, pt('P3', 2)];
+        const next = withResetU(entries, 'P2');
+        expect(next[1].u).toBeUndefined();
+        // 其他点不动,无 u 的点返回原引用
+        expect(next[0]).toBe(entries[0]);
+    });
+});
+describe('sampleEntries / sampleCurve', () => {
+    const out = new Vector3();
+    it('0 个点返回 false(调用方回退手动)', () => {
+        expect(sampleEntries([], 0.5, out)).toBe(false);
+    });
+    it('1 个点时任何进度都取它(单点路径)', () => {
+        const entries = [pt('P1', 1, 2, 3)];
+        for (const u of [0, 0.3, 1]) {
+            expect(sampleEntries(entries, u, out)).toBe(true);
+            expect(out.x).toBe(1);
+            expect(out.y).toBe(2);
+            expect(out.z).toBe(3);
+        }
+    });
+    it('进度越界被夹到 0..1', () => {
+        const entries = [pt('P1', 0), pt('P2', 10)];
+        sampleEntries(entries, -1, out);
+        expect(out.x).toBeCloseTo(0, 5);
+        sampleEntries(entries, 2, out);
+        expect(out.x).toBeCloseTo(10, 5);
+    });
+    it('弧长等比:两段不等长时,u=0.5 落在全长一半处', () => {
+        // 共线三点 (0,0,0)->(1,0,0)->(11,0,0):第一段长 1,第二段长 10,全长 11
+        // 共线时自动手柄也共线,曲线不偏离 x 轴
+        const entries = [pt('P1', 0), pt('P2', 1), pt('P3', 11)];
+        sampleEntries(entries, 0.5, out);
+        // 弧长一半 = 5.5,落在第二段上 x≈5.5(弧长映射是数值近似,放宽到 0.5)
+        expect(out.x).toBeGreaterThan(4.5);
+        expect(out.x).toBeLessThan(6.5);
+        // 若是参数等比(getPoint),u=0.5 会落在两段参数的分界 x≈1 附近
+        expect(out.x).toBeGreaterThan(2);
+    });
+    it('手动手柄改变曲线形状(拉出鼓包)', () => {
+        // 两个点一条直线段,把两端手柄都往 +y 拉,中点应明显抬离 x 轴
+        const entries = [
+            {
+                ...pt('P1', 0),
+                handles: { left: { x: 0, y: 4, z: 0 }, right: { x: 0, y: 4, z: 0 } },
+            },
+            {
+                ...pt('P2', 10),
+                handles: { left: { x: 0, y: 4, z: 0 }, right: { x: 0, y: 4, z: 0 } },
+            },
+        ];
+        sampleEntries(entries, 0.5, out);
+        expect(out.y).toBeGreaterThan(2);
+    });
+});
+describe('buildLinePositions', () => {
+    it('不足两个点返回 0', () => {
+        const buf = new Float32Array(30);
+        expect(buildLinePositions([pt('P1', 0)], buf)).toBe(0);
+        expect(buildLinePositions([], buf)).toBe(0);
+    });
+    it('顶点数随缓冲自适应,不溢出,首尾是路径端点', () => {
+        const buf = new Float32Array(33 * 3);
+        const entries = [pt('P1', 0), pt('P2', 1), pt('P3', 2)];
+        const n = buildLinePositions(entries, buf);
+        expect(n).toBeLessThanOrEqual(33);
+        expect(n).toBeGreaterThan(3);
+        expect(buf[0]).toBeCloseTo(0, 5);
+        expect(buf[(n - 1) * 3]).toBeCloseTo(2, 5);
+    });
+    it('点多时每段细分自动降档,仍然不溢出', () => {
+        const buf = new Float32Array(64 * 3);
+        const entries = Array.from({ length: 20 }, (_, i) => pt(`P${i + 1}`, i));
+        const n = buildLinePositions(entries, buf);
+        expect(n).toBeLessThanOrEqual(64);
+        expect(buf[0]).toBeCloseTo(0, 5);
+        expect(buf[(n - 1) * 3]).toBeCloseTo(19, 5);
+    });
+});
+describe('buildCurve', () => {
+    it('不足两个点返回 null', () => {
+        expect(buildCurve([])).toBeNull();
+        expect(buildCurve([pt('P1', 0)])).toBeNull();
+    });
+});
+describe('composePathMatrix(路径整体变换)', () => {
+    const tr = (over) => ({
+        position: { x: 0, y: 0, z: 0 },
+        rotation: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+        ...over,
+    });
+    const apply = (t, x, y, z) => new Vector3(x, y, z).applyMatrix4(composePathMatrix(t, new Matrix4()));
+    it('单位变换:局部 = 世界(老场景无缝过渡)', () => {
+        const p = apply(IDENTITY_PATH_TRANSFORM, 8, 4.5, -2);
+        expect(p.x).toBeCloseTo(8, 10);
+        expect(p.y).toBeCloseTo(4.5, 10);
+        expect(p.z).toBeCloseTo(-2, 10);
+    });
+    it('平移:所有点统一位移', () => {
+        const p = apply(tr({ position: { x: 2, y: -1, z: 0.5 } }), 8, 4.5, -2);
+        expect(p.x).toBeCloseTo(10, 10);
+        expect(p.y).toBeCloseTo(3.5, 10);
+        expect(p.z).toBeCloseTo(-1.5, 10);
+    });
+    it('绕 Y 转 90°:+x 轴转到 -z 轴', () => {
+        const p = apply(tr({ rotation: { x: 0, y: Math.PI / 2, z: 0 } }), 1, 0, 0);
+        expect(p.x).toBeCloseTo(0, 10);
+        expect(p.z).toBeCloseTo(-1, 10);
+    });
+    it('组合顺序 = 缩放→旋转→平移(同 three 的 Object3D)', () => {
+        const p = apply(tr({
+            position: { x: 10, y: 0, z: 0 },
+            rotation: { x: 0, y: Math.PI / 2, z: 0 },
+            scale: { x: 2, y: 2, z: 2 },
+        }), 1, 0, 0);
+        // (1,0,0) → 缩放 (2,0,0) → 旋转 (0,0,-2) → 平移 (10,0,-2)
+        expect(p.x).toBeCloseTo(10, 10);
+        expect(p.z).toBeCloseTo(-2, 10);
+    });
+    it('逆矩阵往返:世界→局部→世界 还原(拖拽写回靠这个)', () => {
+        const t = tr({
+            position: { x: 3, y: -1, z: 2 },
+            rotation: { x: 0.3, y: -0.7, z: 0.1 },
+            scale: { x: 2, y: 0.5, z: 1.5 },
+        });
+        const m = composePathMatrix(t, new Matrix4());
+        const inv = m.clone().invert();
+        const world = new Vector3(7, 2, -4);
+        const roundTrip = world.clone().applyMatrix4(inv).applyMatrix4(m);
+        expect(roundTrip.distanceTo(world)).toBeLessThan(1e-10);
+    });
+});
+describe('directionArrowMatrices(方向箭头)', () => {
+    const decompose = (m) => {
+        const pos = new Vector3();
+        const q = new Quaternion();
+        const s = new Vector3();
+        m.decompose(pos, q, s);
+        return { pos, q };
+    };
+    it('空曲线/单点 → 没有箭头', () => {
+        expect(directionArrowMatrices(null, 64)).toEqual([]);
+        expect(directionArrowMatrices(buildCurve([pt('P1', 0)]), 64)).toEqual([]);
+    });
+    it('直线沿 +x:箭头全在线上,朝向 +x(单位圆锥从 +Y 转过去)', () => {
+        const curve = buildCurve([pt('P1', 0), pt('P2', 10)]);
+        const mats = directionArrowMatrices(curve, 64);
+        // 长 10,间距 1.5 → 7 个
+        expect(mats.length).toBe(7);
+        for (const m of mats) {
+            const { pos, q } = decompose(m);
+            expect(pos.y).toBeCloseTo(0, 10);
+            expect(pos.z).toBeCloseTo(0, 10);
+            expect(pos.x).toBeGreaterThan(0);
+            expect(pos.x).toBeLessThan(10);
+            const dir = new Vector3(0, 1, 0).applyQuaternion(q);
+            expect(dir.x).toBeCloseTo(1, 5);
+            expect(dir.y).toBeCloseTo(0, 5);
+        }
+        // 沿行进方向 x 单调递增(箭头顺序 = 行进顺序)
+        for (let i = 1; i < mats.length; i++) {
+            expect(decompose(mats[i]).pos.x).toBeGreaterThan(decompose(mats[i - 1]).pos.x);
+        }
+    });
+    it('反向曲线:箭头指向反过来(-x)', () => {
+        const curve = buildCurve([pt('P1', 10), pt('P2', 0)]);
+        const { q } = decompose(directionArrowMatrices(curve, 64)[0]);
+        const dir = new Vector3(0, 1, 0).applyQuaternion(q);
+        expect(dir.x).toBeCloseTo(-1, 5);
+    });
+    it('总数不超容量上限', () => {
+        const entries = Array.from({ length: 20 }, (_, i) => pt(`P${i + 1}`, i * 5));
+        const mats = directionArrowMatrices(buildCurve(entries), 5);
+        expect(mats.length).toBe(5);
+    });
+});

package/dist/pathPresets.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 内置路径预设:几何形状 + 经典运镜,给落点返回一串世界坐标路径点。
+ * 纯函数,无 React/theatre 依赖。预设不可删改、不可自定义(用户决策)。
+ *
+ * 路径是相机轨迹。平面预设的点都在 y = center.y 上(高度由调用方取
+ * 活动相机当前 Y);运镜预设带高度变化(螺旋上升/俯冲等),y 是相对
+ * 落点的偏移。直线往返的"往返"由行进进度回摆实现,点列不重复。
+ */
+import type { Vec3Like } from './pathModel';
+export type PathPreset = {
+    id: 'circle' | 'line' | 'arc' | 'figure8' | 'dollyIn' | 'reveal' | 'spiralUp' | 'crane' | 'orbitPush' | 'dive' | 'figure8v';
+    name: string;
+    /** 英文运镜名(卡片副标题) */
+    en: string;
+    /** 缩略图动画:收尾相连的路径无限绕圈,开放路径往返 */
+    closed: boolean;
+    /** 缩略图一圈(或一个往返)的秒数 */
+    durSeconds: number;
+};
+export declare const PATH_PRESETS: readonly PathPreset[];
+/** 给落点返回该形状的路径点(世界坐标;y 为落点高度 + 各形状自身的偏移) */
+export declare function presetPoints(preset: PathPreset, center: Vec3Like): Vec3Like[];
+/**
+ * 预设放置方案:落点写进路径的位置变换,控制点围绕局部原点生成。
+ * 路径原点(整体移动箭头/原点标记的锚点)从此落在落点上;
+ * 世界位置 = 位置 + 局部点,与直接以 center 调 presetPoints 完全等价
+ * (放置时旋转/缩放是单位值,纯平移直接相加)。
+ */
+export declare function presetPlacement(preset: PathPreset, center: Vec3Like): {
+    points: Vec3Like[];
+    position: Vec3Like;
+};
+/**
+ * 模型点击放置的默认位:base(默认原点)被占时沿 +X 每次错开 2。
+ * XZ 平面距离小于 1.5 视为占用;100 次保底防死循环。
+ */
+export declare function findFreeSpot(occupied: readonly Vec3Like[], base?: Vec3Like): Vec3Like;
+//# sourceMappingURL=pathPresets.d.ts.map

package/dist/pathPresets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathPresets.d.ts","sourceRoot":"","sources":["../src/pathPresets.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAA;AAEzC,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EACE,QAAQ,GACR,MAAM,GACN,KAAK,GACL,SAAS,GACT,SAAS,GACT,QAAQ,GACR,UAAU,GACV,OAAO,GACP,WAAW,GACX,MAAM,GACN,UAAU,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,mBAAmB;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,+BAA+B;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,sBAAsB;IACtB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EA8B7C,CAAA;AAID,4CAA4C;AAC5C,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAsH7E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,GACf;IAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAC,CAK1C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,IAAI,GAAE,QAA6B,GAClC,QAAQ,CAYV"}

package/dist/pathPresets.js

@@ -0,0 +1,180 @@
+export const PATH_PRESETS = [
+    { id: 'circle', name: '环绕圆', en: 'Orbit', closed: true, durSeconds: 6 },
+    { id: 'line', name: '直线往返', en: 'Truck', closed: false, durSeconds: 4 },
+    { id: 'arc', name: '弧线', en: 'Arc', closed: false, durSeconds: 5 },
+    { id: 'figure8', name: '8 字', en: 'Figure-8', closed: true, durSeconds: 7 },
+    { id: 'dollyIn', name: '推近', en: 'Dolly In', closed: false, durSeconds: 3.5 },
+    { id: 'reveal', name: '拉远拉升', en: 'Reveal', closed: false, durSeconds: 5 },
+    {
+        id: 'spiralUp',
+        name: '螺旋上升',
+        en: 'Spiral Up',
+        closed: false,
+        durSeconds: 7,
+    },
+    { id: 'crane', name: '升降摇臂', en: 'Crane', closed: false, durSeconds: 4 },
+    {
+        id: 'orbitPush',
+        name: '环绕推近',
+        en: 'Orbit Push-in',
+        closed: false,
+        durSeconds: 6,
+    },
+    { id: 'dive', name: '俯冲', en: 'Dive', closed: false, durSeconds: 4 },
+    {
+        id: 'figure8v',
+        name: '立体 8 字',
+        en: 'Figure-8 Vert',
+        closed: true,
+        durSeconds: 8,
+    },
+];
+const TAU = Math.PI * 2;
+/** 给落点返回该形状的路径点(世界坐标;y 为落点高度 + 各形状自身的偏移) */
+export function presetPoints(preset, center) {
+    const { x: cx, y, z: cz } = center;
+    switch (preset.id) {
+        case 'circle': {
+            const r = 5;
+            const n = 8;
+            return Array.from({ length: n }, (_, i) => {
+                const a = (i / n) * TAU;
+                return { x: cx + r * Math.cos(a), y, z: cz + r * Math.sin(a) };
+            });
+        }
+        case 'line':
+            return [
+                { x: cx - 5, y, z: cz },
+                { x: cx + 5, y, z: cz },
+            ];
+        case 'arc': {
+            const r = 6;
+            const n = 5;
+            return Array.from({ length: n }, (_, i) => {
+                const a = (i / (n - 1)) * Math.PI;
+                return { x: cx + r * Math.cos(a), y, z: cz + r * Math.sin(a) };
+            });
+        }
+        case 'figure8': {
+            const r = 3;
+            const per = 6;
+            const pts = [];
+            // 左圆:圆心 (cx - r, cz),右缘过落点
+            for (let i = 0; i < per; i++) {
+                const a = (i / per) * TAU;
+                pts.push({ x: cx - r + r * Math.cos(a), y, z: cz + r * Math.sin(a) });
+            }
+            // 右圆:圆心 (cx + r, cz),左缘过落点
+            for (let i = 0; i < per; i++) {
+                const a = (i / per) * TAU;
+                pts.push({ x: cx + r - r * Math.cos(a), y, z: cz + r * Math.sin(a) });
+            }
+            return pts;
+        }
+        // ---- 经典运镜(带高度变化) ----
+        case 'dollyIn':
+            // 正对主体从远处推到近处,留 2 个身位不穿模
+            return [
+                { x: cx, y, z: cz + 10 },
+                { x: cx, y, z: cz + 2 },
+            ];
+        case 'reveal':
+            // 近低 → 远高:拉远同时爬升的揭示镜头
+            return [
+                { x: cx, y: y + 1, z: cz + 3 },
+                { x: cx, y: y + 3, z: cz + 8 },
+                { x: cx, y: y + 7, z: cz + 14 },
+            ];
+        case 'spiralUp': {
+            // 环绕同时爬升:1.5 圈,半径 5,升高 5
+            const r = 5;
+            const n = 16;
+            const turns = 1.5;
+            return Array.from({ length: n }, (_, i) => {
+                const t = i / (n - 1);
+                const a = t * turns * TAU;
+                return {
+                    x: cx + r * Math.cos(a),
+                    y: y + t * 5,
+                    z: cz + r * Math.sin(a),
+                };
+            });
+        }
+        case 'crane':
+            // 摇臂:低位贴地升到高位俯瞰,带轻微前推
+            return [
+                { x: cx, y: y + 0.5, z: cz + 6 },
+                { x: cx, y: y + 3.2, z: cz + 5.5 },
+                { x: cx, y: y + 6, z: cz + 5 },
+            ];
+        case 'orbitPush': {
+            // 水平螺旋收缩:绕一圈,半径 7 → 2.5,边绕边靠近
+            const n = 12;
+            return Array.from({ length: n }, (_, i) => {
+                const t = i / (n - 1);
+                const r = 7 + (2.5 - 7) * t;
+                const a = t * TAU;
+                return { x: cx + r * Math.cos(a), y, z: cz + r * Math.sin(a) };
+            });
+        }
+        case 'dive':
+            // 高远俯冲到低近
+            return [
+                { x: cx, y: y + 9, z: cz + 12 },
+                { x: cx, y: y + 5, z: cz + 8 },
+                { x: cx, y: y + 2.5, z: cz + 5 },
+                { x: cx, y: y + 1, z: cz + 3 },
+            ];
+        case 'figure8v': {
+            // 立体 8 字:平面 8 字叠加正弦起伏,左环低右环高
+            const r = 3;
+            const per = 6;
+            const pts = [];
+            for (let i = 0; i < per; i++) {
+                const a = (i / per) * TAU;
+                pts.push({
+                    x: cx - r + r * Math.cos(a),
+                    y: y + 1.2 * Math.sin(a),
+                    z: cz + r * Math.sin(a),
+                });
+            }
+            for (let i = 0; i < per; i++) {
+                const a = (i / per) * TAU;
+                pts.push({
+                    x: cx + r - r * Math.cos(a),
+                    y: y + 1.2 * Math.sin(a + Math.PI / 2),
+                    z: cz + r * Math.sin(a),
+                });
+            }
+            return pts;
+        }
+    }
+}
+/**
+ * 预设放置方案:落点写进路径的位置变换,控制点围绕局部原点生成。
+ * 路径原点(整体移动箭头/原点标记的锚点)从此落在落点上;
+ * 世界位置 = 位置 + 局部点,与直接以 center 调 presetPoints 完全等价
+ * (放置时旋转/缩放是单位值,纯平移直接相加)。
+ */
+export function presetPlacement(preset, center) {
+    return {
+        points: presetPoints(preset, { x: 0, y: 0, z: 0 }),
+        position: { ...center },
+    };
+}
+/**
+ * 模型点击放置的默认位:base(默认原点)被占时沿 +X 每次错开 2。
+ * XZ 平面距离小于 1.5 视为占用;100 次保底防死循环。
+ */
+export function findFreeSpot(occupied, base = { x: 0, y: 0, z: 0 }) {
+    const CLEAR_RADIUS = 1.5;
+    const STEP = 2;
+    let spot = { ...base };
+    for (let guard = 0; guard < 100; guard++) {
+        const clash = occupied.some((p) => Math.hypot(p.x - spot.x, p.z - spot.z) < CLEAR_RADIUS);
+        if (!clash)
+            return spot;
+        spot = { x: spot.x + STEP, y: base.y, z: base.z };
+    }
+    return spot;
+}

package/dist/pathPresets.test.d.ts

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

package/dist/pathPresets.test.d.ts.map

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