249 lines
9.4 KiB
TypeScript
249 lines
9.4 KiB
TypeScript
import * as THREE from 'three';
|
|
import { STLExporter } from 'three-stdlib';
|
|
import { SUBTRACTION, ADDITION, Brush, Evaluator } from 'three-bvh-csg';
|
|
import { mergeBufferGeometries } from 'three-stdlib';
|
|
import { AppConfig, LayoutSplits, GeneratedPart, Partition } from '../types';
|
|
|
|
// --- ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ---
|
|
|
|
const cleanPoints = (points: number[]) => {
|
|
const rounded = points.map(p => Math.round(p * 1000) / 1000).sort((a, b) => a - b);
|
|
return [...new Set(rounded)];
|
|
};
|
|
|
|
const getAllPartitions = (splits: LayoutSplits): Partition[] => {
|
|
if (!splits || !splits.partitions) return [];
|
|
return Object.values(splits.partitions).flat();
|
|
};
|
|
|
|
export const calculateParts = (config: AppConfig, splits: LayoutSplits): GeneratedPart[] => {
|
|
const parts: GeneratedPart[] = [];
|
|
const safeX = Array.isArray(splits?.x) ? splits.x : [];
|
|
const safeY = Array.isArray(splits?.y) ? splits.y : [];
|
|
|
|
const uniqueX = cleanPoints([0, ...safeX, 1]);
|
|
const uniqueY = cleanPoints([0, ...safeY, 1]);
|
|
|
|
let partCounter = 1;
|
|
|
|
for (let i = 0; i < uniqueX.length - 1; i++) {
|
|
for (let j = 0; j < uniqueY.length - 1; j++) {
|
|
const x1 = uniqueX[i];
|
|
const x2 = uniqueX[i+1];
|
|
const y1 = uniqueY[j];
|
|
const y2 = uniqueY[j+1];
|
|
|
|
if (x2 - x1 < 0.001 || y2 - y1 < 0.001) continue;
|
|
|
|
const rawW = (x2 - x1) * config.drawer.width;
|
|
const rawD = (y2 - y1) * config.drawer.depth;
|
|
const rawX = x1 * config.drawer.width;
|
|
const rawY = y1 * config.drawer.depth;
|
|
|
|
const gap = config.wallThickness / 2 + 0.1;
|
|
|
|
parts.push({
|
|
id: `part-${partCounter}`,
|
|
name: `Ячейка ${partCounter}`,
|
|
width: Math.max(1, rawW - gap * 2),
|
|
depth: Math.max(1, rawD - gap * 2),
|
|
height: config.drawer.height,
|
|
x: rawX + gap,
|
|
y: rawY + gap,
|
|
color: `hsl(${(partCounter * 137.5) % 360}, 70%, 50%)`,
|
|
internalPartitions: []
|
|
});
|
|
partCounter++;
|
|
}
|
|
}
|
|
return parts;
|
|
};
|
|
|
|
// --- ГЕНЕРАЦИЯ ГЕОМЕТРИИ (ПОСЛЕДОВАТЕЛЬНЫЙ CSG) ---
|
|
|
|
export const createBinGeometry = (
|
|
width: number, depth: number, height: number, thickness: number, radius: number = 0,
|
|
splits: LayoutSplits | Partition[] = [],
|
|
config?: AppConfig
|
|
): THREE.BufferGeometry => {
|
|
|
|
const safeConfig = config || { perforation: { enabled: false } } as AppConfig;
|
|
const evaluator = new Evaluator();
|
|
evaluator.useGroups = false;
|
|
|
|
const wallH = height - thickness;
|
|
const innerW = width - 2 * thickness;
|
|
const innerD = depth - 2 * thickness;
|
|
|
|
// 1. Базовая геометрия - ПОЛ
|
|
const floorGeo = new THREE.BoxGeometry(width, thickness, depth);
|
|
floorGeo.translate(0, thickness / 2, 0);
|
|
let mainBrush = new Brush(floorGeo);
|
|
mainBrush.updateMatrixWorld();
|
|
|
|
// --- ФУНКЦИИ ОПЕРАЦИЙ ---
|
|
|
|
// Добавить твердое тело (стену/скругление)
|
|
const addSolid = (geo: THREE.BufferGeometry) => {
|
|
const brush = new Brush(geo);
|
|
brush.updateMatrixWorld();
|
|
mainBrush = evaluator.evaluate(mainBrush, brush, ADDITION);
|
|
};
|
|
|
|
// Вычесть отверстия для конкретной зоны
|
|
const subtractHoles = (W: number, H: number, startX: number, startY: number, startZ: number, axis: 'x' | 'z') => {
|
|
if (!safeConfig.perforation?.enabled) return;
|
|
const { pattern, diameter, spacing } = safeConfig.perforation;
|
|
const margin = 4;
|
|
const step = diameter + Math.max(2, spacing);
|
|
|
|
const cols = Math.floor((W - margin*2) / step);
|
|
const rowH = pattern === 'circle' ? step : step * 0.866;
|
|
const rows = Math.floor((H - margin*2) / rowH);
|
|
|
|
if (cols <= 0 || rows <= 0) return;
|
|
|
|
const offsetX = (W - cols * step) / 2;
|
|
const offsetY = (H - rows * rowH) / 2;
|
|
|
|
// Базовое сверло
|
|
const drillBase = new THREE.CylinderGeometry(diameter/2, diameter/2, thickness * 3, 12);
|
|
if (axis === 'x') drillBase.rotateX(Math.PI / 2); // Вдоль Z
|
|
else drillBase.rotateZ(Math.PI / 2); // Вдоль X
|
|
|
|
const drills: THREE.BufferGeometry[] = [];
|
|
|
|
for(let r=0; r<rows; r++) {
|
|
const isOdd = r % 2 !== 0;
|
|
for(let c=0; c<cols; c++) {
|
|
let u = offsetX + c * step + diameter/2;
|
|
let v = offsetY + r * rowH + diameter/2;
|
|
if ((pattern === 'hexagon' || pattern === 'triangle') && isOdd) u += step/2;
|
|
if (u > W - margin || v > H - margin) continue;
|
|
|
|
const drill = drillBase.clone();
|
|
if (axis === 'x') drill.translate(startX + u, startY + v, startZ);
|
|
else drill.translate(startX, startY + v, startZ + u);
|
|
drills.push(drill);
|
|
}
|
|
}
|
|
|
|
if (drills.length > 0) {
|
|
const mergedDrills = mergeBufferGeometries(drills);
|
|
if (mergedDrills) {
|
|
const drillBrush = new Brush(mergedDrills);
|
|
drillBrush.updateMatrixWorld();
|
|
mainBrush = evaluator.evaluate(mainBrush, drillBrush, SUBTRACTION);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
// 2. СБОРКА СТЕН (ADDITION)
|
|
|
|
// Внешние стены
|
|
// Front
|
|
addSolid(new THREE.BoxGeometry(innerW, wallH, thickness).translate(0, thickness + wallH/2, depth/2 - thickness/2));
|
|
// Back
|
|
addSolid(new THREE.BoxGeometry(innerW, wallH, thickness).translate(0, thickness + wallH/2, -depth/2 + thickness/2));
|
|
// Left
|
|
addSolid(new THREE.BoxGeometry(thickness, wallH, depth).translate(-width/2 + thickness/2, thickness + wallH/2, 0));
|
|
// Right
|
|
addSolid(new THREE.BoxGeometry(thickness, wallH, depth).translate(width/2 - thickness/2, thickness + wallH/2, 0));
|
|
|
|
// Внутренние перегородки
|
|
let partitions: Partition[] = [];
|
|
if (Array.isArray(splits)) partitions = splits;
|
|
else if (splits && splits.partitions) partitions = getAllPartitions(splits);
|
|
|
|
partitions.forEach(p => {
|
|
const pMin = p.min ?? 0; const pMax = p.max ?? 1;
|
|
if (Math.abs(pMax - pMin) < 0.001) return;
|
|
|
|
let w=0, h=p.height, d=0, x=0, z=0;
|
|
if (p.axis === 'x') { // Vert (Z-axis)
|
|
w = thickness; d = (pMax - pMin) * innerD;
|
|
x = (-innerW/2) + (p.offset * innerW);
|
|
z = (-innerD/2) + ((pMin + pMax)/2 * innerD);
|
|
} else { // Horiz (X-axis)
|
|
w = (pMax - pMin) * innerW; d = thickness;
|
|
x = (-innerW/2) + ((pMin + pMax)/2 * innerW);
|
|
z = (-innerD/2) + (p.offset * innerD);
|
|
}
|
|
addSolid(new THREE.BoxGeometry(w, h, d).translate(x, thickness + h/2, z));
|
|
});
|
|
|
|
// 3. СКРУГЛЕНИЯ (ADDITION - цилиндры в углы)
|
|
if (radius > 0) {
|
|
const fRad = Math.min(radius, 5);
|
|
const filletBase = new THREE.CylinderGeometry(fRad, fRad, 1, 16);
|
|
filletBase.translate(0, 0.5, 0); // Pivot at bottom
|
|
|
|
partitions.forEach(p => {
|
|
if (!p.rounded) return;
|
|
const pMin = p.min ?? 0; const pMax = p.max ?? 1;
|
|
if (Math.abs(pMax - pMin) < 0.001) return;
|
|
|
|
const addF = (x: number, z: number) => {
|
|
const f = filletBase.clone();
|
|
f.scale(1, p.height, 1);
|
|
f.translate(x, thickness, z);
|
|
addSolid(f);
|
|
};
|
|
|
|
if (p.axis === 'x') { // Vert
|
|
const xPos = (-innerW/2) + (p.offset * innerW);
|
|
addF(xPos, (-innerD/2) + (pMin * innerD)); // Start Z
|
|
addF(xPos, (-innerD/2) + (pMax * innerD)); // End Z
|
|
} else { // Horiz
|
|
const zPos = (-innerD/2) + (p.offset * innerD);
|
|
addF((-innerW/2) + (pMin * innerW), zPos); // Start X
|
|
addF((-innerW/2) + (pMax * innerW), zPos); // End X
|
|
}
|
|
});
|
|
}
|
|
|
|
// 4. ПЕРФОРАЦИЯ (SUBTRACTION)
|
|
if (safeConfig.perforation?.enabled) {
|
|
// Внешние стены
|
|
subtractHoles(innerW, wallH, -innerW/2, thickness, depth/2, 'x'); // Front
|
|
subtractHoles(innerW, wallH, -innerW/2, thickness, -depth/2, 'x'); // Back
|
|
subtractHoles(depth, wallH, -width/2, thickness, -depth/2, 'z'); // Left
|
|
subtractHoles(depth, wallH, width/2, thickness, -depth/2, 'z'); // Right
|
|
|
|
// Внутренние перегородки
|
|
partitions.forEach(p => {
|
|
const pMin = p.min ?? 0; const pMax = p.max ?? 1;
|
|
if (Math.abs(pMax - pMin) < 0.001) return;
|
|
if (p.axis === 'x') {
|
|
const len = (pMax - pMin) * innerD;
|
|
const xPos = (-innerW/2) + (p.offset * innerW);
|
|
const zStart = (-innerD/2) + (pMin * innerD);
|
|
subtractHoles(len, p.height, xPos, thickness, zStart, 'z');
|
|
} else {
|
|
const len = (pMax - pMin) * innerW;
|
|
const xStart = (-innerW/2) + (pMin * innerW);
|
|
const zPos = (-innerD/2) + (p.offset * innerD);
|
|
subtractHoles(len, p.height, xStart, thickness, zPos, 'x');
|
|
}
|
|
});
|
|
}
|
|
|
|
return mainBrush.geometry;
|
|
};
|
|
|
|
export const generateSTL = (mesh: THREE.Object3D): Uint8Array | string => {
|
|
const exporter = new STLExporter();
|
|
const result = exporter.parse(mesh, { binary: true });
|
|
if (result instanceof DataView) return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
|
|
return result as string;
|
|
};
|
|
|
|
export const exportSTL = (mesh: THREE.Object3D, filename: string) => {
|
|
const result = generateSTL(mesh);
|
|
const blob = new Blob([result], { type: 'application/octet-stream' });
|
|
const link = document.createElement('a');
|
|
link.href = URL.createObjectURL(blob);
|
|
link.download = filename;
|
|
link.click();
|
|
}; |