chore: checkpoint premium 3d stages 0 and 1

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Даня Архипов
2026-07-29 19:05:27 +00:00
parent 5cc27c6fc2
commit 394c513037
79 changed files with 6221 additions and 612 deletions

View File

@@ -0,0 +1,169 @@
/**
* RollCageMesh — честная сетчатая модель роллтейнера C/D по ground truth.
*
* Exterior bounding box: 1200 × 800 × 800 мм (включая колёса) — ROLL_CAGE.
* Открытый верх, читаемая сетка стен (~100мм), пол-панель на CAGE_FLOOR_Y.
*
* Вся геометрия — 3 instanced draw call (трубы+прутья, колёса) + 1 mesh (пол).
* Одна и та же модель используется обеими сценами (`/` и `/details`).
*
* Классификация узла (Stage 1 §13.4): PROCEDURAL_FALLBACK — официальной
* CAD-модели роллтейнера в архивах нет; размеры соответствуют спецификации.
*/
import { useEffect, useMemo, useRef } from 'react';
import * as THREE from 'three';
import { ROLL_CAGE, CAGE_FLOOR_Y } from '../../domain/physicalLayout';
const { width: W, depth: D, height: H, wheelRadius: WR, frameThickness: FT } = ROLL_CAGE;
const WHEEL_D = WR * 2; // 0.08m — cage floor height (CAGE_FLOOR_Y)
const BODY_H = H - WHEEL_D; // frame body above wheels; total exterior = H exactly
const ROD = 0.008; // grid rod thickness (8mm wire)
const GRID_STEP = 0.1; // ~100mm grid pitch
interface CageInstances {
boxes: THREE.Matrix4[];
wheels: THREE.Matrix4[];
}
function boxInstance(x: number, y: number, z: number, sx: number, sy: number, sz: number): THREE.Matrix4 {
return new THREE.Matrix4().compose(
new THREE.Vector3(x, y, z),
new THREE.Quaternion(),
new THREE.Vector3(sx, sy, sz),
);
}
/** Deterministic instance layout for the cage (built once). */
function buildInstances(): CageInstances {
const boxes: THREE.Matrix4[] = [];
const yBot = WHEEL_D; // bottom of frame body
const yTop = H; // top of frame body (exterior top)
// 4 corner posts
for (const sx of [-1, 1]) {
for (const sz of [-1, 1]) {
boxes.push(boxInstance(sx * (W / 2 - FT / 2), yBot + BODY_H / 2, sz * (D / 2 - FT / 2), FT, BODY_H, FT));
}
}
// bottom + top frame rectangles
for (const y of [yBot + FT / 2, yTop - FT / 2]) {
boxes.push(boxInstance(0, y, D / 2 - FT / 2, W, FT, FT));
boxes.push(boxInstance(0, y, -(D / 2 - FT / 2), W, FT, FT));
boxes.push(boxInstance(W / 2 - FT / 2, y, 0, FT, FT, D - FT * 2));
boxes.push(boxInstance(-(W / 2 - FT / 2), y, 0, FT, FT, D - FT * 2));
}
// grid walls between frames (interior span)
const yGridBot = yBot + FT;
const yGridTop = yTop - FT;
const gridH = yGridTop - yGridBot;
const yMid = yGridBot + gridH / 2;
const xInner = W / 2 - FT; // inner half-width
const zInner = D / 2 - FT;
// front/back walls (z = ±(D/2 − ROD/2)): vertical + horizontal rods
const vCols = Math.floor((xInner * 2) / GRID_STEP) - 1; // exclude corners (posts)
const hRows = Math.max(1, Math.round(gridH / GRID_STEP) - 1);
for (const sz of [-1, 1]) {
const z = sz * (D / 2 - ROD / 2);
for (let i = 1; i <= vCols; i++) {
const x = -xInner + (i * (xInner * 2)) / (vCols + 1);
boxes.push(boxInstance(x, yMid, z, ROD, gridH, ROD));
}
for (let r = 1; r <= hRows; r++) {
const y = yGridBot + (r * gridH) / (hRows + 1);
boxes.push(boxInstance(0, y, z, W - FT * 2, ROD, ROD));
}
}
// side walls (x = ±(W/2 − ROD/2))
const sCols = Math.floor((zInner * 2) / GRID_STEP) - 1;
for (const sx of [-1, 1]) {
const x = sx * (W / 2 - ROD / 2);
for (let i = 1; i <= sCols; i++) {
const z = -zInner + (i * (zInner * 2)) / (sCols + 1);
boxes.push(boxInstance(x, yMid, z, ROD, gridH, ROD));
}
for (let r = 1; r <= hRows; r++) {
const y = yGridBot + (r * gridH) / (hRows + 1);
boxes.push(boxInstance(x, y, 0, ROD, ROD, D - FT * 2));
}
}
// caster wheels (lying cylinders)
const wheels: THREE.Matrix4[] = [];
const wheelQuat = new THREE.Quaternion().setFromEuler(new THREE.Euler(0, 0, Math.PI / 2));
for (const sx of [-1, 1]) {
for (const sz of [-1, 1]) {
wheels.push(new THREE.Matrix4().compose(
new THREE.Vector3(sx * (W / 2 - 0.08), WR, sz * (D / 2 - 0.08)),
wheelQuat,
new THREE.Vector3(1, 1, 1),
));
}
}
return { boxes, wheels };
}
export default function RollCageMesh({ color, active = false, shadows = false }: {
color: string;
active?: boolean;
shadows?: boolean;
}) {
const instances = useMemo(buildInstances, []);
const boxGeo = useMemo(() => new THREE.BoxGeometry(1, 1, 1), []);
const wheelGeo = useMemo(() => new THREE.CylinderGeometry(WR, WR, 0.03, 12), []);
const boxesRef = useRef<THREE.InstancedMesh>(null);
const wheelsRef = useRef<THREE.InstancedMesh>(null);
useEffect(() => {
const boxes = boxesRef.current;
if (boxes) {
instances.boxes.forEach((m, i) => boxes.setMatrixAt(i, m));
boxes.instanceMatrix.needsUpdate = true;
}
const wheels = wheelsRef.current;
if (wheels) {
instances.wheels.forEach((m, i) => wheels.setMatrixAt(i, m));
wheels.instanceMatrix.needsUpdate = true;
}
}, [instances]);
useEffect(() => () => {
boxGeo.dispose();
wheelGeo.dispose();
}, [boxGeo, wheelGeo]);
const emissiveIntensity = active ? 0.35 : 0;
return (
<group>
{/* frame + grid walls: single instanced draw call */}
<instancedMesh
ref={boxesRef}
args={[boxGeo, undefined, instances.boxes.length]}
castShadow={shadows}
>
<meshStandardMaterial
color={color}
metalness={0.6}
roughness={0.35}
emissive={color}
emissiveIntensity={emissiveIntensity}
/>
</instancedMesh>
{/* caster wheels: single instanced draw call */}
<instancedMesh ref={wheelsRef} args={[wheelGeo, undefined, instances.wheels.length]}>
<meshStandardMaterial color="#475569" metalness={0.7} roughness={0.3} />
</instancedMesh>
{/* interior floor pan where items rest (top at CAGE_FLOOR_Y) */}
<mesh position={[0, CAGE_FLOOR_Y - 0.005, 0]} receiveShadow={shadows}>
<boxGeometry args={[W - FT, 0.01, D - FT]} />
<meshStandardMaterial color="#1e293b" metalness={0.3} roughness={0.7} />
</mesh>
</group>
);
}