2026-05-01 15:07:47 +05:30

1048 lines
31 KiB
TypeScript

import { useFrame } from '@react-three/fiber'
import {
type AnyNode,
type AnyNodeId,
type RoofNode,
type RoofSegmentNode,
type RoofType,
sceneRegistry,
useScene,
} from '@pascal-app/core'
import * as THREE from 'three'
import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
import { ADDITION, Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg'
import { computeBoundsTree } from 'three-mesh-bvh'
const csgEvaluator = new Evaluator()
csgEvaluator.useGroups = true
;(csgEvaluator as any).consolidateGroups = false // shared dummyMats across brushes causes consolidation to misalign groupIndices vs groupOrder indices → crash
csgEvaluator.attributes = ['position', 'normal', 'uv']
function computeGeometryBoundsTree(geometry: THREE.BufferGeometry) {
;(geometry as any).computeBoundsTree = computeBoundsTree
;(geometry as any).computeBoundsTree({ maxLeafSize: 10 })
}
function prepareBrushForCSG(brush: Brush) {
computeGeometryBoundsTree(brush.geometry)
brush.updateMatrixWorld()
}
// Pooled objects to avoid per-frame allocation in updateMergedRoofGeometry
const _matrix = new THREE.Matrix4()
const _position = new THREE.Vector3()
const _quaternion = new THREE.Quaternion()
const _scale = new THREE.Vector3(1, 1, 1)
const _yAxis = new THREE.Vector3(0, 1, 0)
const _uvFaceNormal = new THREE.Vector3()
// Pending merged-roof updates carried across frames (for throttling)
const pendingRoofUpdates = new Set<AnyNodeId>()
const MAX_ROOFS_PER_FRAME = 1
const MAX_SEGMENTS_PER_FRAME = 3
// ============================================================================
// ROOF SYSTEM
// ============================================================================
export const RoofSystem = () => {
const dirtyNodes = useScene((state) => state.dirtyNodes)
const clearDirty = useScene((state) => state.clearDirty)
const rootNodeIds = useScene((state) => state.rootNodeIds)
useFrame(() => {
// Clear stale pending updates when the scene is unloaded
if (rootNodeIds.length === 0) {
pendingRoofUpdates.clear()
return
}
if (dirtyNodes.size === 0 && pendingRoofUpdates.size === 0) return
const nodes = useScene.getState().nodes
// --- Pass 1: Process dirty roof-segments (throttled) ---
let segmentsProcessed = 0
dirtyNodes.forEach((id) => {
const node = nodes[id]
if (!node) return
if (node.type === 'roof-segment') {
const mesh = sceneRegistry.nodes.get(id) as THREE.Mesh
if (mesh) {
// Only compute expensive individual CSG when the segment is actually rendered
// (its parent group is visible = the roof is selected for editing)
const isVisible = mesh.parent?.visible !== false
if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
updateRoofSegmentGeometry(node as RoofSegmentNode, mesh)
segmentsProcessed++
} else if (isVisible) {
return // Over budget — keep dirty, process next frame
} else {
// Just sync transform, skip CSG — the merged roof handles visuals.
// But replace the initial BoxGeometry once: it has 6 groups (materialIndex 0-5)
// while roofMaterials only has 4 entries. Three.js raycasts into invisible groups,
// so MeshBVH hits groups[4].materialIndex → undefined.side → crash.
if (mesh.geometry.type === 'BoxGeometry') {
mesh.geometry.dispose()
const placeholder = new THREE.BufferGeometry()
placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3))
computeGeometryBoundsTree(placeholder)
mesh.geometry = placeholder
}
mesh.position.set(node.position[0], node.position[1], node.position[2])
mesh.rotation.y = node.rotation
}
clearDirty(id as AnyNodeId)
} else {
clearDirty(id as AnyNodeId)
}
// Queue the parent roof for a merged geometry update
if (node.parentId) {
pendingRoofUpdates.add(node.parentId as AnyNodeId)
}
} else if (node.type === 'roof') {
pendingRoofUpdates.add(id as AnyNodeId)
clearDirty(id as AnyNodeId)
}
})
// --- Pass 2: Process pending merged-roof updates (max 1 per frame) ---
let roofsProcessed = 0
for (const id of pendingRoofUpdates) {
if (roofsProcessed >= MAX_ROOFS_PER_FRAME) break
const node = nodes[id]
if (!node || node.type !== 'roof') {
pendingRoofUpdates.delete(id)
continue
}
const group = sceneRegistry.nodes.get(id) as THREE.Group
if (group) {
const mergedMesh = group.getObjectByName('merged-roof') as THREE.Mesh | undefined
if (mergedMesh?.visible !== false) {
// Only rebuild when visible — RoofEditSystem re-triggers via markDirty on edit mode exit
updateMergedRoofGeometry(node as RoofNode, group, nodes)
roofsProcessed++
}
}
pendingRoofUpdates.delete(id)
}
}, 5) // Priority 5: run after all other systems have settled
return null
}
// ============================================================================
// GEOMETRY GENERATION
// ============================================================================
function updateRoofSegmentGeometry(node: RoofSegmentNode, mesh: THREE.Mesh) {
const newGeo = generateRoofSegmentGeometry(node)
mesh.geometry.dispose()
mesh.geometry = newGeo
computeGeometryBoundsTree(newGeo)
mesh.position.set(node.position[0], node.position[1], node.position[2])
mesh.rotation.y = node.rotation
}
function updateMergedRoofGeometry(
roofNode: RoofNode,
group: THREE.Group,
nodes: Record<string, AnyNode>,
) {
const mergedMesh = group.getObjectByName('merged-roof') as THREE.Mesh | undefined
if (!mergedMesh) return
const children = (roofNode.children ?? [])
.map((id) => nodes[id] as RoofSegmentNode)
.filter(Boolean)
if (children.length === 0) {
mergedMesh.geometry.dispose()
// Keep a valid position attribute so Drei's BVH can index safely.
mergedMesh.geometry = new THREE.BoxGeometry(0, 0, 0)
return
}
let totalShinSlab: Brush | null = null
let totalDeckSlab: Brush | null = null
let totalWall: Brush | null = null
let totalInner: Brush | null = null
for (const child of children) {
const brushes = getRoofSegmentBrushes(child)
if (!brushes) continue
_matrix.compose(
_position.set(child.position[0], child.position[1], child.position[2]),
_quaternion.setFromAxisAngle(_yAxis, child.rotation),
_scale,
)
const applyTransform = (brush: Brush) => {
brush.geometry.applyMatrix4(_matrix)
brush.updateMatrixWorld()
}
applyTransform(brushes.shinSlab)
applyTransform(brushes.deckSlab)
applyTransform(brushes.wallBrush)
applyTransform(brushes.innerBrush)
if (totalShinSlab) {
const next: Brush = csgEvaluator.evaluate(totalShinSlab, brushes.shinSlab, ADDITION) as Brush
totalShinSlab.geometry.dispose()
brushes.shinSlab.geometry.dispose()
prepareBrushForCSG(next)
totalShinSlab = next
} else {
totalShinSlab = brushes.shinSlab
}
if (totalDeckSlab) {
const next: Brush = csgEvaluator.evaluate(totalDeckSlab, brushes.deckSlab, ADDITION) as Brush
totalDeckSlab.geometry.dispose()
brushes.deckSlab.geometry.dispose()
prepareBrushForCSG(next)
totalDeckSlab = next
} else {
totalDeckSlab = brushes.deckSlab
}
if (totalWall) {
const next: Brush = csgEvaluator.evaluate(totalWall, brushes.wallBrush, ADDITION) as Brush
totalWall.geometry.dispose()
brushes.wallBrush.geometry.dispose()
prepareBrushForCSG(next)
totalWall = next
} else {
totalWall = brushes.wallBrush
}
if (totalInner) {
const next: Brush = csgEvaluator.evaluate(totalInner, brushes.innerBrush, ADDITION) as Brush
totalInner.geometry.dispose()
brushes.innerBrush.geometry.dispose()
prepareBrushForCSG(next)
totalInner = next
} else {
totalInner = brushes.innerBrush
}
}
if (totalShinSlab && totalDeckSlab && totalWall && totalInner) {
try {
const finalShinTrimmed = csgEvaluator.evaluate(totalShinSlab, totalInner, SUBTRACTION)
const finalDeckTrimmed = csgEvaluator.evaluate(totalDeckSlab, totalInner, SUBTRACTION)
const finalWallTrimmed = csgEvaluator.evaluate(totalWall, totalInner, SUBTRACTION)
const shinDeck = csgEvaluator.evaluate(finalShinTrimmed, finalDeckTrimmed, ADDITION)
const combined = csgEvaluator.evaluate(shinDeck, finalWallTrimmed, ADDITION)
const resultGeo = combined.geometry
const resultMaterials: THREE.Material[] = Array.isArray(combined.material)
? combined.material
: [combined.material]
const matToIndex = new Map<THREE.Material, number>([
[dummyMats[0], 0],
[dummyMats[1], 1],
[dummyMats[2], 2],
[dummyMats[3], 3],
])
for (const g of resultGeo.groups) {
g.materialIndex = mapRoofGroupMaterialIndex(g.materialIndex, resultMaterials, matToIndex)
}
ensureUv2Attribute(resultGeo)
resultGeo.computeVertexNormals()
mergedMesh.geometry.dispose()
mergedMesh.geometry = resultGeo
finalShinTrimmed.geometry.dispose()
finalDeckTrimmed.geometry.dispose()
finalWallTrimmed.geometry.dispose()
shinDeck.geometry.dispose()
} catch (e) {
console.error('Merged roof CSG failed:', e)
}
totalShinSlab.geometry.dispose()
totalDeckSlab.geometry.dispose()
totalWall.geometry.dispose()
totalInner.geometry.dispose()
}
}
const dummyMats: [
THREE.MeshBasicMaterial,
THREE.MeshBasicMaterial,
THREE.MeshBasicMaterial,
THREE.MeshBasicMaterial,
] = [
new THREE.MeshBasicMaterial(),
new THREE.MeshBasicMaterial(),
new THREE.MeshBasicMaterial(),
new THREE.MeshBasicMaterial(),
]
const ROOF_MATERIAL_SLOT_COUNT = 4
function mapRoofGroupMaterialIndex(
groupMaterialIndex: number | undefined,
csgMaterials: THREE.Material[],
matToIndex: Map<THREE.Material, number>,
): number {
if (groupMaterialIndex === undefined) return 0
const sourceMaterial = csgMaterials[groupMaterialIndex]
const mappedIndex = sourceMaterial ? matToIndex.get(sourceMaterial) : undefined
return mappedIndex ?? 0
}
function normalizeRoofMaterialIndex(materialIndex: number | undefined): number {
if (materialIndex === undefined || !Number.isFinite(materialIndex)) return 0
const normalized = Math.trunc(materialIndex)
if (normalized < 0 || normalized >= ROOF_MATERIAL_SLOT_COUNT) return 0
return normalized
}
const SHINGLE_SURFACE_EPSILON = 0.02
const RAKE_FACE_NORMAL_EPSILON = 0.3
const RAKE_FACE_ALIGNMENT_EPSILON = 0.35
/**
* Generate complete hollow-shell geometry for a roof segment.
* Ports the prototype's CSG approach using three-bvh-csg.
*/
export function getRoofSegmentBrushes(
node: RoofSegmentNode,
): { deckSlab: Brush; shinSlab: Brush; wallBrush: Brush; innerBrush: Brush } | null {
const {
roofType,
width,
depth,
wallHeight,
roofHeight,
wallThickness,
deckThickness,
overhang,
shingleThickness,
} = node
const activeRh = roofType === 'flat' ? 0 : roofHeight
let run = Math.min(width, depth) / 2
let rise = activeRh
if (roofType === 'shed') {
run = depth
}
if (roofType === 'gable') {
run = depth / 2
}
if (roofType === 'gambrel') {
run = depth / 4
rise = activeRh * 0.6
}
if (roofType === 'mansard') {
run = Math.min(width, depth) * 0.15
rise = activeRh * 0.7
}
if (roofType === 'dutch') {
run = Math.min(width, depth) * 0.25
rise = activeRh * 0.5
}
const tanTheta = run > 0 ? rise / run : 0
const cosTheta = Math.cos(Math.atan2(rise, run)) || 1
const sinTheta = Math.sin(Math.atan2(rise, run)) || 0
const verticalRt = activeRh > 0 ? deckThickness / cosTheta : deckThickness
const baseI = Math.min(width, depth) * 0.25
const getVol = (
wExt: number,
vOffset: number,
baseY: number,
matIndex: number,
isVoid: boolean,
) => {
const wV = Math.max(0.01, width + 2 * wExt)
const dV = Math.max(0.01, depth + 2 * wExt)
const autoDrop = wExt * tanTheta
const whV = wallHeight - autoDrop + vOffset
let rhV = activeRh
if (activeRh > 0) {
rhV = activeRh + autoDrop
if (roofType === 'shed') rhV = activeRh + 2 * autoDrop
}
const safeBaseY = Math.min(baseY, whV - 0.05)
let structuralI = baseI
if (isVoid) {
structuralI += deckThickness
}
const faces = getModuleFaces(
roofType,
wV,
dV,
whV,
rhV,
safeBaseY,
{ dutchI: structuralI },
width,
depth,
tanTheta,
)
return createGeometryFromFaces(faces, matIndex)
}
const wallGeo = getVol(wallThickness / 2, 0, 0, 0, false)
const innerGeo = getVol(-wallThickness / 2, 0, -5, 2, false)
const horizontalOverhang = overhang * cosTheta
const deckExt = wallThickness / 2 + horizontalOverhang
const deckTopGeo = getVol(deckExt, verticalRt, 0, 1, false)
const deckBotGeo = getVol(deckExt, 0, -5, 0, true)
const stSin = shingleThickness * sinTheta
const stCos = shingleThickness * cosTheta
const shinBotW = Math.max(0.01, width + 2 * deckExt)
const shinBotD = Math.max(0.01, depth + 2 * deckExt)
const deckDrop = deckExt * tanTheta
const shinBotWh = wallHeight - deckDrop + verticalRt
let shinBotRh = activeRh
if (activeRh > 0) {
shinBotRh = activeRh + deckDrop
if (roofType === 'shed') shinBotRh = activeRh + 2 * deckDrop
}
let shinTopW = shinBotW
let shinTopD = shinBotD
let transZ = 0
if (['hip', 'mansard', 'dutch'].includes(roofType)) {
shinTopW += 2 * stSin
shinTopD += 2 * stSin
} else if (['gable', 'gambrel'].includes(roofType)) {
shinTopD += 2 * stSin
} else if (roofType === 'shed') {
shinTopD += stSin
transZ = stSin / 2
}
const shinTopWh = shinBotWh + stCos
let shinTopRh = shinBotRh
if (activeRh > 0) {
shinTopRh = shinBotRh + stSin * tanTheta
}
const availableR = (Math.min(shinBotW, shinBotD) / 2) * 0.95
const maxDrop = tanTheta > 0.001 ? availableR / tanTheta : 2.0
const dropTop = Math.min(1.0, maxDrop * 0.4)
const dropBot = Math.min(2.0, maxDrop * 0.8)
const topBaseY = shinBotWh - dropTop
const botBaseY = shinBotWh - dropBot
const getInsets = (wh: number, bY: number, isVoid: boolean, brushW: number, brushD: number) => {
let inset = (wh - bY) * tanTheta
const maxSafeInset = Math.min(brushW, brushD) / 2 - 0.005
if (inset > maxSafeInset) {
inset = maxSafeInset
}
let iF = 0,
iB = 0,
iL = 0,
iR = 0
if (['hip', 'mansard', 'dutch'].includes(roofType)) {
iF = inset
iB = inset
iL = inset
iR = inset
} else if (['gable', 'gambrel'].includes(roofType)) {
iF = inset
iB = inset
} else if (roofType === 'shed') {
iF = inset
}
let structuralI = baseI
if (isVoid) {
structuralI += shingleThickness
}
return { iF, iB, iL, iR, dutchI: structuralI }
}
const insetsBot = getInsets(shinBotWh, botBaseY, true, shinBotW, shinBotD)
const insetsTop = getInsets(shinTopWh, topBaseY, false, shinTopW, shinTopD)
const botFaces = getModuleFaces(
roofType,
shinBotW,
shinBotD,
shinBotWh,
shinBotRh,
botBaseY,
insetsBot,
width,
depth,
tanTheta,
)
const topFaces = getModuleFaces(
roofType,
shinTopW,
shinTopD,
shinTopWh,
shinTopRh,
topBaseY,
insetsTop,
width,
depth,
tanTheta,
)
const shinBotGeo = createGeometryFromFaces(botFaces, 1)
const shinTopGeo = createGeometryFromFaces(topFaces, (normal) =>
normal.y > SHINGLE_SURFACE_EPSILON ? 3 : 1,
)
if (transZ !== 0) {
shinTopGeo.translate(0, 0, transZ)
}
const toBrush = (geo: THREE.BufferGeometry): Brush | null => {
if (!geo?.attributes.position || geo.attributes.position.count === 0) return null
if (!geo.index) return null
// Strip zero-count groups — three-bvh-csg crashes with groupIndices[i] undefined
// when a group exists but covers no triangles (can happen after mergeVertices)
geo.groups = geo.groups.filter((g) => g.count > 0)
if (geo.groups.length === 0) return null
computeGeometryBoundsTree(geo)
const brush = new Brush(geo, dummyMats)
brush.updateMatrixWorld()
return brush
}
const eps = 0.002
const wallBrush = toBrush(wallGeo)
const innerBrush = toBrush(innerGeo)
if (innerBrush) {
const wV = Math.max(0.01, width - wallThickness)
const dV = Math.max(0.01, depth - wallThickness)
innerBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV)
innerBrush.updateMatrixWorld()
}
const deckTopBrush = toBrush(deckTopGeo)
const deckBotBrush = toBrush(deckBotGeo)
if (deckBotBrush) {
const wV = Math.max(0.01, width + 2 * deckExt)
const dV = Math.max(0.01, depth + 2 * deckExt)
deckBotBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV)
deckBotBrush.updateMatrixWorld()
}
const shinTopBrush = toBrush(shinTopGeo)
const shinBotBrush = toBrush(shinBotGeo)
if (shinBotBrush) {
const wV = shinBotW
const dV = shinBotD
shinBotBrush.scale.set(1 + eps / wV, 1, 1 + eps / dV)
shinBotBrush.updateMatrixWorld()
}
wallGeo.dispose()
innerGeo.dispose()
deckTopGeo.dispose()
deckBotGeo.dispose()
shinTopGeo.dispose()
shinBotGeo.dispose()
if (deckTopBrush && deckBotBrush && wallBrush && innerBrush && shinTopBrush && shinBotBrush) {
try {
const deckSlab = csgEvaluator.evaluate(deckTopBrush, deckBotBrush, SUBTRACTION)
const shinSlab = csgEvaluator.evaluate(shinTopBrush, shinBotBrush, SUBTRACTION)
deckTopBrush.geometry.dispose()
deckBotBrush.geometry.dispose()
shinTopBrush.geometry.dispose()
shinBotBrush.geometry.dispose()
return { deckSlab, shinSlab, wallBrush, innerBrush }
} catch (e) {
console.error('CSG prep failed:', e)
}
}
if (deckTopBrush) deckTopBrush.geometry.dispose()
if (deckBotBrush) deckBotBrush.geometry.dispose()
if (shinTopBrush) shinTopBrush.geometry.dispose()
if (shinBotBrush) shinBotBrush.geometry.dispose()
if (wallBrush) wallBrush.geometry.dispose()
if (innerBrush) innerBrush.geometry.dispose()
return null
}
export function generateRoofSegmentGeometry(node: RoofSegmentNode): THREE.BufferGeometry {
const brushes = getRoofSegmentBrushes(node)
if (!brushes) {
// Fallback: simple box
return new THREE.BoxGeometry(node.width, node.wallHeight, node.depth)
}
const { deckSlab, shinSlab, wallBrush, innerBrush } = brushes
let resultGeo = new THREE.BufferGeometry()
try {
const hollowWall = csgEvaluator.evaluate(wallBrush, innerBrush, SUBTRACTION)
const shinDeck = csgEvaluator.evaluate(shinSlab, deckSlab, ADDITION)
const combined = csgEvaluator.evaluate(shinDeck, hollowWall, ADDITION)
resultGeo = combined.geometry
const resultMaterials: THREE.Material[] = Array.isArray(combined.material)
? combined.material
: [combined.material]
const matToIndex = new Map<THREE.Material, number>([
[dummyMats[0], 0],
[dummyMats[1], 1],
[dummyMats[2], 2],
[dummyMats[3], 3],
])
for (const group of resultGeo.groups) {
group.materialIndex = mapRoofGroupMaterialIndex(
group.materialIndex,
resultMaterials,
matToIndex,
)
}
remapRoofShellFaces(resultGeo, node)
hollowWall.geometry.dispose()
shinDeck.geometry.dispose()
} catch (e) {
console.error('Roof CSG failed:', e)
resultGeo = wallBrush.geometry.clone()
}
deckSlab.geometry.dispose()
shinSlab.geometry.dispose()
wallBrush.geometry.dispose()
innerBrush.geometry.dispose()
ensureUv2Attribute(resultGeo)
resultGeo.computeVertexNormals()
return resultGeo
}
// ============================================================================
// FACE-BASED GEOMETRY HELPERS (ported from prototype)
// ============================================================================
type Insets = {
iF?: number
iB?: number
iL?: number
iR?: number
dutchI?: number
}
function remapRoofShellFaces(geometry: THREE.BufferGeometry, node: RoofSegmentNode) {
const position = geometry.getAttribute('position')
const index = geometry.getIndex()
if (!(position && index) || index.count === 0 || geometry.groups.length === 0) return
geometry.computeBoundingBox()
const triangleCount = index.count / 3
const triangleMaterials = new Array<number>(triangleCount).fill(0)
const a = new THREE.Vector3()
const b = new THREE.Vector3()
const c = new THREE.Vector3()
const ab = new THREE.Vector3()
const ac = new THREE.Vector3()
const centroid = new THREE.Vector3()
const normal = new THREE.Vector3()
for (const group of geometry.groups) {
const startTriangle = Math.floor(group.start / 3)
const endTriangle = Math.min(triangleCount, Math.floor((group.start + group.count) / 3))
for (let triangleIndex = startTriangle; triangleIndex < endTriangle; triangleIndex++) {
const indexOffset = triangleIndex * 3
let materialIndex = normalizeRoofMaterialIndex(group.materialIndex)
if (materialIndex === 1 || materialIndex === 3) {
const ia = index.getX(indexOffset)
const ib = index.getX(indexOffset + 1)
const ic = index.getX(indexOffset + 2)
a.fromBufferAttribute(position, ia)
b.fromBufferAttribute(position, ib)
c.fromBufferAttribute(position, ic)
ab.subVectors(b, a)
ac.subVectors(c, a)
normal.crossVectors(ab, ac).normalize()
centroid
.copy(a)
.add(b)
.add(c)
.multiplyScalar(1 / 3)
if (normal.y > SHINGLE_SURFACE_EPSILON) {
materialIndex = 3
} else if (isRakeFace(node, geometry, centroid, normal)) {
materialIndex = 0
} else {
materialIndex = 1
}
}
triangleMaterials[triangleIndex] = materialIndex
}
}
geometry.clearGroups()
let currentMaterial = triangleMaterials[0] ?? 0
let groupStart = 0
for (let triangleIndex = 1; triangleIndex < triangleCount; triangleIndex++) {
const materialIndex = triangleMaterials[triangleIndex] ?? 0
if (materialIndex === currentMaterial) continue
geometry.addGroup(groupStart * 3, (triangleIndex - groupStart) * 3, currentMaterial)
groupStart = triangleIndex
currentMaterial = materialIndex
}
geometry.addGroup(groupStart * 3, (triangleCount - groupStart) * 3, currentMaterial)
}
function isRakeFace(
node: RoofSegmentNode,
geometry: THREE.BufferGeometry,
centroid: THREE.Vector3,
normal: THREE.Vector3,
) {
const rakeAxis = getRakeAxis(node)
const bounds = geometry.boundingBox
if (!(rakeAxis && bounds)) return false
if (Math.abs(normal.y) > RAKE_FACE_NORMAL_EPSILON) return false
const axisNormal = rakeAxis === 'x' ? Math.abs(normal.x) : Math.abs(normal.z)
if (axisNormal < RAKE_FACE_ALIGNMENT_EPSILON) return false
const halfExtent =
rakeAxis === 'x'
? Math.max(Math.abs(bounds.min.x), Math.abs(bounds.max.x))
: Math.max(Math.abs(bounds.min.z), Math.abs(bounds.max.z))
const axisCoord = rakeAxis === 'x' ? Math.abs(centroid.x) : Math.abs(centroid.z)
const planeTolerance = Math.max(
node.overhang + node.wallThickness + node.deckThickness + node.shingleThickness,
0.25,
)
if (halfExtent - axisCoord > planeTolerance) return false
return true
}
function getRakeAxis(node: RoofSegmentNode): 'x' | 'z' | null {
if (node.roofType === 'gable' || node.roofType === 'gambrel') return 'x'
if (node.roofType === 'dutch') return node.width >= node.depth ? 'x' : 'z'
return null
}
/**
* Generates faces for a roof module volume.
* Supports: hip, gable, shed, gambrel, dutch, mansard, flat.
*/
function getModuleFaces(
type: RoofType,
w: number,
d: number,
wh: number,
rh: number,
baseY: number,
insets: Insets,
baseW: number,
baseD: number,
tanTheta: number,
): THREE.Vector3[][] {
const v = (x: number, y: number, z: number) => new THREE.Vector3(x, y, z)
const { iF = 0, iB = 0, iL = 0, iR = 0 } = insets
const b1 = v(-w / 2 + iL, baseY, d / 2 - iF)
const b2 = v(w / 2 - iR, baseY, d / 2 - iF)
const b3 = v(w / 2 - iR, baseY, -d / 2 + iB)
const b4 = v(-w / 2 + iL, baseY, -d / 2 + iB)
const bottom = [b4, b3, b2, b1]
const e1 = v(-w / 2, wh, d / 2)
const e2 = v(w / 2, wh, d / 2)
const e3 = v(w / 2, wh, -d / 2)
const e4 = v(-w / 2, wh, -d / 2)
const faces: THREE.Vector3[][] = []
faces.push([b1, b2, e2, e1], [b2, b3, e3, e2], [b3, b4, e4, e3], [b4, b1, e1, e4], bottom)
const h = wh + Math.max(0.001, rh)
if (type === 'flat' || rh === 0) {
faces.push([e1, e2, e3, e4])
} else if (type === 'gable') {
const r1 = v(-w / 2, h, 0)
const r2 = v(w / 2, h, 0)
faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2])
} else if (type === 'hip') {
if (Math.abs(w - d) < 0.01) {
const r = v(0, h, 0)
faces.push([e4, e1, r], [e1, e2, r], [e2, e3, r], [e3, e4, r])
} else if (w >= d) {
const r1 = v(-w / 2 + d / 2, h, 0)
const r2 = v(w / 2 - d / 2, h, 0)
faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2])
} else {
const r1 = v(0, h, d / 2 - w / 2)
const r2 = v(0, h, -d / 2 + w / 2)
faces.push([e1, e2, r1], [e3, e4, r2], [e2, e3, r2, r1], [e4, e1, r1, r2])
}
} else if (type === 'shed') {
const t1 = v(-w / 2, h, -d / 2)
const t2 = v(w / 2, h, -d / 2)
faces.push([e1, e2, t2, t1], [e2, e3, t2], [e3, e4, t1, t2], [e4, e1, t1])
} else if (type === 'gambrel') {
const mz = (baseD / 2) * 0.5
const dist = d / 2 - mz
const mh = wh + dist * (tanTheta || 0)
const m1 = v(-w / 2, mh, mz)
const m2 = v(w / 2, mh, mz)
const m3 = v(w / 2, mh, -mz)
const m4 = v(-w / 2, mh, -mz)
const r1 = v(-w / 2, h, 0)
const r2 = v(w / 2, h, 0)
faces.push(
[e4, e1, m1, r1, m4],
[e2, e3, m3, r2, m2],
[e1, e2, m2, m1],
[m1, m2, r2, r1],
[e3, e4, m4, m3],
[m3, m4, r1, r2],
)
} else if (type === 'mansard') {
const i = Math.min(baseW, baseD) * 0.15
const mh = wh + i * (tanTheta || 0)
const m1 = v(-w / 2 + i, mh, d / 2 - i)
const m2 = v(w / 2 - i, mh, d / 2 - i)
const m3 = v(w / 2 - i, mh, -d / 2 + i)
const m4 = v(-w / 2 + i, mh, -d / 2 + i)
const t1 = v(-w / 2 + i * 2, h, d / 2 - i * 2)
const t2 = v(w / 2 - i * 2, h, d / 2 - i * 2)
const t3 = v(w / 2 - i * 2, h, -d / 2 + i * 2)
const t4 = v(-w / 2 + i * 2, h, -d / 2 + i * 2)
if (w - i * 4 <= 0.01 || d - i * 4 <= 0.01) {
if (w >= d) {
const r1 = v(-w / 2 + d / 2, h, 0)
const r2 = v(w / 2 - d / 2, h, 0)
faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2])
} else {
const r1 = v(0, h, d / 2 - w / 2)
const r2 = v(0, h, -d / 2 + w / 2)
faces.push([e1, e2, r1], [e3, e4, r2], [e2, e3, r2, r1], [e4, e1, r1, r2])
}
} else {
faces.push(
[t1, t2, t3, t4],
[e1, e2, m2, m1],
[e2, e3, m3, m2],
[e3, e4, m4, m3],
[e4, e1, m1, m4],
[m1, m2, t2, t1],
[m2, m3, t3, t2],
[m3, m4, t4, t3],
[m4, m1, t1, t4],
)
}
} else if (type === 'dutch') {
const i = insets.dutchI !== undefined ? insets.dutchI : Math.min(baseW, baseD) * 0.25
const mh = wh + i * (tanTheta || 0)
if (w >= d) {
const m1 = v(-w / 2 + i, mh, d / 2 - i)
const m2 = v(w / 2 - i, mh, d / 2 - i)
const m3 = v(w / 2 - i, mh, -d / 2 + i)
const m4 = v(-w / 2 + i, mh, -d / 2 + i)
const r1 = v(-w / 2 + i, h, 0)
const r2 = v(w / 2 - i, h, 0)
faces.push(
[e1, e2, m2, m1],
[e2, e3, m3, m2],
[e3, e4, m4, m3],
[e4, e1, m1, m4],
[m4, m1, r1],
[m2, m3, r2],
[m1, m2, r2, r1],
[m3, m4, r1, r2],
)
} else {
const m1 = v(-w / 2 + i, mh, d / 2 - i)
const m2 = v(w / 2 - i, mh, d / 2 - i)
const m3 = v(w / 2 - i, mh, -d / 2 + i)
const m4 = v(-w / 2 + i, mh, -d / 2 + i)
const r1 = v(0, h, d / 2 - i)
const r2 = v(0, h, -d / 2 + i)
faces.push(
[e1, e2, m2, m1],
[e2, e3, m3, m2],
[e3, e4, m4, m3],
[e4, e1, m1, m4],
[m1, m2, r1],
[m3, m4, r2],
[m2, m3, r2, r1],
[m4, m1, r1, r2],
)
}
}
return faces
}
/**
* Converts an array of face polygons into a BufferGeometry.
* Each face is triangulated via fan triangulation.
*/
function createGeometryFromFaces(
faces: THREE.Vector3[][],
matRule: number | ((normal: THREE.Vector3) => number) | null = null,
): THREE.BufferGeometry {
const positions: number[] = []
const normals: number[] = []
const uvs: number[] = []
const indices: number[] = []
const groups: { start: number; count: number; materialIndex: number }[] = []
let vertexCount = 0
for (const face of faces) {
if (face.length < 3) continue
const p0 = face[0]!
const p1 = face[1]!
const p2 = face[2]!
const vA = new THREE.Vector3().subVectors(p1, p0)
const vB = new THREE.Vector3().subVectors(p2, p0)
const normal = new THREE.Vector3().crossVectors(vA, vB).normalize()
let assignedMatIndex = 0
if (typeof matRule === 'function') {
assignedMatIndex = matRule(normal)
} else if (matRule !== null && matRule !== undefined) {
assignedMatIndex = matRule
} else {
const isVertical = Math.abs(normal.y) < 0.01
assignedMatIndex = isVertical ? 0 : 1
}
let faceVertexCount = 0
const startVertexCount = vertexCount
for (let i = 1; i < face.length - 1; i++) {
const fi = face[i]!
const fi1 = face[i + 1]!
positions.push(p0.x, p0.y, p0.z)
positions.push(fi.x, fi.y, fi.z)
positions.push(fi1.x, fi1.y, fi1.z)
normals.push(normal.x, normal.y, normal.z)
normals.push(normal.x, normal.y, normal.z)
normals.push(normal.x, normal.y, normal.z)
pushRoofUv(uvs, p0, normal)
pushRoofUv(uvs, fi, normal)
pushRoofUv(uvs, fi1, normal)
indices.push(vertexCount, vertexCount + 1, vertexCount + 2)
faceVertexCount += 3
vertexCount += 3
}
groups.push({
start: startVertexCount,
count: faceVertexCount,
materialIndex: assignedMatIndex,
})
}
const geometry = new THREE.BufferGeometry()
geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3))
geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3))
geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2))
geometry.setIndex(indices)
for (const g of groups) {
geometry.addGroup(g.start, g.count, g.materialIndex)
}
// Merge identical vertices to optimize geometry for CSG and create clean topology
const mergedGeo = mergeVertices(geometry, 1e-4)
geometry.dispose()
ensureUv2Attribute(mergedGeo)
return mergedGeo
}
function pushRoofUv(uvs: number[], point: THREE.Vector3, normal: THREE.Vector3) {
_uvFaceNormal.copy(normal).normalize()
const absX = Math.abs(_uvFaceNormal.x)
const absY = Math.abs(_uvFaceNormal.y)
const absZ = Math.abs(_uvFaceNormal.z)
if (absY >= absX && absY >= absZ) {
uvs.push(point.x, point.z)
return
}
if (absX >= absZ) {
uvs.push(point.z, point.y)
return
}
uvs.push(point.x, point.y)
}
function ensureUv2Attribute(geometry: THREE.BufferGeometry) {
const uv = geometry.getAttribute('uv')
if (!uv) return
geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2))
}