ai-chatbot/components/canvas/director/DirectorViewport.tsx

360 lines
12 KiB
TypeScript

"use client";
import {
forwardRef,
useEffect,
useImperativeHandle,
useRef,
useState,
} from "react";
import * as THREE from "three";
import { buildThreeAssetUrl } from "@/lib/canvas/three-asset-url";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
import {
directorImageSize,
type DirectorScene,
type DirectorObject,
} from "@/lib/video-canvas/director-scene";
export type DirectorViewportHandle = {
capture: () => Promise<{ blob: Blob; width: number; height: number }>;
};
type Props = {
scene: DirectorScene;
selected: string;
mode: "translate" | "rotate" | "scale";
cameraView: boolean;
onTransform: (id: string, patch: Partial<DirectorObject>) => void;
onCamera: (
position: [number, number, number],
target: [number, number, number],
) => void;
};
function dispose(root: THREE.Object3D) {
root.traverse((o) => {
if (o instanceof THREE.Mesh) {
o.geometry.dispose();
for (const m of Array.isArray(o.material) ? o.material : [o.material]) {
for (const value of Object.values(m))
if (value instanceof THREE.Texture) value.dispose();
m.dispose();
}
}
});
}
export const DirectorViewport = forwardRef<DirectorViewportHandle, Props>(
function DirectorViewport(props, ref) {
const host = useRef<HTMLDivElement>(null);
const latest = useRef(props);
latest.current = props;
const runtime = useRef<{
renderer: THREE.WebGLRenderer;
world: THREE.Scene;
camera: THREE.PerspectiveCamera;
orbit: OrbitControls;
transform: TransformControls;
helper: THREE.Object3D;
grid: THREE.GridHelper;
objects: THREE.Group;
pending: number;
resize: () => void;
} | null>(null);
const [ready, setReady] = useState(false);
const [error, setError] = useState("");
const [loading, setLoading] = useState(false);
useEffect(() => {
if (!host.current) return;
let renderer: THREE.WebGLRenderer;
try {
renderer = new THREE.WebGLRenderer({
antialias: true,
preserveDrawingBuffer: true,
});
} catch {
setError("无法初始化 3D 视图,请检查浏览器 WebGL 支持");
return;
}
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
renderer.outputColorSpace = THREE.SRGBColorSpace;
renderer.setClearColor("#c5cbd3");
host.current.appendChild(renderer.domElement);
renderer.domElement.setAttribute("aria-label", "3D 导演台场景");
Object.assign(renderer.domElement.style, {
position: "absolute",
left: "50%",
top: "50%",
transform: "translate(-50%, -50%)",
});
const world = new THREE.Scene();
world.background = new THREE.Color("#c5cbd3");
world.add(new THREE.HemisphereLight(0xffffff, 0x647080, 2.4));
const light = new THREE.DirectionalLight(0xffffff, 3);
light.position.set(4, 8, 5);
world.add(light);
const floor = new THREE.Mesh(
new THREE.PlaneGeometry(100, 100),
new THREE.MeshStandardMaterial({ color: 0xb1b6be, roughness: 1 }),
);
floor.rotation.x = -Math.PI / 2;
floor.position.y = -0.02;
world.add(floor);
const grid = new THREE.GridHelper(30, 30, 0x596573, 0x929daa);
world.add(grid);
const camera = new THREE.PerspectiveCamera(50, 1, 0.05, 500);
camera.position.set(4, 3, 7);
const orbit = new OrbitControls(camera, renderer.domElement);
orbit.target.set(0, 1, 0);
orbit.minDistance = 0.3;
orbit.maxDistance = 80;
const transform = new TransformControls(camera, renderer.domElement);
const helper = transform.getHelper();
world.add(helper);
const objects = new THREE.Group();
world.add(objects);
transform.addEventListener("dragging-changed", (e) => {
orbit.enabled = !e.value && !latest.current.cameraView;
});
transform.addEventListener("mouseUp", () => {
const o = transform.object;
if (o)
latest.current.onTransform(o.name, {
position: o.position.toArray(),
rotation: [o.rotation.x, o.rotation.y, o.rotation.z],
scale: o.scale.toArray(),
});
});
orbit.addEventListener("end", () =>
latest.current.onCamera(
camera.position.toArray(),
orbit.target.toArray(),
),
);
const resize = () => {
if (!host.current) return;
const { width, height } = host.current.getBoundingClientRect();
const size = directorImageSize(latest.current.scene.ratio);
const aspect = size.width / size.height;
const fitWidth = Math.max(1, Math.min(width, height * aspect));
renderer.setSize(fitWidth, fitWidth / aspect);
camera.aspect = aspect;
camera.updateProjectionMatrix();
};
const state = {
renderer,
world,
camera,
orbit,
transform,
helper,
grid,
objects,
pending: 0,
resize,
};
runtime.current = state;
const observer = new ResizeObserver(resize);
observer.observe(host.current);
resize();
renderer.setAnimationLoop(() => {
orbit.update();
renderer.render(world, camera);
});
setReady(true);
return () => {
runtime.current = null;
observer.disconnect();
renderer.setAnimationLoop(null);
transform.dispose();
orbit.dispose();
dispose(world);
renderer.dispose();
renderer.domElement.remove();
};
}, []);
useEffect(() => {
const r = runtime.current;
if (!r || !ready) return;
let active = true;
r.transform.detach();
r.objects.children.slice().forEach((o) => {
dispose(o);
r.objects.remove(o);
});
setError("");
r.pending = 0;
const attach = (object: THREE.Object3D, item: DirectorObject) => {
if (!active) {
dispose(object);
return;
}
object.name = item.id;
object.position.fromArray(item.position);
object.rotation.set(...item.rotation);
object.scale.fromArray(item.scale);
r.objects.add(object);
if (item.id === latest.current.selected && !latest.current.cameraView)
r.transform.attach(object);
};
for (const item of props.scene.objects) {
if (item.kind === "model" && item.url) {
r.pending++;
new GLTFLoader().load(
buildThreeAssetUrl(item.url),
(g) => {
if (active) {
const box = new THREE.Box3().setFromObject(g.scene);
const size = box.getSize(new THREE.Vector3());
const scale = 2 / Math.max(size.x, size.y, size.z, 0.001);
g.scene.scale.setScalar(scale);
const normalized = new THREE.Group();
normalized.add(g.scene);
const fitted = new THREE.Box3().setFromObject(normalized);
const center = fitted.getCenter(new THREE.Vector3());
g.scene.position.set(-center.x, -fitted.min.y, -center.z);
attach(normalized, item);
r.pending--;
setLoading(r.pending > 0);
} else dispose(g.scene);
},
undefined,
() => {
if (active) {
r.pending--;
setLoading(r.pending > 0);
setError("模型加载失败,请检查 GLB 文件及资源访问权限");
}
},
);
continue;
}
const mat = new THREE.MeshStandardMaterial({
color: item.kind === "actor" ? 0x687bb0 : 0xc3664c,
roughness: 0.6,
});
let object: THREE.Object3D;
if (item.kind === "actor") {
const group = new THREE.Group();
const body = new THREE.Mesh(
new THREE.CapsuleGeometry(0.32, 0.7, 6, 16),
mat,
);
body.position.y = 1.05;
group.add(body);
const head = new THREE.Mesh(
new THREE.SphereGeometry(0.24, 24, 16),
mat.clone(),
);
head.position.y = 1.95;
group.add(head);
for (const x of [-0.18, 0.18]) {
const leg = new THREE.Mesh(
new THREE.CapsuleGeometry(0.12, 0.55, 4, 12),
mat.clone(),
);
leg.position.set(x, 0.42, 0);
group.add(leg);
}
object = group;
} else {
object = new THREE.Mesh(
item.kind === "sphere"
? new THREE.SphereGeometry(0.5, 32, 20)
: new THREE.BoxGeometry(1, 1, 1),
mat,
);
}
attach(object, item);
}
setLoading(r.pending > 0);
return () => {
active = false;
};
}, [props.scene.objects, ready]);
useEffect(() => {
const r = runtime.current;
if (!r) return;
const camera =
props.scene.cameras.find((c) => c.id === props.scene.activeCameraId) ||
props.scene.cameras[0];
r.camera.position.fromArray(camera.position);
r.camera.fov = camera.fov;
r.camera.updateProjectionMatrix();
r.orbit.target.fromArray(camera.target);
r.orbit.enabled = !props.cameraView;
r.orbit.update();
r.transform.setMode(props.mode);
const selected = r.objects.getObjectByName(props.selected);
if (selected && !props.cameraView) r.transform.attach(selected);
else r.transform.detach();
}, [
props.scene.cameras,
props.scene.activeCameraId,
props.selected,
props.mode,
props.cameraView,
ready,
]);
useEffect(() => {
runtime.current?.resize();
}, [props.scene.ratio, ready]);
useImperativeHandle(
ref,
() => ({
capture: async () => {
const r = runtime.current;
if (!r || !ready || r.pending || error)
throw Error(error || "3D 场景尚未准备好");
const { width, height } = directorImageSize(
latest.current.scene.ratio,
);
const previousSize = r.renderer.getSize(new THREE.Vector2());
const pixelRatio = r.renderer.getPixelRatio();
const aspect = r.camera.aspect;
r.helper.visible = false;
r.grid.visible = false;
r.renderer.setPixelRatio(1);
r.renderer.setSize(width, height, false);
r.camera.aspect = width / height;
r.camera.updateProjectionMatrix();
r.renderer.render(r.world, r.camera);
try {
const blob = await new Promise<Blob>((resolve, reject) =>
r.renderer.domElement.toBlob(
(b) => (b ? resolve(b) : reject(Error("截图失败"))),
"image/png",
),
);
return { blob, width, height };
} finally {
r.renderer.setPixelRatio(pixelRatio);
r.renderer.setSize(previousSize.x, previousSize.y);
r.camera.aspect = aspect;
r.camera.updateProjectionMatrix();
r.grid.visible = true;
r.helper.visible = true;
}
},
}),
[ready, error],
);
return (
<div className="relative h-full w-full" data-testid="director-viewport">
<div ref={host} className="h-full w-full" />
{error ? (
<div
role="alert"
className="absolute inset-x-4 top-4 rounded bg-red-950/90 p-3 text-sm text-white"
>
{error}
</div>
) : loading ? (
<div className="absolute left-4 top-4 rounded bg-black/60 p-2 text-white">
正在加载模型...
</div>
) : null}
</div>
);
},
);