1355 lines
69 KiB
JavaScript
1355 lines
69 KiB
JavaScript
/*!
|
|
* Tectum
|
|
* Copyright © 2026 Machiel Heinen.
|
|
* Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
|
|
* Zie LICENTIE.md.
|
|
*/
|
|
// ============================================================
|
|
// wall/wall-model.js — ENIGE bron van waarheid voor de wand-logica:
|
|
// ankerresolutie van openingen, regelwerk (stijlen), 3D-opbouw en de
|
|
// specificatie-berekening. Geen DOM. Wordt gebruikt door:
|
|
// - wall/wall.js (de losse wand-editor)
|
|
// - unit/unit.js (unit = vloer + 4 wanden)
|
|
// Wijzigingen aan de wand-logica horen dus HIER, zodat ze automatisch
|
|
// voor zowel de losse wand als de unit gelden.
|
|
//
|
|
// Werkt met een "wand-state" (zelfde formaat als getStateJson/JSON-export):
|
|
// { wall: {width, heightAll, heightLeft, heightRight, heightMid?, studWidth, ...},
|
|
// materials: {interior, exterior}, openings: [{id,w,h,y,anchor,offset}] }
|
|
//
|
|
// Plain script (geen ES-module), moet na core/geometry.js geladen worden.
|
|
// ============================================================
|
|
|
|
window.WallModel = (() => {
|
|
// Referentiedichtheden — hier hardcoded aanpasbaar (geen UI-velden meer,
|
|
// zoals afgesproken). Spaanplaat (binnenzijde) en cement-gebonden platen
|
|
// (optie voor de buitenzijde) gebruiken hetzelfde kg/m3 x volume-patroon
|
|
// als voorheen "OSB"; vochtdoek (andere buitenzijde-optie) blijft een
|
|
// kg/m2-membraan.
|
|
const DENSITY_WOOD_KGM3 = 450;
|
|
const DENSITY_SPAANPLAAT_KGM3 = 650;
|
|
const DENSITY_CEMENTPLAAT_KGM3 = 1250;
|
|
const DENSITY_DOEK_KGM2 = 1.5;
|
|
|
|
// Klein, bewust niet-nul luchtgaatje tussen plaat en houtwerk (zie
|
|
// build3D). Ook gebruikt voor de totale wanddikte (thicknessOf).
|
|
const SKIN_GAP_MM = 0.5;
|
|
|
|
// Standaard muurbalk: 38 x 235 mm (dikte x diepte), ingekocht in deze
|
|
// handelslengtes. Het zaagplan (planPurchase) kiest per staaf de lengte
|
|
// met zo min mogelijk snijverlies.
|
|
const STANDARD_BEAM = { width: 38, depth: 235 };
|
|
const STOCK_LENGTHS_MM = [3600, 4200, 4800, 5400];
|
|
|
|
// Hoeken: elke wandkop bestaat uit 2 stijlen tegen elkaar (38 + 38 mm).
|
|
const CORNER_STUDS = 2;
|
|
|
|
// Latwerk op het vochtdoek voor de gevelbekleding (WEO/Novalit): kruislat
|
|
// van 2 lagen, latten 20 (dik) x 30 (breed) mm, handelslengte 4000 mm,
|
|
// 400 mm h.o.h. in beide richtingen. De bovenste laag staat haaks op de
|
|
// richting van de gevelbekleding (materials.cladding). Alleen bij
|
|
// vochtdoek; cement-gebonden platen zijn voor steenstrips.
|
|
const BATTEN = { thick: 20, width: 30, length: 4000, spacing: 400 };
|
|
const CLADDING_DIRECTIONS = { horizontaal: 'Horizontaal', verticaal: 'Verticaal' };
|
|
const CLADDING_THICK_MM = 12; // gevelbekleding (WEO/Novalit), nog niet getekend
|
|
|
|
// Hoe ver de afgewerkte gevel buiten het wandvlak ligt (mm): bij vochtdoek
|
|
// de kruislat (2 lagen) + de gevelbekleding. Gebruikt o.a. voor de
|
|
// positie van gevellampen.
|
|
function claddingOffset(buitenMateriaal) {
|
|
return buitenMateriaal === 'vochtdoek' ? 2 * BATTEN.thick + CLADDING_THICK_MM : 0;
|
|
}
|
|
|
|
// Trasraam: strook cement-gebonden plaat (montage-achterkant voor de
|
|
// plint-afwerking) onderaan de gevel, vóór het vochtdoek; het latwerk
|
|
// begint erboven.
|
|
// De hoogte telt vanaf Y=0 van de vloer = het beloopbare vlak (bovenkant
|
|
// vloer), en dat is ook de onderkant van de wand: in wand-coördinaten
|
|
// loopt de strook dus van 0 tot de hoogte.
|
|
// Geeft null als hij uit staat. Alleen van toepassing op vochtdoek-wanden
|
|
// (cement-gebonden buitenzijde is al plaat).
|
|
const TRASRAAM_DEFAULT_MM = 350;
|
|
function trasraamFor(heightMM) {
|
|
if (!(heightMM > 0)) return null;
|
|
return { bottom: 0, top: heightMM };
|
|
}
|
|
// Hoekdoorloop van de buitenlagen. Een wand die tussen twee doorlopende
|
|
// wanden past (unit-hoek) moet met zijn buitenlagen ook de kopse kant
|
|
// (hoekstijlen) van die doorlopende wand bedekken: skinExt = { left,
|
|
// right } = dikte van die wand (mm, 0 = vrij uiteinde). Elke laag loopt
|
|
// daarbovenop nog door tot zijn eigen buitenvlak, zodat de hoek dicht is.
|
|
// depth = afstand van het buitenvlak van de laag tot het wandvlak (mm).
|
|
function cornerExt(skinExt, depth) {
|
|
const e = skinExt || {};
|
|
return { left: e.left > 0 ? e.left + depth : 0, right: e.right > 0 ? e.right + depth : 0 };
|
|
}
|
|
|
|
// Onderkant van vochtdoek en latwerk (wand-coördinaten, mm).
|
|
function skinStartY(trasraam) {
|
|
return trasraam ? Math.max(0, trasraam.top) : 0;
|
|
}
|
|
|
|
// Openingtypes met hun standaardmaat (mm). 'y' = hoogte onderkant.
|
|
const OPENING_TYPES = {
|
|
raam: { label: 'Raam', w: 500, h: 1900, y: 250 },
|
|
deur: { label: 'Deur', w: 900, h: 2150, y: 0 },
|
|
voordeur: { label: 'Voordeur', w: 1150, h: 2150, y: 0 }
|
|
};
|
|
// Deuren krijgen aan weerszijden een tweede stijl direct tegen de
|
|
// koningsstijl (stevigheid, computeFrame).
|
|
const isDoor = (op) => op.type === 'deur' || op.type === 'voordeur';
|
|
|
|
// Buitenzijde-materialen (sleutel -> weergavenaam). 'spaanplaat' is voor
|
|
// binnenwanden (aan beide zijden spaanplaat).
|
|
// 'geen': geen beplating aan de buitenzijde — naadwand-deel dat tegen het
|
|
// deel van de andere unit aan staat (HouseModel, naadwanden).
|
|
const EXTERIOR_MATERIALS = { vochtdoek: 'Vochtdoek', cementplaat: 'Cement-gebonden platen', spaanplaat: 'Spaanplaat', geen: 'Geen (naadzijde)' };
|
|
|
|
// Bovenrand van de wand (daklijn): één recht stuk van links naar rechts,
|
|
// of met een middenpunt (nok, wallPeak) twee stukken die elkaar daar
|
|
// raken. De nok ligt nooit lager dan de goten (buildConfig), dus de
|
|
// bovenrand is overal het MINIMUM van de (doorgetrokken) stukken — dat
|
|
// houdt at/under/rangeAbove simpel en maakt "laagste punt boven een
|
|
// opening" gelijk aan het laagste van de twee uiteinden.
|
|
// x t.o.v. het wandmidden, alles in mm x k (k = 0.001: meters).
|
|
// at(x) bovenkant (daklijn)
|
|
// under(x) onderkant bovenregel(s); knee = hun snijpunt (verstek)
|
|
// rangeAbove(y) [x0, x1] waar de daklijn boven y ligt (of null)
|
|
// crossings(y) x-posities waar de daklijn y kruist (knikpunten)
|
|
// underPts(a, b) onderkant bovenregel van a naar b, incl. knie
|
|
function topLine(CONFIG, k) {
|
|
k = k || 1;
|
|
const halfW = CONFIG.wallWidth / 2 * k;
|
|
const L = { x: -halfW, y: CONFIG.wallHeightLeft * k }, R = { x: halfW, y: CONFIG.wallHeightRight * k };
|
|
const pk = CONFIG.wallPeak ? { x: (CONFIG.wallPeak.x - CONFIG.wallWidth / 2) * k, y: CONFIG.wallPeak.h * k } : null;
|
|
const pts = pk ? [L, pk, R] : [L, R];
|
|
const segs = [];
|
|
for (let i = 0; i < pts.length - 1; i++) {
|
|
const a = pts[i], b = pts[i + 1], slope = (b.y - a.y) / (b.x - a.x);
|
|
segs.push({ a, b, slope, vo: CONFIG.plateThick * k * Math.sqrt(1 + slope * slope) });
|
|
}
|
|
const lineY = (sg, x) => sg.a.y + (x - sg.a.x) * sg.slope;
|
|
const at = (x) => Math.min(...segs.map(sg => lineY(sg, x)));
|
|
const under = (x) => Math.min(...segs.map(sg => lineY(sg, x) - sg.vo));
|
|
let knee = null;
|
|
if (segs.length === 2) {
|
|
const [s0, s1] = segs, ds = s0.slope - s1.slope;
|
|
// s0.a.y + (x - s0.a.x) s0.slope - vo0 = s1.a.y + (x - s1.a.x) s1.slope - vo1
|
|
const x = Math.abs(ds) > 1e-12
|
|
? ((s1.a.y - s1.a.x * s1.slope - s1.vo) - (s0.a.y - s0.a.x * s0.slope - s0.vo)) / ds
|
|
: pk.x;
|
|
knee = { x, y: under(x) };
|
|
}
|
|
const rangeAbove = (y) => {
|
|
let x0 = -halfW, x1 = halfW;
|
|
segs.forEach(sg => {
|
|
if (Math.abs(sg.slope) < 1e-12) { if (sg.a.y <= y) x1 = x0 - 1; return; }
|
|
const xc = sg.a.x + (y - sg.a.y) / sg.slope;
|
|
if (sg.slope > 0) x0 = Math.max(x0, xc); else x1 = Math.min(x1, xc);
|
|
});
|
|
return x1 > x0 ? [x0, x1] : null;
|
|
};
|
|
const crossings = (y) => segs.filter(sg => Math.abs(sg.slope) > 1e-12)
|
|
.map(sg => ({ sg, x: sg.a.x + (y - sg.a.y) / sg.slope }))
|
|
.filter(c => c.x > c.sg.a.x && c.x < c.sg.b.x).map(c => c.x);
|
|
const underPts = (xa, xb) => {
|
|
const out = [{ x: xa, y: under(xa) }];
|
|
if (knee && knee.x > xa && knee.x < xb) out.push({ x: knee.x, y: knee.y });
|
|
out.push({ x: xb, y: under(xb) });
|
|
return out;
|
|
};
|
|
return {
|
|
pts, segs, peak: pk, knee, at, under, rangeAbove, crossings, underPts,
|
|
maxY: Math.max(...pts.map(p => p.y)), minY: Math.min(L.y, R.y),
|
|
kinks: pk ? [pk.x] : []
|
|
};
|
|
}
|
|
|
|
// Omtrek(ken) van de bovenregel(s) (zelfde eenheid als topLine): één
|
|
// parallellogram, of met nok twee stukken in verstek (nok boven, knie onder).
|
|
function topPlateOutlines(tl) {
|
|
const [L, R] = [tl.pts[0], tl.pts[tl.pts.length - 1]];
|
|
if (!tl.peak) {
|
|
const vo = tl.segs[0].vo;
|
|
return [[L, R, { x: R.x, y: R.y - vo }, { x: L.x, y: L.y - vo }]];
|
|
}
|
|
const P = tl.peak, K = tl.knee;
|
|
return [
|
|
[L, P, K, { x: L.x, y: L.y - tl.segs[0].vo }],
|
|
[P, R, { x: R.x, y: R.y - tl.segs[1].vo }, K]
|
|
];
|
|
}
|
|
|
|
// Heuristiek (geen volwaardige constraint-solver): elke opening wordt eerst
|
|
// individueel gepositioneerd op basis van zijn anker, dan van links naar
|
|
// rechts gesorteerd en tegen elkaar aan geduwd als er overlap is, en tot
|
|
// slot terug binnen de wand getrokken als de laatste opening over de
|
|
// rechter rand heen zou steken. Als openingen simpelweg niet allemaal
|
|
// passen bij de huidige wandbreedte, wordt dat expliciet gemeld i.p.v.
|
|
// stil verkeerd te tekenen.
|
|
//
|
|
// Breedte/positie (x) worden EERST volledig opgelost; pas daarna wordt per
|
|
// opening de hoogte/Y geklemd tegen de daklijn — en wel de daklijn ZOALS
|
|
// DIE OP DE EIGEN (definitieve) POSITIE van die opening loopt, niet tegen
|
|
// het laagste punt van de hele wand. Bij een hellende wand mag een opening
|
|
// dicht bij de hoge kant dus hoger/groter zijn dan een opening dicht bij
|
|
// de lage kant.
|
|
// roofAt(xLocal): daklijn, xLocal vanaf de linker wandrand (0..wallWidth).
|
|
function resolveOpenings(rawOpenings, wallWidth, studWidth, roofAt, plateThick) {
|
|
// 2850mm is de vaste referentie-bovengrens (bijv. max. sparingbreedte in
|
|
// dit constructiesysteem); daarnaast blijft de wand zelf ook een harde
|
|
// grens (er moet nog stijlruimte overblijven).
|
|
const maxOpW = Math.min(2850, Math.max(400, wallWidth - (studWidth * (2 * CORNER_STUDS + 2))));
|
|
// Openingen blijven vrij van de dubbele hoekstijl; de koningsstijl mag
|
|
// tegen de binnenste hoekstijl aan vallen.
|
|
const edgeMargin = studWidth * CORNER_STUDS;
|
|
|
|
// Fase 1: breedte + x-positie (ankers), zonder hoogte/Y.
|
|
let resolved = rawOpenings.map(raw => {
|
|
const w = Math.min(Math.max(400, raw.w), maxOpW);
|
|
|
|
let x;
|
|
if (raw.anchor === 'right') x = wallWidth - raw.offset - w;
|
|
else if (raw.anchor === 'middle') x = (wallWidth - w) / 2 + raw.offset;
|
|
else x = raw.offset;
|
|
|
|
return { id: raw.id, type: raw.type || 'raam', w, anchor: raw.anchor, offset: raw.offset, x, rawH: raw.h, rawY: raw.y };
|
|
});
|
|
|
|
resolved.sort((a, b) => a.x - b.x);
|
|
|
|
// Individuele randclamp (marge voor een stijl aan weerszijden van de wand)
|
|
resolved.forEach(o => {
|
|
o.x = Math.max(edgeMargin, Math.min(o.x, wallWidth - o.w - edgeMargin));
|
|
});
|
|
|
|
// Openingen die elkaar in de hoogte raken (incl. boven-/onderdorpel en
|
|
// 2x stijldikte ertussen) moeten naast elkaar; staan ze boven elkaar
|
|
// (bijv. een raam boven een deur), dan mogen ze in x overlappen.
|
|
// Hoogte hier op basis van de invoer; na fase 2 wordt het nog gecontroleerd.
|
|
const vBand = (o, h, y) => [y > plateThick ? y - studWidth : 0, y + h + studWidth];
|
|
const stacked = (a, b, useFinal) => {
|
|
const [a0, a1] = useFinal ? vBand(a, a.h, a.y) : vBand(a, Math.max(400, a.rawH), a.rawY);
|
|
const [b0, b1] = useFinal ? vBand(b, b.h, b.y) : vBand(b, Math.max(400, b.rawH), b.rawY);
|
|
return a1 <= b0 + 0.5 || b1 <= a0 + 0.5;
|
|
};
|
|
// Tussenruimte naast elkaar: 2x stijldikte i.p.v. 1x: de OSB-uitsparing
|
|
// rond elke opening steekt aan weerszijden al 1x stijldikte uit (om de
|
|
// koningsstijl zichtbaar te laten), dus bij minder afstand zouden hun
|
|
// uitsparingen elkaar kunnen overlappen. Naast een deur 1x extra voor
|
|
// de dubbele stijl.
|
|
const gapOf = (a, b) => studWidth * (2 + (isDoor(a) ? 1 : 0) + (isDoor(b) ? 1 : 0));
|
|
|
|
// Links-naar-rechts: duw botsende openingen uit elkaar.
|
|
for (let i = 1; i < resolved.length; i++) {
|
|
const cur = resolved[i];
|
|
for (let j = 0; j < i; j++) {
|
|
const prev = resolved[j];
|
|
if (stacked(prev, cur)) continue;
|
|
cur.x = Math.max(cur.x, prev.x + prev.w + gapOf(prev, cur));
|
|
}
|
|
}
|
|
|
|
// Rechts-naar-links: wat over de rechterrand steekt terugtrekken, en de
|
|
// botsende openingen links ervan mee.
|
|
const rightLimit = wallWidth - edgeMargin;
|
|
for (let i = resolved.length - 1; i >= 0; i--) {
|
|
const cur = resolved[i];
|
|
let maxX = rightLimit - cur.w;
|
|
for (let j = i + 1; j < resolved.length; j++) {
|
|
const next = resolved[j];
|
|
if (!stacked(cur, next)) maxX = Math.min(maxX, next.x - gapOf(cur, next) - cur.w);
|
|
}
|
|
if (cur.x > maxX) cur.x = maxX;
|
|
}
|
|
|
|
// Fase 2: hoogte (h) en verticale positie (y), per opening geklemd tegen
|
|
// de daklijn zoals die loopt op de EIGEN (nu definitieve) x-positie van
|
|
// die opening — het punt waar een verticale lijn op die plek de
|
|
// (eventueel hellende) horizontale topbalk zou snijden. Bij een
|
|
// opening die zelf een breedte heeft, wordt het laagste van de twee
|
|
// uiteinden aangehouden (de daklijn is lineair of heeft een nok als
|
|
// hoogste punt, dus dat is voldoende).
|
|
const localRoofHeightAt = roofAt;
|
|
|
|
resolved.forEach(o => {
|
|
const localCeiling = Math.min(localRoofHeightAt(o.x), localRoofHeightAt(o.x + o.w));
|
|
const maxAllowedOpH = Math.max(400, localCeiling - (plateThick * 2));
|
|
const h = Math.min(Math.max(400, o.rawH), maxAllowedOpH);
|
|
const maxOpY = Math.max(0, localCeiling - h - plateThick);
|
|
const y = Math.max(0, Math.min(o.rawY, maxOpY));
|
|
o.h = h;
|
|
o.y = y;
|
|
});
|
|
|
|
// Detecteer of het na dit alles nog steeds niet past (te veel/te brede
|
|
// openingen voor deze wandbreedte, of boven elkaar zonder ruimte
|
|
// ertussen) zodat de UI dit kan tonen.
|
|
resolved.forEach(o => {
|
|
o.overflowing = (o.x < edgeMargin - 0.5) || (o.x + o.w > wallWidth - edgeMargin + 0.5);
|
|
});
|
|
for (let i = 0; i < resolved.length; i++) {
|
|
for (let j = i + 1; j < resolved.length; j++) {
|
|
const a = resolved[i], b = resolved[j];
|
|
const [l, r] = a.x <= b.x ? [a, b] : [b, a];
|
|
if (!stacked(a, b, true) && r.x < l.x + l.w + gapOf(l, r) - 0.5) { a.overflowing = true; b.overflowing = true; }
|
|
}
|
|
}
|
|
|
|
return resolved;
|
|
}
|
|
|
|
// Zet ruwe (DOM- of JSON-)parameters om naar de opgeloste CONFIG waar de
|
|
// rest van de logica mee rekent (afronding + fallback-waarden, en de
|
|
// openingen al geresolved op hun anker).
|
|
function buildConfig(params, rawOpenings) {
|
|
const wallWidth = Math.round(params.width || 3000);
|
|
const hLeft = Math.round(params.heightLeft || 2400);
|
|
const hRight = Math.round(params.heightRight || 2900);
|
|
const studWidth = Math.round(params.studWidth || STANDARD_BEAM.width);
|
|
const plateThick = Math.round(params.plateThick || STANDARD_BEAM.width);
|
|
// Middenpunt (nok): standaard midden op de wand, of op peakX (mm vanaf
|
|
// links; een wandstuk uit een unit waar de nok niet in het midden
|
|
// valt). Nooit lager dan de hoogste goot; gelijk = geen nok.
|
|
let wallPeak = null;
|
|
if (params.heightMid > 0) {
|
|
const px = params.peakX !== undefined ? params.peakX : wallWidth / 2;
|
|
const h = Math.round(Math.max(params.heightMid, hLeft, hRight));
|
|
if (px > 1 && px < wallWidth - 1 && h > hLeft + (px / wallWidth) * (hRight - hLeft) + 0.5) wallPeak = { x: px, h };
|
|
}
|
|
const roofAt = (x) => wallPeak
|
|
? (x <= wallPeak.x ? hLeft + x / wallPeak.x * (wallPeak.h - hLeft) : wallPeak.h + (x - wallPeak.x) / (wallWidth - wallPeak.x) * (hRight - wallPeak.h))
|
|
: hLeft + (x / wallWidth) * (hRight - hLeft);
|
|
|
|
return {
|
|
wallWidth,
|
|
wallHeightLeft: hLeft,
|
|
wallHeightRight: hRight,
|
|
wallPeak,
|
|
studWidth,
|
|
studDepth: Math.round(params.studDepth || STANDARD_BEAM.depth),
|
|
plateThick,
|
|
plateDepth: Math.round(params.plateDepth || STANDARD_BEAM.depth),
|
|
sheathingThick: Math.round(params.sheathingThick || 10),
|
|
minSpacing: Math.round(params.minSpacing || 240),
|
|
maxSpacing: Math.round(params.maxSpacing || 480),
|
|
openings: resolveOpenings(rawOpenings, wallWidth, studWidth, roofAt, plateThick)
|
|
};
|
|
}
|
|
|
|
function configFromState(state) {
|
|
return buildConfig(state.wall, state.openings || []);
|
|
}
|
|
|
|
// Totale wanddikte (mm): regelwerk + beplating aan beide zijden (bij
|
|
// buitenMateriaal 'geen' alleen aan de binnenzijde). Gebruikt door de unit
|
|
// om wanden met hun buitenkant op de vloerrand te zetten.
|
|
function thicknessOf(config, buitenMateriaal) {
|
|
const sides = buitenMateriaal === 'geen' ? 1 : 2;
|
|
return Math.max(config.studDepth, config.plateDepth) + sides * (config.sheathingThick + SKIN_GAP_MM);
|
|
}
|
|
|
|
// Regelwerk: volledige stijlen (incl. koningsstijlen) + kreupele stijlen.
|
|
function computeFrame(CONFIG) {
|
|
const startX = -CONFIG.wallWidth / 2;
|
|
const top = topLine(CONFIG);
|
|
const slope = top.segs[0].slope;
|
|
// Met nok: de steilste helling (beide kanten lopen dan op naar de nok).
|
|
const angleDeg = top.peak
|
|
? Math.round(Math.max(...top.segs.map(sg => Math.atan(Math.abs(sg.slope)))) * (180 / Math.PI))
|
|
: Math.round(Math.atan(slope) * (180 / Math.PI));
|
|
|
|
// Dubbele hoekstijlen: de buitenste staat op de wandrand, de tweede er
|
|
// direct tegenaan. De regelmatige verdeling begint bij de binnenste.
|
|
const cornerInset = (CORNER_STUDS - 1) * CONFIG.studWidth;
|
|
const outerLeftStudX = startX + CONFIG.studWidth / 2;
|
|
const outerRightStudX = startX + CONFIG.wallWidth - CONFIG.studWidth / 2;
|
|
const wallLeftStudX = outerLeftStudX + cornerInset;
|
|
const wallRightStudX = outerRightStudX - cornerInset;
|
|
const cornerStuds = [];
|
|
for (let i = 0; i < CORNER_STUDS; i++) {
|
|
cornerStuds.push(outerLeftStudX + i * CONFIG.studWidth, outerRightStudX - i * CONFIG.studWidth);
|
|
}
|
|
|
|
// Stijlen als stukken { x, y0, y1, kind } (mm; y1 null = tot de
|
|
// daklijn). Eerst kandidaat-posities, daarna wordt elke kandidaat
|
|
// opgeknipt door de openingen (incl. boven-/onderdorpel) die hij kruist.
|
|
// Zo kunnen openingen ook boven elkaar staan (raam boven een deur): de
|
|
// stijlen ertussen lopen van dorpel tot dorpel.
|
|
// hoek dubbele hoekstijl
|
|
// koning koningsstijl direct naast een opening
|
|
// dubbel tweede stijl direct tegen de koningsstijl van een deur
|
|
// regel regelmatige verdeling in de vrije zones
|
|
// kreupel boven/onder een opening, binnen de openingbreedte
|
|
const sw = CONFIG.studWidth;
|
|
const ops = CONFIG.openings; // al gesorteerd op x door resolveOpenings
|
|
const bands = ops.map(op => ({
|
|
op, x0: startX + op.x, x1: startX + op.x + op.w,
|
|
y0: op.y > CONFIG.plateThick ? op.y - sw : 0, y1: op.y + op.h + sw
|
|
}));
|
|
const cands = [];
|
|
cornerStuds.forEach(x => cands.push({ x, kind: 'hoek' }));
|
|
ops.forEach(op => {
|
|
const x0 = startX + op.x, x1 = x0 + op.w;
|
|
cands.push({ x: x0 - sw / 2, kind: 'koning' }, { x: x1 + sw / 2, kind: 'koning' });
|
|
if (isDoor(op)) cands.push({ x: x0 - 1.5 * sw, kind: 'dubbel' }, { x: x1 + 1.5 * sw, kind: 'dubbel' });
|
|
});
|
|
|
|
// Kolommen: openingen (incl. hun stijlen) die elkaar in x overlappen.
|
|
// Tussen de kolommen en de hoekstijlen: regelmatige verdeling.
|
|
const cols = [];
|
|
ops.map(op => {
|
|
const extra = (isDoor(op) ? 2 : 1) * sw;
|
|
return [startX + op.x - extra + sw / 2, startX + op.x + op.w + extra - sw / 2]; // hartlijnen buitenste stijlen
|
|
}).sort((p, q) => p[0] - q[0]).forEach(r => {
|
|
const last = cols[cols.length - 1];
|
|
if (last && r[0] < last[1] + sw) last[1] = Math.max(last[1], r[1]);
|
|
else cols.push(r.slice());
|
|
});
|
|
const edges = [wallLeftStudX];
|
|
cols.forEach(c => edges.push(c[0], c[1]));
|
|
edges.push(wallRightStudX);
|
|
for (let i = 0; i < edges.length; i += 2) {
|
|
const a = edges[i], b = edges[i + 1];
|
|
if (b - a > sw) calculateSegmentPositions(b - a, CONFIG.minSpacing, CONFIG.maxSpacing).forEach(p => cands.push({ x: a + p, kind: 'regel' }));
|
|
}
|
|
ops.forEach(op => calculateSegmentPositions(op.w, CONFIG.minSpacing, CONFIG.maxSpacing)
|
|
.forEach(p => cands.push({ x: startX + op.x + p, kind: 'kreupel', owner: op })));
|
|
|
|
// Knippen op de openingen.
|
|
const PRIO = { hoek: 0, koning: 1, dubbel: 2, regel: 3, kreupel: 4 };
|
|
const roofMin = (x) => Math.min(...top.underPts(x - sw / 2, x + sw / 2).map(p => p.y));
|
|
const segs = [];
|
|
cands.forEach(c => {
|
|
const x = Math.round(c.x);
|
|
const hit = bands.filter(bd => Math.min(bd.x1, x + sw / 2) - Math.max(bd.x0, x - sw / 2) > 0.5).sort((p, q) => p.y0 - q.y0);
|
|
let cur = CONFIG.plateThick, below = null;
|
|
const push = (y0, y1, above) => {
|
|
if (c.kind === 'kreupel') {
|
|
// Alleen direct boven of onder de eigen opening; onder de opening
|
|
// niet als hij op een andere opening uitkomt (dat stuk vult de
|
|
// kreupele stijl van de onderste opening al).
|
|
const onTop = below && below.op === c.owner, underneath = above && above.op === c.owner;
|
|
if (!onTop && !(underneath && !below)) return;
|
|
}
|
|
segs.push({ x, y0, y1, kind: c.kind });
|
|
};
|
|
hit.forEach(bd => {
|
|
if (bd.y0 > cur + 1) push(cur, bd.y0, bd);
|
|
if (bd.y1 > cur) { cur = bd.y1; below = bd; }
|
|
});
|
|
if (roofMin(x) > cur + 1) push(cur, null, null);
|
|
});
|
|
// Dubbelingen (bijv. koningsstijl op de hoekstijl) weg: hoogste prioriteit wint.
|
|
const studs = [];
|
|
segs.sort((p, q) => PRIO[p.kind] - PRIO[q.kind]).forEach(sg => {
|
|
const top1 = sg.y1 === null ? Infinity : sg.y1;
|
|
const clash = studs.some(o => Math.abs(o.x - sg.x) < sw - 0.5 &&
|
|
Math.min(top1, o.y1 === null ? Infinity : o.y1) - Math.max(sg.y0, o.y0) > 1);
|
|
if (!clash) studs.push(sg);
|
|
});
|
|
studs.sort((p, q) => p.x - q.x || p.y0 - q.y0);
|
|
// Volle stijlen (onderregel tot daklijn), o.a. voor de maatvoering.
|
|
const fullStuds = [...new Set(studs.filter(sg => sg.y1 === null && sg.y0 <= CONFIG.plateThick).map(sg => sg.x))].sort((a, b) => a - b);
|
|
|
|
return { studs, fullStuds, slope, angleDeg };
|
|
}
|
|
|
|
// Uitsparing in de beplating/het vochtdoek per opening (mm; x t.o.v. het
|
|
// wandmidden, y vanaf de onderkant): de opening + 1x stijldikte marge
|
|
// links/rechts/boven, zodat de koningsstijlen en bovendorpel zichtbaar
|
|
// blijven. De bovenkant wordt defensief tegen de lokale daklijn geklemd —
|
|
// bij een sterk hellende wand met een opening dicht bij de lage kant kan
|
|
// de marge anders lokaal boven het dak uitkomen (kapotte uitsparing).
|
|
// Gebruikt door build3D (fill) én de 2D-tekening (naad-/baanlijnen).
|
|
function sheathingHoles(CONFIG) {
|
|
const halfW = CONFIG.wallWidth / 2;
|
|
const topYAt = topLine(CONFIG).at;
|
|
const roofSafetyMargin = 10;
|
|
return CONFIG.openings.map(op => {
|
|
const hx0 = -halfW + op.x - CONFIG.studWidth;
|
|
const hx1 = -halfW + op.x + op.w + CONFIG.studWidth;
|
|
let hy1 = op.y + op.h + CONFIG.studWidth;
|
|
const localRoofCeiling = Math.min(topYAt(hx0), topYAt(hx1)) - roofSafetyMargin;
|
|
if (hy1 > localRoofCeiling) hy1 = Math.max(op.y + roofSafetyMargin, localRoofCeiling);
|
|
return { hx0, hx1, hy0: op.y, hy1 };
|
|
});
|
|
}
|
|
|
|
// Stukken van een horizontale lijn op hoogte y (mm) die OP de beplating
|
|
// liggen: binnen de wand-omtrek (incl. schuine top) en buiten de
|
|
// uitsparingen. Geeft [[x0, x1], ...] terug (mm, t.o.v. het wandmidden).
|
|
function skinSegmentsAtY(CONFIG, y) {
|
|
if (y <= 0) return [];
|
|
// Deel van de breedte waar de daklijn boven y ligt.
|
|
const range = topLine(CONFIG).rangeAbove(y);
|
|
if (!range) return [];
|
|
let segments = [range];
|
|
sheathingHoles(CONFIG).filter(h => y > h.hy0 && y < h.hy1).forEach(h => {
|
|
segments = segments.flatMap(([a, b]) => {
|
|
if (h.hx1 <= a || h.hx0 >= b) return [[a, b]];
|
|
const out = [];
|
|
if (h.hx0 > a) out.push([a, h.hx0]);
|
|
if (h.hx1 < b) out.push([h.hx1, b]);
|
|
return out;
|
|
});
|
|
});
|
|
return segments;
|
|
}
|
|
|
|
// Kruislat (pure berekening, mm, x t.o.v. het wandmidden). Latten worden
|
|
// uitgespaard rond de openingen (zelfde uitsparing als het vochtdoek,
|
|
// sheathingHoles) en afgekapt op de (schuine) bovenrand.
|
|
// Geeft { top, under, layers: { horizontaal: [...], verticaal: [...] },
|
|
// lengths: [...], stock: {count, wasteMM}, totalLengthMM }.
|
|
// facade (optioneel, woning): { u0, extStart, isEnd } — plaats van dit
|
|
// wandstuk in de doorlopende gevel (zie HouseModel.assignFacades): u0 =
|
|
// afstand (mm, wandvlak) van het gevelbegin (incl. hoekdoorloop) tot de
|
|
// linkerrand van dit stuk. Het verticale latten-raster volgt dan de
|
|
// hele gevel i.p.v. per stuk opnieuw te beginnen; een eindlat komt
|
|
// alleen aan het einde van de gevel.
|
|
// facade.gridY0 (optioneel, mm, wand-coördinaten): hoogte waarop het
|
|
// horizontale latten-raster van de hele gevel begint. Een wandstuk dat
|
|
// hoger begint (opbouw, blootliggende naadwand) volgt zo hetzelfde raster.
|
|
// skinFrom (optioneel, mm): buitenafwerking pas vanaf deze hoogte (het
|
|
// blootliggende deel van een naadwand boven het dak van de andere unit).
|
|
function computeBattens(CONFIG, cladding, trasraam, skinExt, facade, skinFrom) {
|
|
const y0 = Math.max(skinStartY(trasraam), skinFrom || 0); // boven het trasraam
|
|
const ext = cornerExt(skinExt, 2 * BATTEN.thick); // over de hoekstijlen van de doorlopende wand
|
|
const xL = -CONFIG.wallWidth / 2 - ext.left, xR = CONFIG.wallWidth / 2 + ext.right;
|
|
const gridX0 = facade ? -CONFIG.wallWidth / 2 - facade.u0 - (facade.extStart ? 2 * BATTEN.thick : 0) : xL;
|
|
const isEnd = facade ? facade.isEnd : true;
|
|
const halfW = CONFIG.wallWidth / 2;
|
|
const tl = topLine(CONFIG), topYAt = tl.at;
|
|
const holes = sheathingHoles(CONFIG);
|
|
const w = BATTEN.width, sp = BATTEN.spacing;
|
|
const top = (cladding === 'verticaal') ? 'horizontaal' : 'verticaal';
|
|
|
|
// Horizontale latten: vanaf de onderkant elke 400 mm (hartmaat).
|
|
const horizontaal = [];
|
|
let yStart = y0 + w / 2;
|
|
if (facade && facade.gridY0 !== undefined) {
|
|
const g = facade.gridY0 + w / 2;
|
|
yStart = g + Math.max(0, Math.ceil((yStart - g) / sp - 1e-9)) * sp;
|
|
}
|
|
for (let y = yStart; y < tl.maxY - w / 2; y += sp) {
|
|
skinSegmentsAtY(CONFIG, y).forEach(([x0, x1]) => {
|
|
if (x0 <= -halfW + 0.5) x0 = xL;
|
|
if (x1 >= halfW - 0.5) x1 = xR;
|
|
if (x1 - x0 > w) horizontaal.push({ x0, x1, y });
|
|
});
|
|
}
|
|
// Verticale latten: vanaf de linkerrand elke 400 mm, plus een lat op de rechterrand.
|
|
const xs = [];
|
|
// Raster vanaf het gevelbegin; een lat hoort bij het stuk waar zijn hart in valt.
|
|
for (let x = gridX0 + w / 2 + Math.max(0, Math.ceil((xL - gridX0 - w / 2) / sp - 1e-9)) * sp; x <= xR - (isEnd ? w / 2 - 0.5 : 0) && x < xR; x += sp) xs.push(x);
|
|
if (isEnd && (!xs.length || xR - w / 2 - xs[xs.length - 1] > 50)) xs.push(xR - w / 2);
|
|
const verticaal = [];
|
|
xs.forEach(x => {
|
|
const yTop = Math.min(topYAt(x - w / 2), topYAt(x + w / 2));
|
|
let segs = [[y0, yTop]];
|
|
holes.filter(h => x + w / 2 > h.hx0 && x - w / 2 < h.hx1).forEach(h => {
|
|
segs = segs.flatMap(([a, b]) => {
|
|
if (h.hy1 <= a || h.hy0 >= b) return [[a, b]];
|
|
const out = [];
|
|
if (h.hy0 > a) out.push([a, h.hy0]);
|
|
if (h.hy1 < b) out.push([h.hy1, b]);
|
|
return out;
|
|
});
|
|
});
|
|
segs.filter(([a, b]) => b - a > w).forEach(([y0, y1]) => verticaal.push({ x, y0, y1 }));
|
|
});
|
|
|
|
const lengths = horizontaal.map(b => b.x1 - b.x0).concat(verticaal.map(b => b.y1 - b.y0));
|
|
const bars = lengths.length ? planStockCutting(lengths, [BATTEN.length]) : [];
|
|
const sum = summarizeStockPlan(bars);
|
|
return {
|
|
top, under: top === 'verticaal' ? 'horizontaal' : 'verticaal',
|
|
layers: { horizontaal, verticaal }, lengths,
|
|
stock: { count: bars.length, wasteMM: sum.wasteMM },
|
|
totalLengthMM: lengths.reduce((a, b) => a + b, 0)
|
|
};
|
|
}
|
|
|
|
// Vochtdoek-bedrukking zoals op de echte doeken: het logo als medium-grijs
|
|
// watermerk (geen kleur) onder 45°, 1,5m breed. De doekbanen hebben
|
|
// ExtrudeGeometry-UV's in meters (vormcoördinaten), dus repeat = 1/tegel.
|
|
// Eén gedeelde textuur; zonder DOM (node-tests) valt hij weg.
|
|
const DOEK_COLOR = '#444444';
|
|
const WATERMARK = { color: '#8c8c8c', logoWidthM: 1.5, tileM: 2.0, px: 512 };
|
|
let doekTexture = null;
|
|
function getDoekTexture() {
|
|
if (doekTexture !== null) return doekTexture || null;
|
|
doekTexture = false;
|
|
if (typeof document === 'undefined' || !window.TECTUM_LOGO) return null;
|
|
const canvas = document.createElement('canvas');
|
|
canvas.width = canvas.height = WATERMARK.px;
|
|
const ctx = canvas.getContext && canvas.getContext('2d');
|
|
if (!ctx) return null;
|
|
ctx.fillStyle = DOEK_COLOR;
|
|
ctx.fillRect(0, 0, WATERMARK.px, WATERMARK.px);
|
|
const tex = new THREE.CanvasTexture(canvas);
|
|
tex.wrapS = tex.wrapT = THREE.RepeatWrapping;
|
|
tex.repeat.set(1 / WATERMARK.tileM, 1 / WATERMARK.tileM);
|
|
tex.anisotropy = 8;
|
|
|
|
const img = new Image();
|
|
img.onload = () => {
|
|
// Logo-silhouet egaal grijs maken (source-in), dan 45° gedraaid midden
|
|
// in de tegel tekenen.
|
|
const pxPerM = WATERMARK.px / WATERMARK.tileM;
|
|
const w = WATERMARK.logoWidthM * pxPerM, h = w / window.TECTUM_LOGO.aspect;
|
|
const tint = document.createElement('canvas');
|
|
tint.width = Math.ceil(w); tint.height = Math.ceil(h);
|
|
const tctx = tint.getContext('2d');
|
|
tctx.drawImage(img, 0, 0, tint.width, tint.height);
|
|
tctx.globalCompositeOperation = 'source-in';
|
|
tctx.fillStyle = WATERMARK.color;
|
|
tctx.fillRect(0, 0, tint.width, tint.height);
|
|
ctx.save();
|
|
ctx.translate(WATERMARK.px / 2, WATERMARK.px / 2);
|
|
ctx.rotate(-Math.PI / 4); // oplopend van links naar rechts
|
|
ctx.drawImage(tint, -w / 2, -h / 2, w, h);
|
|
ctx.restore();
|
|
tex.needsUpdate = true;
|
|
};
|
|
img.src = window.TECTUM_LOGO.png;
|
|
doekTexture = tex;
|
|
return tex;
|
|
}
|
|
|
|
function createMaterials() {
|
|
const doekMap = getDoekTexture();
|
|
return {
|
|
woodMaterial: new THREE.MeshStandardMaterial({ color: 0xc29b62, roughness: 0.6 }),
|
|
spaanplaatMaterial: new THREE.MeshStandardMaterial({ color: 0x1e4620, roughness: 0.6, side: THREE.DoubleSide }),
|
|
doekMaterial: doekMap
|
|
? new THREE.MeshStandardMaterial({ color: 0xffffff, map: doekMap, roughness: 0.7, side: THREE.DoubleSide })
|
|
: new THREE.MeshStandardMaterial({ color: DOEK_COLOR, roughness: 0.7, side: THREE.DoubleSide }),
|
|
cementplaatMaterial: new THREE.MeshStandardMaterial({ color: 0x808285, roughness: 0.8, side: THREE.DoubleSide }),
|
|
battenMaterial: new THREE.MeshStandardMaterial({ color: 0xd9b77e, roughness: 0.7 })
|
|
};
|
|
}
|
|
|
|
// Bouwt de volledige 3D-wand (in meters, lokaal assenstelsel: X = breedte
|
|
// gecentreerd, Y = hoogte vanaf onderkant onderregel, +Z = buitenzijde/zuid)
|
|
// en geeft daarnaast de volume-boekhouding terug voor de specificaties.
|
|
// opts: { materials, buitenMateriaal, cladding, trasraam, spaanplaatVisible, buitenVisible }
|
|
// trasraam: { bottom, top } in mm (wand-coördinaten, zie trasraamFor) of null.
|
|
// skinExt: { left, right } in mm (zie cornerExt) of null.
|
|
// facade: { u0, extStart, isEnd } (zie computeBattens) of null.
|
|
function build3D(CONFIG, calcData, opts) {
|
|
const { woodMaterial, spaanplaatMaterial, doekMaterial, cementplaatMaterial, battenMaterial } = opts.materials;
|
|
const buitenMateriaal = opts.buitenMateriaal || 'vochtdoek';
|
|
const spaanplaatVisible = opts.spaanplaatVisible !== false;
|
|
const buitenVisible = opts.buitenVisible !== false;
|
|
const cladding = opts.cladding || 'horizontaal';
|
|
const trasraam = buitenMateriaal === 'vochtdoek' ? (opts.trasraam || null) : null;
|
|
const skinExt = opts.skinExt || null;
|
|
const facade = opts.facade || null;
|
|
const skinFrom = opts.skinFrom > 0 ? opts.skinFrom : 0; // buitenafwerking vanaf (mm), zie computeBattens
|
|
// spaanplaatBelow: onder skinFrom aan de buitenzijde spaanplaat (naadwand
|
|
// geheel in één unit: onder het dak van de andere unit is het een binnenwand).
|
|
const spaanplaatBelow = !!opts.spaanplaatBelow && skinFrom > 0 && buitenMateriaal === 'vochtdoek';
|
|
// Watermerk-UV's (doek) in gevel-coördinaten, zodat het patroon over
|
|
// naden/wandstukken doorloopt (UV = vormcoördinaat in m + verschuiving).
|
|
const uvShiftM = facade ? (CONFIG.wallWidth / 2 + facade.u0) * 0.001 : 0;
|
|
// Verticaal: een hoger beginnend stuk (facade.yOff, mm boven het
|
|
// loopvlak van de gevel) schuift het watermerk mee omhoog.
|
|
const uvShiftYM = facade && facade.yOff ? facade.yOff * 0.001 : 0;
|
|
const shiftUV = (geo) => {
|
|
if (!uvShiftM && !uvShiftYM) return geo;
|
|
const uv = geo.attributes.uv;
|
|
for (let k = 0; k < uv.count; k++) { uv.setX(k, uv.getX(k) + uvShiftM); uv.setY(k, uv.getY(k) + uvShiftYM); }
|
|
return geo;
|
|
};
|
|
|
|
const wallGroup3D = new THREE.Group();
|
|
// ------------------------------------------------------------
|
|
// Volume-boekhouding voor de specificaties. Puur analytisch, los van de
|
|
// driehoeksmesh-data: elke balk/dorpel/plaat-vorm wordt via de
|
|
// schoenveter-formule (shoelace) opgemeten en opgeteld, in m3.
|
|
// ------------------------------------------------------------
|
|
let woodVolumeM3 = 0;
|
|
let spaanplaatVolumeM3 = 0;
|
|
let spaanplaatAreaM2 = 0; // enkelzijdig, altijd binnenzijde/noord
|
|
let cementplaatVolumeM3 = 0;
|
|
let cementplaatAreaM2 = 0; // enkelzijdig, alleen als buitenMateriaal='cementplaat'
|
|
let doekAreaM2 = 0; // enkelzijdig, alleen als buitenMateriaal='vochtdoek'
|
|
let spaanplaatBuitenAreaM2 = 0; // alleen als buitenMateriaal='spaanplaat' (binnenwanden)
|
|
let spaanplaatBuitenVolumeM3 = 0;
|
|
let battenLengthM = 0, battenVolumeM3 = 0, battenCount = 0; // kruislat (alleen vochtdoek)
|
|
let trasraamAreaM2 = 0, trasraamVolumeM3 = 0; // cement-gebonden plaat onderaan (alleen vochtdoek)
|
|
let horizBeamCount = 0; // onderregel-segmenten + topbalk + dorpels per opening
|
|
|
|
function createExtrudedBeam(shape, depth, positionZ) {
|
|
const extrudeSettings = { steps: 1, depth: depth, bevelEnabled: false };
|
|
const geo = new THREE.ExtrudeGeometry(shape, extrudeSettings);
|
|
const mesh = new THREE.Mesh(geo, woodMaterial);
|
|
mesh.position.set(0, 0, positionZ);
|
|
mesh.castShadow = true;
|
|
|
|
woodVolumeM3 += polygonArea(shape.getPoints()) * depth;
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
const toM = 0.001;
|
|
const sWidthM = CONFIG.studWidth * toM;
|
|
const sDepthM = CONFIG.studDepth * toM;
|
|
const pThickM = CONFIG.plateThick * toM;
|
|
const pDepthM = CONFIG.plateDepth * toM;
|
|
const sThickM = CONFIG.sheathingThick * toM;
|
|
const wWidthM = CONFIG.wallWidth * toM;
|
|
const hLeftM = CONFIG.wallHeightLeft * toM;
|
|
const hRightM = CONFIG.wallHeightRight * toM;
|
|
const halfW = wWidthM / 2;
|
|
|
|
const tl = topLine(CONFIG, toM);
|
|
const startXM = -halfW;
|
|
const topYAt = tl.at;
|
|
// Onderkant bovenregel van xLeft naar xRight (incl. verstek bij de nok).
|
|
const underPts = tl.underPts;
|
|
|
|
// Openingen naar meter-coordinaten. LET OP: xMin/xMax hier zijn al naar
|
|
// wereld-coordinaten verschoven (dezelfde as als de rest van de 3D-opbouw,
|
|
// -halfW..+halfW), niet lokaal t.o.v. de linker wandrand (0..wallWidth) —
|
|
// dat onderscheid was eerder de bron van een echte bug (dorpels en de
|
|
// OSB-uitsparing op de verkeerde plek, deels buiten de plaat).
|
|
const opsM = CONFIG.openings.map(op => ({
|
|
id: op.id,
|
|
xMin: startXM + op.x * toM,
|
|
xMax: startXM + (op.x + op.w) * toM,
|
|
yMin: op.y * toM,
|
|
yMax: (op.y + op.h) * toM,
|
|
wM: op.w * toM
|
|
}));
|
|
|
|
// A. ONDERBALK WAND — alleen doorgesneden ter plaatse van openingen die
|
|
// tot de vloer reiken (deuren); vensters boven de plaat blijven gewoon
|
|
// op een doorlopende onderregel staan.
|
|
const floorCuts = opsM
|
|
.filter(op => op.yMin < pThickM)
|
|
.map(op => ({ min: op.xMin, max: op.xMax }))
|
|
.sort((a, b) => a.min - b.min);
|
|
|
|
let cursor = -halfW;
|
|
floorCuts.forEach(cut => {
|
|
if (cut.min > cursor) {
|
|
const segW = cut.min - cursor;
|
|
const geo = new THREE.BoxGeometry(segW, pThickM, pDepthM);
|
|
const mesh = new THREE.Mesh(geo, woodMaterial);
|
|
mesh.position.set(cursor + segW / 2, pThickM / 2, 0);
|
|
wallGroup3D.add(mesh);
|
|
woodVolumeM3 += segW * pThickM * pDepthM;
|
|
horizBeamCount++;
|
|
}
|
|
cursor = Math.max(cursor, cut.max);
|
|
});
|
|
if (cursor < halfW) {
|
|
const segW = halfW - cursor;
|
|
const geo = new THREE.BoxGeometry(segW, pThickM, pDepthM);
|
|
const mesh = new THREE.Mesh(geo, woodMaterial);
|
|
mesh.position.set(cursor + segW / 2, pThickM / 2, 0);
|
|
wallGroup3D.add(mesh);
|
|
woodVolumeM3 += segW * pThickM * pDepthM;
|
|
horizBeamCount++;
|
|
}
|
|
|
|
// B. TOPBALK WAND (ongewijzigd door openingen) — dit is zelf ook een
|
|
// "horizontale balk" (liggend, ook al loopt hij mee met de dakhelling).
|
|
// Met nok: twee bovenregels die in verstek op de nok samenkomen.
|
|
topPlateOutlines(tl).forEach(pts => {
|
|
wallGroup3D.add(createExtrudedBeam(new THREE.Shape(pts.map(p => new THREE.Vector2(p.x, p.y))), pDepthM, -pDepthM / 2));
|
|
horizBeamCount++;
|
|
});
|
|
|
|
// C. VERTICALE STIJLEN (vol, koning, dubbel bij deuren, kreupel): elk
|
|
// stuk van y0 tot y1, of tot onder de daklijn (y1 null), zie computeFrame.
|
|
calcData.studs.forEach(st => {
|
|
const xM = st.x * toM;
|
|
const xLeft = xM - (sWidthM / 2);
|
|
const xRight = xM + (sWidthM / 2);
|
|
const y0 = st.y0 * toM;
|
|
const pts = st.y1 === null
|
|
? [{ x: xLeft, y: y0 }, { x: xRight, y: y0 }, ...underPts(xLeft, xRight).reverse()]
|
|
: [{ x: xLeft, y: y0 }, { x: xRight, y: y0 }, { x: xRight, y: st.y1 * toM }, { x: xLeft, y: st.y1 * toM }];
|
|
wallGroup3D.add(createExtrudedBeam(new THREE.Shape(pts.map(p => new THREE.Vector2(p.x, p.y))), sDepthM, -sDepthM / 2));
|
|
});
|
|
|
|
// D. DORPELS, per opening
|
|
opsM.forEach(op => {
|
|
// Bovendorpel / linteel (horizontale balk)
|
|
const opTopShape = new THREE.Shape();
|
|
opTopShape.moveTo(op.xMin, op.yMax);
|
|
opTopShape.lineTo(op.xMax, op.yMax);
|
|
opTopShape.lineTo(op.xMax, op.yMax + sWidthM);
|
|
opTopShape.lineTo(op.xMin, op.yMax + sWidthM);
|
|
opTopShape.closePath();
|
|
wallGroup3D.add(createExtrudedBeam(opTopShape, sDepthM, -sDepthM / 2));
|
|
horizBeamCount++;
|
|
|
|
// Onderdorpel (indien zwevend, dus niet op de onderregel) — zit
|
|
// ONDER de opening (niet erin), consistent met de BOM/PDF-logica.
|
|
if (op.yMin > pThickM) {
|
|
const opBotShape = new THREE.Shape();
|
|
opBotShape.moveTo(op.xMin, op.yMin - sWidthM);
|
|
opBotShape.lineTo(op.xMax, op.yMin - sWidthM);
|
|
opBotShape.lineTo(op.xMax, op.yMin);
|
|
opBotShape.lineTo(op.xMin, op.yMin);
|
|
opBotShape.closePath();
|
|
wallGroup3D.add(createExtrudedBeam(opBotShape, sDepthM, -sDepthM / 2));
|
|
horizBeamCount++;
|
|
}
|
|
});
|
|
|
|
// (Isolatie wordt niet getekend; de spouwinhoud zit in computeSpecs.)
|
|
|
|
// E. VERTICALE PLATEN — gedeelde opbouw voor spaanplaat (binnenzijde,
|
|
// altijd) EN cement-gebonden platen (buitenzijde, als die gekozen is):
|
|
// beide zijn plaatmateriaal van precies 1m breed, elk hoog genoeg om in
|
|
// een enkel stuk te zagen (geen horizontale naden, alleen verticale).
|
|
// De platen worden vanaf een ankerzijde gelegd; de laatste (smallere)
|
|
// reststrook valt aan de andere kant.
|
|
const maxDepth = Math.max(sDepthM, pDepthM);
|
|
// Klein, bewust niet-nul luchtgaatje tussen plaat en houtwerk: voorkomt
|
|
// dat vlakken exact samenvallen (co-planar), wat anders overlap-
|
|
// artefacten/flikkering (z-fighting) geeft, met name goed zichtbaar op
|
|
// scherende hoeken zoals de schuine bovenrand.
|
|
const skinGapM = SKIN_GAP_MM * 0.001; // 0.5 mm
|
|
const seamM = 0.0005; // 0.5 mm naad tussen twee aangrenzende platen/banen
|
|
const boardWidthM = 1.0; // platen zijn altijd exact 1m breed
|
|
|
|
// Ankerzijde: gelijke hoogte -> links; linkerkant het hoogst -> rechts;
|
|
// rechterkant het hoogst -> links. (De volle platen beginnen op de
|
|
// ankerzijde, de smalle reststrook valt aan de andere kant.)
|
|
let boardAnchorSide;
|
|
if (hLeftM === hRightM) boardAnchorSide = 'left';
|
|
else if (hLeftM > hRightM) boardAnchorSide = 'right';
|
|
else boardAnchorSide = 'left';
|
|
|
|
const numFullBoards = Math.floor(wWidthM / boardWidthM);
|
|
const remainderM = wWidthM - numFullBoards * boardWidthM;
|
|
|
|
let boardBoundaries;
|
|
if (boardAnchorSide === 'left') {
|
|
boardBoundaries = [];
|
|
for (let i = 0; i <= numFullBoards; i++) boardBoundaries.push(-halfW + i * boardWidthM);
|
|
if (remainderM > 1e-9) boardBoundaries.push(halfW);
|
|
} else {
|
|
const raw = [];
|
|
for (let i = 0; i <= numFullBoards; i++) raw.push(halfW - i * boardWidthM);
|
|
if (remainderM > 1e-9) raw.push(-halfW);
|
|
boardBoundaries = raw.slice().reverse();
|
|
}
|
|
|
|
// Uitgebreide uitsparing per opening (1x stijldikte marge, zie hierboven),
|
|
// eenmalig berekend zodat elke plaat/baan er alleen zijn eigen deel van
|
|
// hoeft te knippen. Extra: de bovenkant van elke uitsparing wordt hier
|
|
// ook nog defensief tegen de lokale daklijn geklemd — bij een sterk
|
|
// hellende wand met een opening dicht bij de lage kant kan de marge
|
|
// (+sWidthM t.b.v. de bovendorpel) anders lokaal boven het dak uitkomen,
|
|
// wat dezelfde soort kapotte-uitsparing-bug zou geven als eerder opgelost.
|
|
// (Berekening zelf: sheathingHoles, gedeeld met de 2D-tekening.)
|
|
const edgeEps = 1e-6;
|
|
// Hoekdoorloop per buitenlaag, in m (zie cornerExt).
|
|
const extM = (depthMM) => { const e = cornerExt(skinExt, depthMM); return { left: e.left * toM, right: e.right * toM }; };
|
|
const holeExtents = sheathingHoles(CONFIG).map(hole => ({
|
|
hx0: hole.hx0 * toM, hx1: hole.hx1 * toM, hy0: hole.hy0 * toM, hy1: hole.hy1 * toM
|
|
}));
|
|
|
|
// side: 'front' (buitenzijde/zuid) of 'back' (binnenzijde/noord).
|
|
// range (optioneel, m): { y0, y1, zExtra } = alleen de strook daartussen
|
|
// (trasraam), zExtra verder naar buiten. ext (m): { left, right, zOut } =
|
|
// doorloop voorbij de wandranden (hoekdoorloop buitenzijde). Zonder zOut
|
|
// lopen de randplaten door (laag ligt al vóór het wandvlak); met zOut
|
|
// komt er een losse strook zOut verder naar buiten (laag in de
|
|
// beplatingsruimte, anders zouden de hoekstijlen erdoor steken).
|
|
function buildVerticalBoardSkin(material, side, visible, range, ext) {
|
|
const bounds = boardBoundaries.slice();
|
|
if (ext && !ext.zOut) { bounds[0] -= ext.left; bounds[bounds.length - 1] += ext.right; }
|
|
const yB = range ? range.y0 : 0;
|
|
const yCap = range ? range.y1 : Infinity;
|
|
const skinTopAt = (x) => Math.min(yCap, topYAt(x));
|
|
let areaM2 = 0, volumeM3 = 0;
|
|
const z = (side === 'front' ? (maxDepth / 2) + skinGapM : -(maxDepth / 2) - sThickM - skinGapM) + ((range && range.zExtra) || 0);
|
|
// Duidelijke naad tussen platen: dunne rand rond elke plaat, 50%
|
|
// donkerder dan de plaatkleur zelf (ook zichtbaar rond eventuele
|
|
// opening-uitsparingen, niet alleen tussen platen onderling).
|
|
const edgeMaterial = new THREE.LineBasicMaterial({ color: material.color.clone().multiplyScalar(0.5) });
|
|
|
|
for (let i = 0; i < bounds.length - 1; i++) {
|
|
const bx0 = bounds[i];
|
|
const bx1 = bounds[i + 1];
|
|
const isWallLeftEdge = i === 0;
|
|
const isWallRightEdge = i === bounds.length - 2;
|
|
// Alleen inspringen op interne naden; de buitenste plaatranden blijven
|
|
// gewoon vlak met de wandrand (geen naad met het kozijn/de hoekstijl).
|
|
const ex0 = bx0 + (isWallLeftEdge ? 0 : seamM / 2);
|
|
const ex1 = bx1 - (isWallRightEdge ? 0 : seamM / 2);
|
|
if (ex1 - ex0 <= edgeEps) continue;
|
|
|
|
// Plaat = strook min uitsparingen (columnMinusRects): een opening
|
|
// over een plaatnaad wordt een inkeping in de plaatrand, zodat er
|
|
// geen reepje plaat (met randlijnen) door de opening blijft lopen.
|
|
const pieces = columnMinusRects(ex0, ex1, yB, skinTopAt,
|
|
holeExtents.map(h => ({ x0: h.hx0, x1: h.hx1, y0: h.hy0, y1: h.hy1 })),
|
|
{ yCap: range ? yCap : undefined, extraXs: range ? tl.kinks.concat(tl.crossings(yCap)) : tl.kinks });
|
|
let boardShapes;
|
|
if (pieces) {
|
|
boardShapes = pieces.map(piece => {
|
|
const shape = new THREE.Shape(piece.outer.map(p => new THREE.Vector2(p.x, p.y)));
|
|
piece.holes.forEach(hole => shape.holes.push(new THREE.Path(hole.map(p => new THREE.Vector2(p.x, p.y)))));
|
|
return shape;
|
|
});
|
|
} else {
|
|
// Terugval (uitsparing tot in de schuine bovenrand): oude
|
|
// gat-methode, net binnen de plaatrand afgekapt.
|
|
const boardShape = new THREE.Shape();
|
|
boardShape.moveTo(ex0, yB);
|
|
boardShape.lineTo(ex1, yB);
|
|
boardShape.lineTo(ex1, skinTopAt(ex1));
|
|
tl.kinks.filter(x => x > ex0 && x < ex1).forEach(x => boardShape.lineTo(x, skinTopAt(x)));
|
|
boardShape.lineTo(ex0, skinTopAt(ex0));
|
|
boardShape.closePath();
|
|
holeExtents.forEach(h => {
|
|
const chx0 = Math.max(ex0 + edgeEps, h.hx0);
|
|
const chx1 = Math.min(ex1 - edgeEps, h.hx1);
|
|
if (chx1 > chx0) {
|
|
const holePath = new THREE.Path();
|
|
const chy0 = Math.max(yB + edgeEps, h.hy0), chy1 = Math.min(yCap - edgeEps, h.hy1);
|
|
if (chy1 <= chy0) return;
|
|
holePath.moveTo(chx0, chy0);
|
|
holePath.lineTo(chx0, chy1);
|
|
holePath.lineTo(chx1, chy1);
|
|
holePath.lineTo(chx1, chy0);
|
|
holePath.closePath();
|
|
boardShape.holes.push(holePath);
|
|
}
|
|
});
|
|
boardShapes = [boardShape];
|
|
}
|
|
if (!boardShapes.length) continue;
|
|
|
|
const boardExtrudeSettings = { steps: 1, depth: sThickM, bevelEnabled: false };
|
|
const boardGeo = new THREE.ExtrudeGeometry(boardShapes, boardExtrudeSettings);
|
|
const boardAreaM2 = boardShapes.reduce((sum, shape) => sum + shapeAreaWithHoles(shape), 0);
|
|
|
|
const board = new THREE.Mesh(boardGeo, material);
|
|
board.position.set(0, 0, z);
|
|
board.visible = visible;
|
|
wallGroup3D.add(board);
|
|
|
|
const edgesGeo = new THREE.EdgesGeometry(boardGeo);
|
|
const edgeLines = new THREE.LineSegments(edgesGeo, edgeMaterial);
|
|
edgeLines.position.set(0, 0, z);
|
|
edgeLines.visible = visible;
|
|
wallGroup3D.add(edgeLines);
|
|
|
|
areaM2 += boardAreaM2;
|
|
volumeM3 += boardAreaM2 * sThickM;
|
|
}
|
|
if (ext && ext.zOut) {
|
|
[[-halfW - ext.left, -halfW], [halfW, halfW + ext.right]].forEach(([a, b]) => {
|
|
if (b - a <= edgeEps || Math.min(skinTopAt(a), skinTopAt(b)) <= yB + edgeEps) return;
|
|
const shape = new THREE.Shape([
|
|
new THREE.Vector2(a, yB), new THREE.Vector2(b, yB), new THREE.Vector2(b, skinTopAt(b)), new THREE.Vector2(a, skinTopAt(a))
|
|
]);
|
|
const geo = new THREE.ExtrudeGeometry(shape, { steps: 1, depth: sThickM, bevelEnabled: false });
|
|
const mesh = new THREE.Mesh(geo, material);
|
|
mesh.position.set(0, 0, z + ext.zOut);
|
|
mesh.visible = visible;
|
|
wallGroup3D.add(mesh);
|
|
const edgeLines = new THREE.LineSegments(new THREE.EdgesGeometry(geo), edgeMaterial);
|
|
edgeLines.position.set(0, 0, z + ext.zOut);
|
|
edgeLines.visible = visible;
|
|
wallGroup3D.add(edgeLines);
|
|
const a2 = shapeAreaWithHoles(shape);
|
|
areaM2 += a2;
|
|
volumeM3 += a2 * sThickM;
|
|
});
|
|
}
|
|
return { areaM2, volumeM3 };
|
|
}
|
|
|
|
// Binnenzijde (noord): altijd spaanplaat.
|
|
const spaanplaatResult = buildVerticalBoardSkin(spaanplaatMaterial, 'back', spaanplaatVisible);
|
|
spaanplaatAreaM2 = spaanplaatResult.areaM2;
|
|
spaanplaatVolumeM3 = spaanplaatResult.volumeM3;
|
|
|
|
// Buitenzijde (zuid): cement-gebonden platen (zelfde plaatlogica als
|
|
// hierboven) OF vochtdoek (horizontale banen, zie onder) — nooit beide.
|
|
if (spaanplaatBelow) {
|
|
const spaanOnder = buildVerticalBoardSkin(spaanplaatMaterial, 'front', buitenVisible, { y0: 0, y1: skinFrom * 0.001 });
|
|
spaanplaatBuitenAreaM2 = spaanOnder.areaM2;
|
|
spaanplaatBuitenVolumeM3 = spaanOnder.volumeM3;
|
|
}
|
|
if (buitenMateriaal === 'spaanplaat') {
|
|
// Binnenwand: aan beide zijden spaanplaat.
|
|
const spaanBuiten = buildVerticalBoardSkin(spaanplaatMaterial, 'front', buitenVisible);
|
|
spaanplaatBuitenAreaM2 = spaanBuiten.areaM2;
|
|
spaanplaatBuitenVolumeM3 = spaanBuiten.volumeM3;
|
|
} else if (buitenMateriaal === 'geen') {
|
|
// Naadzijde: geen beplating (het deel van de andere unit staat ertegen).
|
|
} else if (buitenMateriaal === 'cementplaat') {
|
|
const cementResult = buildVerticalBoardSkin(cementplaatMaterial, 'front', buitenVisible, null,
|
|
Object.assign(extM(0), { zOut: sThickM + 2 * skinGapM }));
|
|
cementplaatAreaM2 = cementResult.areaM2;
|
|
cementplaatVolumeM3 = cementResult.volumeM3;
|
|
} else {
|
|
// F. VOCHTDOEK BUITENZIJDE (zuid) — horizontale banen van 1500mm
|
|
// (rolbreedte), "oneindig" strekkend in de breedte (dus geen
|
|
// verticale naden nodig binnen één baan). Begint onderaan
|
|
// (vloerhoogte); de bovenste baan wordt afgeknipt op de schuine
|
|
// daklijn. Elke baan overlapt de vorige met 5cm.
|
|
const doekHeightM = 1.5;
|
|
const doekOverlapM = 0.05;
|
|
const doekStepM = doekHeightM - doekOverlapM;
|
|
// Kleine Z-stap per baan: zorgt dat een hogere baan (die de vorige met
|
|
// 5cm overlapt) in de overlapzone net iets vóór de onderliggende baan
|
|
// ligt — zoals bij een echte shingle-overlap — i.p.v. exact co-planair
|
|
// (wat flikkering/z-fighting zou geven nu de platen niet meer
|
|
// transparant zijn).
|
|
const doekZStepM = 0.0002; // 0.2 mm per baan, verwaarloosbaar t.o.v. de spouwdiepte
|
|
const wallOutlinePts = [{ x: -halfW, y: 0 }, { x: halfW, y: 0 }, ...tl.pts.slice().reverse()];
|
|
const maxRoofY = tl.maxY;
|
|
|
|
let rowY0 = skinFrom * toM;
|
|
let rowIndex = 0;
|
|
while (rowY0 < maxRoofY - 1e-9) {
|
|
const rowY1 = rowY0 + doekHeightM;
|
|
|
|
// Baan = strook [rowY0, min(rowY1, daklijn)] min uitsparingen
|
|
// (columnMinusRects, zelfde als de platen): een opening over de
|
|
// baanrand wordt een inkeping, geen reepje doek door de opening.
|
|
const roofAt = topYAt;
|
|
const [rx0, rx1] = tl.rangeAbove(rowY0) || [0, 0];
|
|
const extraXs = tl.crossings(rowY1).concat(tl.kinks);
|
|
const pieces = rx1 - rx0 > edgeEps ? columnMinusRects(rx0, rx1, rowY0, (x) => Math.min(rowY1, roofAt(x)),
|
|
holeExtents.map(h => ({ x0: h.hx0, x1: h.hx1, y0: h.hy0, y1: h.hy1 })), { yCap: rowY1, extraXs }) : [];
|
|
|
|
let rowShapes;
|
|
if (pieces) {
|
|
rowShapes = pieces.map(piece => {
|
|
const shape = new THREE.Shape(piece.outer.map(p => new THREE.Vector2(p.x, p.y)));
|
|
piece.holes.forEach(hole => shape.holes.push(new THREE.Path(hole.map(p => new THREE.Vector2(p.x, p.y)))));
|
|
return shape;
|
|
});
|
|
} else {
|
|
// Terugval (uitsparing tot in de schuine bovenrand): oude methode.
|
|
let rowPts = clipPolygonYLE(wallOutlinePts, rowY1);
|
|
rowPts = clipPolygonYGE(rowPts, rowY0);
|
|
rowShapes = [];
|
|
if (rowPts.length >= 3) {
|
|
const rowShape = new THREE.Shape();
|
|
rowShape.moveTo(rowPts[0].x, rowPts[0].y);
|
|
for (let k = 1; k < rowPts.length; k++) rowShape.lineTo(rowPts[k].x, rowPts[k].y);
|
|
rowShape.closePath();
|
|
holeExtents.forEach(h => {
|
|
const chy0 = Math.max(rowY0 + edgeEps, h.hy0);
|
|
const chy1 = Math.min(rowY1 - edgeEps, h.hy1);
|
|
if (chy1 > chy0) {
|
|
const holePath = new THREE.Path();
|
|
holePath.moveTo(h.hx0, chy0);
|
|
holePath.lineTo(h.hx0, chy1);
|
|
holePath.lineTo(h.hx1, chy1);
|
|
holePath.lineTo(h.hx1, chy0);
|
|
holePath.closePath();
|
|
rowShape.holes.push(holePath);
|
|
}
|
|
});
|
|
rowShapes.push(rowShape);
|
|
}
|
|
}
|
|
if (rowShapes.length) {
|
|
const rowExtrudeSettings = { steps: 1, depth: sThickM, bevelEnabled: false };
|
|
const rowGeo = shiftUV(new THREE.ExtrudeGeometry(rowShapes, rowExtrudeSettings));
|
|
const rowAreaM2 = rowShapes.reduce((sum, shape) => sum + shapeAreaWithHoles(shape), 0);
|
|
|
|
const doekRow = new THREE.Mesh(rowGeo, doekMaterial);
|
|
doekRow.position.set(0, 0, (maxDepth / 2) + skinGapM + rowIndex * doekZStepM);
|
|
doekRow.visible = buitenVisible;
|
|
wallGroup3D.add(doekRow);
|
|
|
|
// Elke baan telt met zijn volle oppervlak mee (incl. de overlapzone
|
|
// met de vorige baan) — dat is fysiek correct voor een materiaal-
|
|
// hoeveelheid: de overlap wordt ook echt van de rol verbruikt.
|
|
doekAreaM2 += rowAreaM2;
|
|
}
|
|
// Hoekdoorloop: strook over de kopse kant van de doorlopende wand,
|
|
// net vóór het wandvlak (het doek zelf ligt in de beplatingsruimte).
|
|
const dExt = extM(0);
|
|
// Dun (1 mm, membraan); het latwerk ligt eroverheen.
|
|
const zOut = (maxDepth / 2) + skinGapM + sThickM + skinGapM + rowIndex * doekZStepM;
|
|
const stripM = 0.001;
|
|
[[-halfW - dExt.left, -halfW], [halfW, halfW + dExt.right]].forEach(([a, b]) => {
|
|
if (b - a <= edgeEps || Math.min(roofAt(a), roofAt(b)) <= rowY0 + edgeEps) return;
|
|
const pts = [{ x: a, y: rowY0 }, { x: b, y: rowY0 }, { x: b, y: Math.min(rowY1, roofAt(b)) }, { x: a, y: Math.min(rowY1, roofAt(a)) }];
|
|
const shape = new THREE.Shape(pts.map(p => new THREE.Vector2(p.x, p.y)));
|
|
const mesh = new THREE.Mesh(shiftUV(new THREE.ExtrudeGeometry(shape, { steps: 1, depth: stripM, bevelEnabled: false })), doekMaterial);
|
|
mesh.position.set(0, 0, zOut);
|
|
mesh.visible = buitenVisible;
|
|
wallGroup3D.add(mesh);
|
|
doekAreaM2 += shapeAreaWithHoles(shape);
|
|
});
|
|
rowY0 += doekStepM;
|
|
rowIndex++;
|
|
}
|
|
|
|
// H. TRASRAAM: onderaan cement-gebonden plaat (zelfde plaatlogica en
|
|
// uitsparingen als de buitenplaten), vóór het doek
|
|
// (zelfde vlak als de latten). Het doek loopt
|
|
// er ongewijzigd achter door; het latwerk begint erboven.
|
|
if (trasraam) {
|
|
const tras = buildVerticalBoardSkin(cementplaatMaterial, 'front', buitenVisible, {
|
|
y0: trasraam.bottom * toM, y1: trasraam.top * toM, zExtra: sThickM + (rowIndex + 1) * doekZStepM + skinGapM
|
|
}, extM(CONFIG.sheathingThick + 2 * SKIN_GAP_MM));
|
|
trasraamAreaM2 = tras.areaM2;
|
|
trasraamVolumeM3 = tras.volumeM3;
|
|
}
|
|
|
|
// G. KRUISLAT op het vochtdoek (computeBattens): onderste laag direct op
|
|
// het doek, bovenste laag (haaks op de gevelbekleding) daaroverheen.
|
|
const bat = computeBattens(CONFIG, cladding, trasraam, skinExt, facade, skinFrom);
|
|
const bT = BATTEN.thick * toM, bW = BATTEN.width * toM;
|
|
const zDoek = (maxDepth / 2) + skinGapM + sThickM + rowIndex * doekZStepM + skinGapM;
|
|
const addLayer = (orientation, z) => {
|
|
bat.layers[orientation].forEach(b => {
|
|
const horiz = orientation === 'horizontaal';
|
|
const len = horiz ? (b.x1 - b.x0) * toM : (b.y1 - b.y0) * toM;
|
|
const mesh = new THREE.Mesh(new THREE.BoxGeometry(horiz ? len : bW, horiz ? bW : len, bT), battenMaterial);
|
|
mesh.position.set(horiz ? (b.x0 + b.x1) / 2 * toM : b.x * toM, horiz ? b.y * toM : (b.y0 + b.y1) / 2 * toM, z + bT / 2);
|
|
mesh.visible = buitenVisible;
|
|
wallGroup3D.add(mesh);
|
|
});
|
|
};
|
|
addLayer(bat.under, zDoek);
|
|
addLayer(bat.top, zDoek + bT);
|
|
battenLengthM = bat.totalLengthMM * toM;
|
|
battenVolumeM3 = battenLengthM * bT * bW;
|
|
battenCount = bat.stock.count;
|
|
}
|
|
|
|
return {
|
|
group: wallGroup3D,
|
|
stats: {
|
|
woodVolumeM3, spaanplaatVolumeM3, spaanplaatAreaM2, cementplaatVolumeM3, cementplaatAreaM2, doekAreaM2,
|
|
spaanplaatBuitenAreaM2, spaanplaatBuitenVolumeM3, horizBeamCount,
|
|
battenLengthM, battenVolumeM3, battenCount, trasraamAreaM2, trasraamVolumeM3
|
|
}
|
|
};
|
|
}
|
|
|
|
// Specificaties (volumes -> gewichten), op basis van de stats uit build3D.
|
|
function computeSpecs(CONFIG, stats, buitenMateriaal) {
|
|
const toM = 0.001;
|
|
const wWidthM = CONFIG.wallWidth * toM;
|
|
const hLeftM = CONFIG.wallHeightLeft * toM;
|
|
const hRightM = CONFIG.wallHeightRight * toM;
|
|
const sDepthM = CONFIG.studDepth * toM;
|
|
const halfW = wWidthM / 2;
|
|
|
|
// Omhullende van de wand (trapezium, incl. schuine top) als referentie
|
|
// voor de leegte-berekening — spouwdiepte wordt gelijkgesteld aan de
|
|
// stijldiepte (vereenvoudiging, zie toelichting in de UI).
|
|
const envelopePoints = [{ x: -halfW, y: 0 }, { x: halfW, y: 0 }, ...topLine(CONFIG, toM).pts.slice().reverse()];
|
|
const envelopeAreaM2 = polygonArea(envelopePoints);
|
|
const envelopeVolumeM3 = envelopeAreaM2 * sDepthM;
|
|
|
|
const openingsVolumeM3 = CONFIG.openings.reduce((sum, op) => {
|
|
return sum + (op.w * toM) * (op.h * toM) * sDepthM;
|
|
}, 0);
|
|
|
|
let voidVolumeM3 = envelopeVolumeM3 - stats.woodVolumeM3 - openingsVolumeM3;
|
|
if (voidVolumeM3 < 0) voidVolumeM3 = 0;
|
|
|
|
const woodKg = stats.woodVolumeM3 * DENSITY_WOOD_KGM3;
|
|
const spaanplaatKg = stats.spaanplaatVolumeM3 * DENSITY_SPAANPLAAT_KGM3;
|
|
|
|
let buitenAreaM2, buitenKg, buitenVolumeM3;
|
|
if (buitenMateriaal === 'spaanplaat') {
|
|
buitenAreaM2 = stats.spaanplaatBuitenAreaM2;
|
|
buitenKg = stats.spaanplaatBuitenVolumeM3 * DENSITY_SPAANPLAAT_KGM3;
|
|
buitenVolumeM3 = stats.spaanplaatBuitenVolumeM3;
|
|
} else if (buitenMateriaal === 'geen') {
|
|
buitenAreaM2 = 0; buitenKg = 0; buitenVolumeM3 = 0;
|
|
} else if (buitenMateriaal === 'cementplaat') {
|
|
buitenAreaM2 = stats.cementplaatAreaM2;
|
|
buitenKg = stats.cementplaatVolumeM3 * DENSITY_CEMENTPLAAT_KGM3;
|
|
buitenVolumeM3 = stats.cementplaatVolumeM3;
|
|
} else {
|
|
// Vochtdoek wordt per m2 gewogen (rol/dun membraan), niet per m3.
|
|
buitenAreaM2 = stats.doekAreaM2;
|
|
buitenKg = stats.doekAreaM2 * DENSITY_DOEK_KGM2;
|
|
buitenVolumeM3 = null; // n.v.t. (rolmateriaal)
|
|
}
|
|
|
|
const battenKg = (stats.battenVolumeM3 || 0) * DENSITY_WOOD_KGM3;
|
|
const trasraamKg = (stats.trasraamVolumeM3 || 0) * DENSITY_CEMENTPLAAT_KGM3;
|
|
const totalKg = woodKg + spaanplaatKg + buitenKg + battenKg + trasraamKg;
|
|
return { woodKg, spaanplaatKg, buitenAreaM2, buitenKg, buitenVolumeM3, voidVolumeM3, battenKg, trasraamKg, totalKg };
|
|
}
|
|
|
|
// Materiaallijst (BOM): elk los stuk hout met zijn maat, soort en
|
|
// positie (voor de PDF-tekening en de unit-totalen).
|
|
function computeBOM(CONFIG, calcData) {
|
|
const wallWidth = CONFIG.wallWidth, hLeft = CONFIG.wallHeightLeft, hRight = CONFIG.wallHeightRight;
|
|
const halfW = wallWidth / 2;
|
|
const tl = topLine(CONFIG);
|
|
const startX = -halfW;
|
|
|
|
const pieces = [];
|
|
|
|
const opsWorld = CONFIG.openings.map(op => ({ xMin: startX + op.x, xMax: startX + op.x + op.w, yMin: op.y }));
|
|
const floorCuts = opsWorld.filter(o => o.yMin < CONFIG.plateThick)
|
|
.map(o => ({ min: o.xMin, max: o.xMax })).sort((a, b) => a.min - b.min);
|
|
let cursor = -halfW;
|
|
floorCuts.forEach(cut => {
|
|
if (cut.min > cursor) {
|
|
pieces.push({ length: cut.min - cursor, width: CONFIG.plateThick, depth: CONFIG.plateDepth, kind: 'onderregel', x: (cursor + cut.min) / 2, y: CONFIG.plateThick / 2 });
|
|
}
|
|
cursor = Math.max(cursor, cut.max);
|
|
});
|
|
if (cursor < halfW) {
|
|
pieces.push({ length: halfW - cursor, width: CONFIG.plateThick, depth: CONFIG.plateDepth, kind: 'onderregel', x: (cursor + halfW) / 2, y: CONFIG.plateThick / 2 });
|
|
}
|
|
|
|
// Bovenregel(s): met nok twee stukken (verstek). outline = werkelijke
|
|
// omtrek (PDF-tekening).
|
|
topPlateOutlines(tl).forEach((outline, i) => {
|
|
const sg = tl.segs[i];
|
|
pieces.push({
|
|
length: Math.hypot(sg.b.x - sg.a.x, sg.b.y - sg.a.y), width: CONFIG.plateThick, depth: CONFIG.plateDepth, kind: 'bovenregel',
|
|
x: (sg.a.x + sg.b.x) / 2, y: (sg.a.y + sg.b.y) / 2 - CONFIG.plateThick / 2, outline
|
|
});
|
|
});
|
|
|
|
// Verticale stukken krijgen, naast de bounding-box velden (length/y —
|
|
// gebruikt voor de materiaallijst: de lengte van het rechte stuk hout
|
|
// waar de schuine kop uit gezaagd wordt), ook hun 4 werkelijke
|
|
// hoekpunten (yBottomLeft/Right, yTopLeft/Right). De PDF-tekening
|
|
// gebruikt die hoekpunten om het stuk als schuin viervlak te tekenen
|
|
// i.p.v. als platte rechthoek tot het hoogste punt — anders komt alleen
|
|
// de hoogste kant van de balk goed op de daklijn te staan, en blijft de
|
|
// laagste kant er (visueel) los van.
|
|
// (outline: ook de knik onder de nok, als de stijl daar staat.)
|
|
calcData.studs.forEach(st => {
|
|
const x = st.x, xLeft = x - CONFIG.studWidth / 2, xRight = x + CONFIG.studWidth / 2;
|
|
const yBottom = st.y0;
|
|
const kind = st.kind === 'kreupel' ? 'kreupele stijl' : 'verticale balk';
|
|
if (st.y1 !== null) {
|
|
pieces.push({
|
|
length: st.y1 - yBottom, width: CONFIG.studWidth, depth: CONFIG.studDepth, kind, x,
|
|
y: (yBottom + st.y1) / 2,
|
|
yBottomLeft: yBottom, yBottomRight: yBottom, yTopLeft: st.y1, yTopRight: st.y1
|
|
});
|
|
return;
|
|
}
|
|
const topPts = tl.underPts(xLeft, xRight);
|
|
const yTopLeft = topPts[0].y, yTopRight = topPts[topPts.length - 1].y;
|
|
pieces.push({
|
|
length: Math.max(...topPts.map(p => p.y)) - yBottom, width: CONFIG.studWidth, depth: CONFIG.studDepth, kind, x,
|
|
y: (yBottom + yBottom + yTopLeft + yTopRight) / 4,
|
|
yBottomLeft: yBottom, yBottomRight: yBottom, yTopLeft, yTopRight,
|
|
outline: [{ x: xLeft, y: yBottom }, { x: xRight, y: yBottom }, ...topPts.slice().reverse()]
|
|
});
|
|
});
|
|
|
|
CONFIG.openings.forEach(op => {
|
|
const opXWorld = startX + op.x;
|
|
pieces.push({ length: op.w, width: CONFIG.studWidth, depth: CONFIG.studDepth, kind: 'bovendorpel', x: opXWorld + op.w / 2, y: op.y + op.h + CONFIG.studWidth / 2 });
|
|
if (op.y > CONFIG.plateThick) {
|
|
pieces.push({ length: op.w, width: CONFIG.studWidth, depth: CONFIG.studDepth, kind: 'onderdorpel', x: opXWorld + op.w / 2, y: op.y - CONFIG.studWidth / 2 });
|
|
}
|
|
});
|
|
|
|
return pieces;
|
|
}
|
|
|
|
function groupBOM(pieces) {
|
|
const map = new Map();
|
|
pieces.forEach(p => {
|
|
const length = Math.round(p.length);
|
|
const key = `${p.width}|${p.depth}|${length}`;
|
|
if (!map.has(key)) map.set(key, { width: p.width, depth: p.depth, length, count: 0 });
|
|
map.get(key).count++;
|
|
});
|
|
const groups = Array.from(map.values());
|
|
groups.sort((a, b) => b.length - a.length);
|
|
groups.forEach((g, i) => { g.posnum = i + 1; });
|
|
const keyToPosnum = new Map();
|
|
groups.forEach(g => keyToPosnum.set(`${g.width}|${g.depth}|${g.length}`, g.posnum));
|
|
pieces.forEach(p => { p.posnum = keyToPosnum.get(`${p.width}|${p.depth}|${Math.round(p.length)}`); });
|
|
return groups;
|
|
}
|
|
|
|
// Inkoop/zaagplan per balkdoorsnede (dikte x diepte) over de gegeven
|
|
// BOM-stukken — ook over meerdere wanden tegelijk (unit), zodat
|
|
// reststukken van de ene wand in de andere gebruikt kunnen worden.
|
|
function planPurchase(pieces) {
|
|
const bySection = new Map();
|
|
pieces.forEach(p => {
|
|
const key = `${p.width}x${p.depth}`;
|
|
if (!bySection.has(key)) bySection.set(key, { width: p.width, depth: p.depth, lengths: [] });
|
|
bySection.get(key).lengths.push(p.length);
|
|
});
|
|
return Array.from(bySection.values()).map(sec => {
|
|
const bars = planStockCutting(sec.lengths, STOCK_LENGTHS_MM);
|
|
return { width: sec.width, depth: sec.depth, bars, ...summarizeStockPlan(bars) };
|
|
});
|
|
}
|
|
|
|
// Korte tekst, bijv. "38x235: 2x 3600, 5x 4800".
|
|
function purchaseText(plan) {
|
|
return plan.map(sec => `${sec.width}x${sec.depth}: ` +
|
|
sec.perStock.map(s => `${s.count}x ${s.stock}`).join(', ')).join(' | ') || '-';
|
|
}
|
|
|
|
// Structuurcontrole van een wand-state (bijv. bij JSON-import). Gooit een
|
|
// Error met een leesbare melding als er iets ontbreekt/ongeldig is.
|
|
function validateState(design) {
|
|
if (!design.wall || typeof design.wall !== 'object') throw new Error('veld "wall" ontbreekt');
|
|
const requiredWallFields = ['width', 'heightAll', 'heightLeft', 'heightRight', 'studWidth', 'studDepth',
|
|
'plateThick', 'plateDepth', 'sheathingThick', 'minSpacing', 'maxSpacing'];
|
|
requiredWallFields.forEach(f => {
|
|
if (typeof design.wall[f] !== 'number' || !isFinite(design.wall[f])) {
|
|
throw new Error(`wall.${f} ontbreekt of is geen geldig getal`);
|
|
}
|
|
});
|
|
// materials is optioneel bij import (oudere bestanden hebben dit veld
|
|
// niet), maar als het aanwezig is moet de waarde wel geldig zijn.
|
|
if (design.materials !== undefined) {
|
|
if (typeof design.materials !== 'object' || design.materials === null) {
|
|
throw new Error('veld "materials" is aanwezig maar geen object');
|
|
}
|
|
if (design.materials.exterior !== undefined &&
|
|
!EXTERIOR_MATERIALS[design.materials.exterior]) {
|
|
throw new Error(`materials.exterior moet ${Object.keys(EXTERIOR_MATERIALS).join('/')} zijn (was: ${design.materials.exterior})`);
|
|
}
|
|
if (design.materials.cladding !== undefined && !CLADDING_DIRECTIONS[design.materials.cladding]) {
|
|
throw new Error(`materials.cladding moet ${Object.keys(CLADDING_DIRECTIONS).join('/')} zijn (was: ${design.materials.cladding})`);
|
|
}
|
|
}
|
|
if (!Array.isArray(design.openings)) throw new Error('veld "openings" ontbreekt of is geen lijst');
|
|
design.openings.forEach((o, i) => {
|
|
if (typeof o.w !== 'number' || typeof o.h !== 'number' || typeof o.y !== 'number' || typeof o.offset !== 'number') {
|
|
throw new Error(`opening #${i + 1}: w/h/y/offset moeten getallen zijn`);
|
|
}
|
|
if (o.type !== undefined && !OPENING_TYPES[o.type]) {
|
|
throw new Error(`opening #${i + 1}: type moet ${Object.keys(OPENING_TYPES).join('/')} zijn (was: ${o.type})`);
|
|
}
|
|
if (!['left', 'middle', 'right'].includes(o.anchor)) {
|
|
throw new Error(`opening #${i + 1}: anchor moet 'left', 'middle' of 'right' zijn (was: ${o.anchor})`);
|
|
}
|
|
});
|
|
}
|
|
|
|
return {
|
|
STANDARD_BEAM, STOCK_LENGTHS_MM, CORNER_STUDS, EXTERIOR_MATERIALS, OPENING_TYPES, BATTEN, CLADDING_DIRECTIONS, CLADDING_THICK_MM, claddingOffset, cornerExt, TRASRAAM_DEFAULT_MM, trasraamFor, skinStartY, computeBattens, planPurchase, purchaseText,
|
|
sheathingHoles, skinSegmentsAtY, topLine, topPlateOutlines,
|
|
validateState, resolveOpenings, computeBOM, groupBOM, buildConfig, configFromState, thicknessOf, computeFrame,
|
|
createMaterials, build3D, computeSpecs
|
|
};
|
|
})();
|