"use client"; /* eslint-disable @next/next/no-img-element */ import { Html, OrbitControls, PointerLockControls } from "@react-three/drei"; import { Canvas, type ThreeEvent, useFrame, useThree } from "@react-three/fiber"; import { SparkRenderer, SplatMesh as SparkSplatMesh } from "@sparkjsdev/spark"; import { AlertCircle, ArrowDown, ArrowLeft, ArrowRight, ArrowUp, Box, Crosshair, Globe, ImageIcon, Loader2, Sparkles, } from "lucide-react"; import React, { Suspense, useEffect, useMemo, useRef, useState } from "react"; import * as THREE from "three"; import { type Model3DLayer, type Model3DStats, Model3DViewer, type Model3DViewerSettings, } from "@/components/canvas/model3d/Model3DViewer"; import { Badge } from "@/components/ui/badge"; import { cn } from "@/lib/utils"; import type { World3DHotspot, World3DViewMode } from "@/types/canvas"; type World3DPickResult = { point: [number, number, number]; }; type MovementCommand = | "forward" | "backward" | "left" | "right" | "up" | "down"; type MovementState = Record; type SplatLoadingPhase = "loading" | "revealing" | "hidden"; type SplatRevealCloudData = { count: number; colors: Float32Array; startPositions: Float32Array; targetPositions: Float32Array; }; type World3DViewerProps = { mode: World3DViewMode; worldUrl?: string | null; imageUrl?: string | null; meshUrl?: string | null; splatUrl?: string | null; previewImageUrl?: string | null; emptyStateTitle?: string; meshSettings?: Model3DViewerSettings; meshLayerVisibility?: Record; onMeshLayersChange?: (layers: Model3DLayer[]) => void; onMeshStatsChange?: (stats: Model3DStats) => void; firstPerson?: boolean; hotspots?: World3DHotspot[]; interactionMode?: "navigate" | "hotspot"; onPick?: (pick: World3DPickResult) => void; onHotspotSelect?: (hotspotId: string) => void; semanticsMetadata?: Record | null; className?: string; }; const DEFAULT_MESH_SETTINGS: Model3DViewerSettings = { envPreset: "city", lightIntensity: 1, autoRotate: false, showGrid: true, wireframe: false, }; const EMPTY_MOVEMENT_STATE: MovementState = { forward: false, backward: false, left: false, right: false, up: false, down: false, }; const KEY_TO_MOVEMENT: Partial> = { KeyW: "forward", ArrowUp: "forward", KeyS: "backward", ArrowDown: "backward", KeyA: "left", ArrowLeft: "left", KeyD: "right", ArrowRight: "right", KeyQ: "up", KeyR: "up", PageUp: "up", KeyE: "down", KeyF: "down", PageDown: "down", }; function isEditableKeyboardTarget(target: EventTarget | null) { if (!(target instanceof HTMLElement)) return false; if (target.isContentEditable) return true; const editableSelector = "input, textarea, select, [contenteditable='true'], [role='textbox']"; if (target.matches(editableSelector)) return true; return Boolean(target.closest(editableSelector)); } function getSemanticFacts(metadata?: Record | null) { if (!metadata) return []; const facts: Array<{ label: string; value: string }> = []; const scaleFactor = metadata.metric_scale_factor; if (typeof scaleFactor === "number" && Number.isFinite(scaleFactor)) { facts.push({ label: "比例尺", value: `${scaleFactor.toFixed(3)}x`, }); } const groundOffset = metadata.ground_plane_offset; if (typeof groundOffset === "number" && Number.isFinite(groundOffset)) { facts.push({ label: "地平面偏移", value: `${groundOffset.toFixed(2)}m`, }); } return facts; } function WorldEmptyState({ icon: Icon, title, description, previewImageUrl, }: { icon: React.ComponentType<{ className?: string }>; title: string; description: string; previewImageUrl?: string | null; }) { return (
{previewImageUrl ? (
{title}
) : (
)}

{title}

{description}

); } const REAL_SPLAT_REVEAL_SAMPLE_LIMIT = 3600; function seededUnit(index: number, salt: number) { const value = Math.sin(index * 12.9898 + salt * 78.233) * 43758.5453; return value - Math.floor(value); } function buildSplatRevealCloudData( splatMesh: SparkSplatMesh, sampleLimit = REAL_SPLAT_REVEAL_SAMPLE_LIMIT ): SplatRevealCloudData | null { const totalSplats = Math.max(0, splatMesh.packedSplats?.numSplats || 0); if (!totalSplats) return null; const sampleStep = Math.max(1, Math.floor(totalSplats / sampleLimit)); const sampled: Array<{ center: THREE.Vector3; color: THREE.Color; opacity: number; }> = []; const bounds = new THREE.Box3(); splatMesh.forEachSplat((index, center, _scales, _quaternion, opacity, color) => { if (sampled.length >= sampleLimit) return; if (opacity < 0.04) return; if (index % sampleStep !== 0) return; const target = center.clone(); bounds.expandByPoint(target); sampled.push({ center: target, color: color.clone(), opacity, }); }); if (!sampled.length) return null; const sceneCenter = bounds.getCenter(new THREE.Vector3()); const sceneBoundsSize = bounds.getSize(new THREE.Vector3()); const sceneSize = sceneBoundsSize.length(); const sceneRadius = Math.max(sceneSize * 0.42, 1.6); const white = new THREE.Color("#fff4de"); const colors = new Float32Array(sampled.length * 3); const startPositions = new Float32Array(sampled.length * 3); const targetPositions = new Float32Array(sampled.length * 3); sampled.forEach((sample, index) => { const stride = index * 3; const direction = sample.center.clone().sub(sceneCenter); if (direction.lengthSq() < 1e-4) { direction.set( seededUnit(index, 10) - 0.5, seededUnit(index, 11) - 0.35, seededUnit(index, 12) - 0.5 ); } direction.normalize(); const swirlAxis = new THREE.Vector3( seededUnit(index, 13) - 0.5, seededUnit(index, 14) - 0.5, seededUnit(index, 15) - 0.5 ); if (swirlAxis.lengthSq() < 1e-4) { swirlAxis.set(0.3, 1, 0.2); } swirlAxis.normalize(); const tangent = new THREE.Vector3().crossVectors(direction, swirlAxis); if (tangent.lengthSq() < 1e-4) { tangent.set(1, 0, 0); } else { tangent.normalize(); } const start = sample.center .clone() .sub(sceneCenter) .multiplyScalar(1.08 + seededUnit(index, 16) * 0.38) .add(sceneCenter) .addScaledVector( tangent, sceneRadius * (0.018 + seededUnit(index, 17) * 0.085) ) .addScaledVector( direction, sceneRadius * (0.035 + seededUnit(index, 18) * 0.12) ) .add( new THREE.Vector3( 0, sceneBoundsSize.y * (seededUnit(index, 19) - 0.5) * 0.16, 0 ) ); const displayColor = sample.color .clone() .lerp(white, 0.42) .multiplyScalar(0.88 + Math.min(sample.opacity, 1) * 0.24); targetPositions[stride] = sample.center.x; targetPositions[stride + 1] = sample.center.y; targetPositions[stride + 2] = sample.center.z; startPositions[stride] = start.x; startPositions[stride + 1] = start.y; startPositions[stride + 2] = start.z; colors[stride] = displayColor.r; colors[stride + 1] = displayColor.g; colors[stride + 2] = displayColor.b; }); return { count: sampled.length, colors, startPositions, targetPositions, }; } function SplatRevealCloud({ data, phase, }: { data: SplatRevealCloudData; phase: Exclude; }) { const pointsRef = useRef(null); const materialRef = useRef(null); const positionBuffer = useMemo( () => data.startPositions.slice(), [data.startPositions] ); const geometryRef = useRef(null); const phaseRef = useRef(phase); const phaseStartedAtRef = useRef(performance.now()); useEffect(() => { if (phaseRef.current !== phase) { phaseRef.current = phase; phaseStartedAtRef.current = performance.now(); } }, [phase]); useEffect(() => { if (pointsRef.current) { pointsRef.current.raycast = () => null; } }, []); useFrame((state) => { const geometry = geometryRef.current; const material = materialRef.current; if (!geometry || !material) return; const elapsed = state.clock.getElapsedTime(); const rawProgress = Math.min( (performance.now() - phaseStartedAtRef.current) / 1450, 1 ); const easedProgress = 1 - Math.pow(1 - rawProgress, 3); const positionAttribute = geometry.getAttribute("position"); const positions = positionAttribute.array as Float32Array; for (let index = 0; index < data.count; index += 1) { const stride = index * 3; const swirl = Math.sin(elapsed * 2.4 + index * 0.17) * (1 - easedProgress) * 0.018; positions[stride] = THREE.MathUtils.lerp( data.startPositions[stride], data.targetPositions[stride], easedProgress ) + swirl; positions[stride + 1] = THREE.MathUtils.lerp( data.startPositions[stride + 1], data.targetPositions[stride + 1], easedProgress ) + swirl * 0.45; positions[stride + 2] = THREE.MathUtils.lerp( data.startPositions[stride + 2], data.targetPositions[stride + 2], easedProgress ) - swirl * 0.65; } positionAttribute.needsUpdate = true; material.opacity = THREE.MathUtils.lerp(0.9, 0, easedProgress); material.size = THREE.MathUtils.lerp(0.04, 0.009, easedProgress); }); return ( ); } function WorldSplatLoadingOverlay({ previewImageUrl, phase, }: { previewImageUrl?: string | null; phase: Exclude; }) { const isRevealing = phase === "revealing"; return (
{previewImageUrl ? ( 世界预览 ) : null}
{isRevealing ? "真实点云正在成形" : "正在载入真实 Gaussian Splats"}
{isRevealing ? "点云聚合中" : "SPZ 数据准备中"}
); } function createMovementState(): MovementState { return { ...EMPTY_MOVEMENT_STATE }; } function DirectionPad({ onCommandChange, }: { onCommandChange: (command: MovementCommand, active: boolean) => void; }) { const pressHandlers = (command: MovementCommand) => ({ onMouseDown: () => onCommandChange(command, true), onMouseUp: () => onCommandChange(command, false), onMouseLeave: () => onCommandChange(command, false), onTouchStart: () => onCommandChange(command, true), onTouchEnd: () => onCommandChange(command, false), onTouchCancel: () => onCommandChange(command, false), }); return (
方向移动
前后左右
); } function CameraMovementControls({ enabled, firstPerson, virtualMovement, orbitControlsRef, }: { enabled: boolean; firstPerson: boolean; virtualMovement: MovementState; orbitControlsRef: React.MutableRefObject; }) { const { camera } = useThree(); const pressedKeysRef = useRef(createMovementState()); const directionRef = useRef(new THREE.Vector3()); const rightRef = useRef(new THREE.Vector3()); const upRef = useRef(new THREE.Vector3()); const moveRef = useRef(new THREE.Vector3()); useEffect(() => { if (!enabled) { pressedKeysRef.current = createMovementState(); return; } const handleKeyDown = (event: KeyboardEvent) => { const movement = KEY_TO_MOVEMENT[event.code]; if (!movement) return; if (event.metaKey || event.ctrlKey || event.altKey) return; if (isEditableKeyboardTarget(event.target)) { pressedKeysRef.current = createMovementState(); return; } pressedKeysRef.current[movement] = true; }; const handleKeyUp = (event: KeyboardEvent) => { const movement = KEY_TO_MOVEMENT[event.code]; if (!movement) return; if (isEditableKeyboardTarget(event.target)) { pressedKeysRef.current = createMovementState(); return; } pressedKeysRef.current[movement] = false; }; const handleFocusIn = (event: FocusEvent) => { if (isEditableKeyboardTarget(event.target)) { pressedKeysRef.current = createMovementState(); } }; window.addEventListener("keydown", handleKeyDown); window.addEventListener("keyup", handleKeyUp); window.addEventListener("focusin", handleFocusIn); return () => { window.removeEventListener("keydown", handleKeyDown); window.removeEventListener("keyup", handleKeyUp); window.removeEventListener("focusin", handleFocusIn); }; }, [enabled]); useFrame((_, delta) => { if (!enabled) return; const pressed = pressedKeysRef.current; const hasMovement = Object.values(pressed).some(Boolean) || Object.values(virtualMovement).some(Boolean); if (!hasMovement) return; const moveSpeed = 3.8; const distance = moveSpeed * delta; camera.getWorldDirection(directionRef.current); directionRef.current.setY(0).normalize(); rightRef.current.crossVectors(directionRef.current, camera.up).normalize(); upRef.current.copy(camera.up).normalize(); moveRef.current.set(0, 0, 0); if (pressed.forward || virtualMovement.forward) { moveRef.current.add(directionRef.current); } if (pressed.backward || virtualMovement.backward) { moveRef.current.addScaledVector(directionRef.current, -1); } if (pressed.left || virtualMovement.left) { moveRef.current.addScaledVector(rightRef.current, -1); } if (pressed.right || virtualMovement.right) { moveRef.current.add(rightRef.current); } if (pressed.up || virtualMovement.up) { moveRef.current.add(upRef.current); } if (pressed.down || virtualMovement.down) { moveRef.current.addScaledVector(upRef.current, -1); } if (moveRef.current.lengthSq() === 0) return; moveRef.current.normalize().multiplyScalar(distance); camera.position.add(moveRef.current); if (!firstPerson && orbitControlsRef.current?.target) { orbitControlsRef.current.target.add(moveRef.current); orbitControlsRef.current.update(); } }); if (!enabled || !firstPerson) return null; return ; } function HotspotBillboard({ hotspot, onSelect, }: { hotspot: World3DHotspot; onSelect?: (hotspotId: string) => void; }) { return ( { event.stopPropagation(); onSelect?.(hotspot.id); }} >
{hotspot.label}
); } function WorldSplatScene({ splatUrl, revealPhase = "loading", firstPerson = false, hotspots = [], interactionMode = "navigate", onPick, onHotspotSelect, semanticsMetadata, onLoadStateChange, }: { splatUrl: string; revealPhase?: SplatLoadingPhase; firstPerson?: boolean; hotspots?: World3DHotspot[]; interactionMode?: "navigate" | "hotspot"; onPick?: (pick: World3DPickResult) => void; onHotspotSelect?: (hotspotId: string) => void; semanticsMetadata?: Record | null; onLoadStateChange?: (state: "ready" | "error") => void; }) { const renderer = useThree((state) => state.gl); const orbitControlsRef = useRef(null); const [virtualMovement, setVirtualMovement] = useState(createMovementState); const [revealCloudData, setRevealCloudData] = useState(null); const semanticFacts = useMemo( () => getSemanticFacts(semanticsMetadata), [semanticsMetadata] ); const revealPhaseRef = useRef(revealPhase); const revealStartedAtRef = useRef(performance.now()); const sparkRenderer = useMemo( () => new SparkRenderer({ renderer, blurAmount: 0.18, maxStdDev: Math.sqrt(7), }), [renderer] ); const splatMesh = useMemo(() => new SparkSplatMesh({ url: splatUrl }), [splatUrl]); useEffect(() => { sparkRenderer.frustumCulled = false; sparkRenderer.renderOrder = 10; sparkRenderer.minAlpha = 0.02; sparkRenderer.preBlurAmount = 0.04; return () => { sparkRenderer.removeFromParent(); }; }, [sparkRenderer]); useEffect(() => { if (revealPhaseRef.current !== revealPhase) { revealPhaseRef.current = revealPhase; revealStartedAtRef.current = performance.now(); } }, [revealPhase]); useEffect(() => { splatMesh.frustumCulled = false; splatMesh.rotation.x = Math.PI; splatMesh.opacity = 0; sparkRenderer.blurAmount = 0.95; sparkRenderer.preBlurAmount = 0.28; sparkRenderer.minAlpha = 0.08; sparkRenderer.maxStdDev = Math.sqrt(10); setRevealCloudData(null); let cancelled = false; splatMesh.initialized .then(() => { if (cancelled) return; setRevealCloudData(buildSplatRevealCloudData(splatMesh)); onLoadStateChange?.("ready"); }) .catch(() => { if (!cancelled) onLoadStateChange?.("error"); }); return () => { cancelled = true; splatMesh.dispose(); }; }, [onLoadStateChange, sparkRenderer, splatMesh]); useFrame(() => { const phase = revealPhaseRef.current; const revealElapsed = phase === "revealing" ? Math.min((performance.now() - revealStartedAtRef.current) / 1250, 1) : 0; const easedReveal = 1 - Math.pow(1 - revealElapsed, 3); if (phase === "loading") { splatMesh.opacity = 0; sparkRenderer.blurAmount = 0.95; sparkRenderer.preBlurAmount = 0.28; sparkRenderer.minAlpha = 0.08; sparkRenderer.maxStdDev = Math.sqrt(10); } else if (phase === "revealing") { splatMesh.opacity = THREE.MathUtils.lerp(0.02, 1, easedReveal); sparkRenderer.blurAmount = THREE.MathUtils.lerp(0.95, 0.16, easedReveal); sparkRenderer.preBlurAmount = THREE.MathUtils.lerp(0.28, 0.04, easedReveal); sparkRenderer.minAlpha = THREE.MathUtils.lerp(0.08, 0.02, easedReveal); sparkRenderer.maxStdDev = THREE.MathUtils.lerp( Math.sqrt(10), Math.sqrt(7), easedReveal ); } else { splatMesh.opacity = 1; sparkRenderer.blurAmount = 0.16; sparkRenderer.preBlurAmount = 0.04; sparkRenderer.minAlpha = 0.02; sparkRenderer.maxStdDev = Math.sqrt(7); } sparkRenderer.needsUpdate = true; }); const groundPlaneOffset = typeof semanticsMetadata?.ground_plane_offset === "number" ? -semanticsMetadata.ground_plane_offset : null; const handleDirectionChange = (command: MovementCommand, active: boolean) => { setVirtualMovement((prev) => { if (prev[command] === active) return prev; return { ...prev, [command]: active, }; }); }; const handlePointerDown = (event: ThreeEvent) => { if (interactionMode !== "hotspot") return; event.stopPropagation(); onPick?.({ point: [event.point.x, event.point.y, event.point.z], }); }; return ( <> {groundPlaneOffset !== null ? ( ) : null} {revealPhase !== "hidden" && revealCloudData ? ( ) : null} {hotspots.map((hotspot) => ( ))} {!firstPerson ? ( ) : ( )}
SPZ {semanticFacts.map((fact) => ( {fact.label} {fact.value} ))}
{interactionMode === "hotspot" ? (
点击场景放置热点
) : null}
{firstPerson ? "方向键 / WASD 前后左右 · Q/E 或 PgUp/PgDn 上下 · 鼠标观察 · Esc 退出" : "拖拽旋转 · 滚轮缩放 · 方向键 / 按钮可做六向移动"}
{interactionMode === "navigate" ? ( ) : null} {(firstPerson || interactionMode === "hotspot") && (
)}
); } function WorldSplatViewer({ splatUrl, previewImageUrl, firstPerson, hotspots, interactionMode, onPick, onHotspotSelect, semanticsMetadata, }: { splatUrl?: string | null; previewImageUrl?: string | null; firstPerson?: boolean; hotspots?: World3DHotspot[]; interactionMode?: "navigate" | "hotspot"; onPick?: (pick: World3DPickResult) => void; onHotspotSelect?: (hotspotId: string) => void; semanticsMetadata?: Record | null; }) { const [loadState, setLoadState] = useState<"loading" | "ready" | "error">("loading"); const [overlayPhase, setOverlayPhase] = useState("loading"); useEffect(() => { setLoadState("loading"); setOverlayPhase("loading"); }, [splatUrl]); useEffect(() => { if (loadState === "ready") { setOverlayPhase("revealing"); const timer = window.setTimeout(() => { setOverlayPhase("hidden"); }, 1250); return () => window.clearTimeout(timer); } if (loadState === "loading") { setOverlayPhase("loading"); } if (loadState === "error") { setOverlayPhase("hidden"); } }, [loadState]); if (!splatUrl) { return ( ); } if (loadState === "error") { return ( ); } return (
{overlayPhase !== "hidden" ? ( ) : null}
); } export function World3DViewer({ mode, worldUrl, imageUrl, meshUrl, splatUrl, previewImageUrl, emptyStateTitle = "准备生成 3D 世界", meshSettings, meshLayerVisibility, onMeshLayersChange, onMeshStatsChange, firstPerson = false, hotspots = [], interactionMode = "navigate", onPick, onHotspotSelect, semanticsMetadata, className, }: World3DViewerProps) { const resolvedImageUrl = String(imageUrl || previewImageUrl || "").trim() || null; if (mode === "mesh") { return (
); } if (mode === "world") { return (
{worldUrl ? (