360 lines
12 KiB
TypeScript
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>
|
|
);
|
|
},
|
|
);
|