402 lines
20 KiB
JavaScript
402 lines
20 KiB
JavaScript
/*!
|
|
* Tectum
|
|
* Copyright © 2026 Machiel Heinen.
|
|
* Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
|
|
* Zie LICENTIE.md.
|
|
*/
|
|
// Kunststof kozijnen naar de Aluplast Ideal 7000 (examples/Buiten kozijnen.pdf).
|
|
// links/rechts (leaf, hinge, dir) zijn van buitenaf gezien = vanaf +z.
|
|
// userData.door: open/target in radialen (draaien) of meters (schuiven); de loopmodus (house.js) zet target.
|
|
|
|
window.KozijnModel = (() => {
|
|
const COLORS = {
|
|
wit: { label: 'Wit', ral: 'RAL 9016', hex: 0xf1f0ea },
|
|
grijs: { label: 'Grijs', ral: 'RAL 7038', hex: 0xaeb0aa },
|
|
antraciet: { label: 'Antraciet', ral: 'RAL 7016', hex: 0x383e42 },
|
|
zwart: { label: 'Zwart', ral: 'RAL 9005', hex: 0x151515 }
|
|
};
|
|
const FILL_TYPES = { geen: 'Geen (open)', raam: 'Raam (vast glas)', deur: 'Deur', schuifdeur: 'Schuifdeur' };
|
|
const HINGES = { links: 'Links', rechts: 'Rechts' };
|
|
const SWINGS = { binnen: 'Naar binnen', buiten: 'Naar buiten' };
|
|
const SLIDE_MOUNTS = { inbouw: 'In de wand', opbouw: 'Op de wand (rail)' };
|
|
const SLIDE_SIDES = { binnen: 'Binnenzijde', buiten: 'Buitenzijde' };
|
|
const SLIDE_DIRS = { links: 'Naar links', rechts: 'Naar rechts' };
|
|
const DEFAULT_OUT = 'antraciet', DEFAULT_IN = 'wit';
|
|
|
|
const P = {
|
|
gap: 5,
|
|
kader: 70,
|
|
depth: 120,
|
|
dorpel: 30,
|
|
tussen: 70, // tussenstijl/-regel (deur naast zijlicht, onder bovenlicht)
|
|
rooster: 80,
|
|
glass: 24,
|
|
leafW: 930, // deurblad (binnenmaat kader) als er een zijlicht naast past
|
|
leafH: 2200, // deurblad als er een bovenlicht boven past
|
|
leafT: 68,
|
|
minLight: 200
|
|
};
|
|
|
|
const colorKey = (k, def) => COLORS[k] ? k : def;
|
|
const pick = (v, opts, def) => opts[v] ? v : def;
|
|
function normalize(fill) {
|
|
if (!fill || !FILL_TYPES[fill.type] || fill.type === 'geen') return null;
|
|
const f = {
|
|
type: fill.type, rooster: !!fill.rooster, glas: fill.glas !== false,
|
|
out: colorKey(fill.out, DEFAULT_OUT), in: colorKey(fill.in, DEFAULT_IN)
|
|
};
|
|
if (f.type === 'deur') {
|
|
f.hinge = pick(fill.hinge, HINGES, 'links');
|
|
f.leaf = pick(fill.leaf, HINGES, f.hinge);
|
|
f.swing = pick(fill.swing, SWINGS, 'binnen');
|
|
f.volglas = !!fill.volglas;
|
|
}
|
|
if (f.type === 'schuifdeur') Object.assign(f, {
|
|
leaves: Number(fill.leaves) === 2 ? 2 : 1, mount: pick(fill.mount, SLIDE_MOUNTS, 'inbouw'),
|
|
side: pick(fill.side, SLIDE_SIDES, 'binnen'), dir: pick(fill.dir, SLIDE_DIRS, 'links')
|
|
});
|
|
return f;
|
|
}
|
|
function defaultFill(openingType, like) {
|
|
const l = normalize(like) || {};
|
|
const type = openingType === 'deur' || openingType === 'voordeur' ? 'deur' : 'raam';
|
|
return { type, rooster: false, glas: openingType === 'voordeur', out: l.out || DEFAULT_OUT, in: l.in || DEFAULT_IN };
|
|
}
|
|
|
|
function insetPoly(pts, d) {
|
|
const n = pts.length;
|
|
const lines = pts.map((p, i) => {
|
|
const q = pts[(i + 1) % n];
|
|
const len = Math.hypot(q.x - p.x, q.y - p.y) || 1;
|
|
const dx = (q.x - p.x) / len, dy = (q.y - p.y) / len;
|
|
return { x: p.x - dy * d[i], y: p.y + dx * d[i], dx, dy };
|
|
});
|
|
return pts.map((p, i) => {
|
|
const a = lines[(i - 1 + n) % n], b = lines[i];
|
|
const den = a.dx * b.dy - a.dy * b.dx;
|
|
if (Math.abs(den) < 1e-9) return { x: b.x, y: b.y };
|
|
const t = ((b.x - a.x) * b.dy - (b.y - a.y) * b.dx) / den;
|
|
return { x: a.x + a.dx * t, y: a.y + a.dy * t };
|
|
});
|
|
}
|
|
function clipPoly(pts, f) {
|
|
const out = [];
|
|
pts.forEach((p, i) => {
|
|
const q = pts[(i + 1) % pts.length];
|
|
const fp = f(p), fq = f(q);
|
|
if (fp >= 0) out.push(p);
|
|
if ((fp >= 0) !== (fq >= 0)) {
|
|
const t = fp / (fp - fq);
|
|
out.push({ x: p.x + (q.x - p.x) * t, y: p.y + (q.y - p.y) * t });
|
|
}
|
|
});
|
|
return out;
|
|
}
|
|
// >= 0 onder de bovenrand q[3]-q[2] van een vierhoek.
|
|
const below = (q) => (p) => {
|
|
const a = q[3], b = q[2];
|
|
return (b.y - a.y) * (p.x - a.x) - (b.x - a.x) * (p.y - a.y);
|
|
};
|
|
const rect = (x0, x1, y0, y1) => [{ x: x0, y: y0 }, { x: x1, y: y0 }, { x: x1, y: y1 }, { x: x0, y: y1 }];
|
|
const areaOf = (pts) => Math.abs(pts.reduce((a, p, i) => { const q = pts[(i + 1) % pts.length]; return a + p.x * q.y - q.x * p.y; }, 0)) / 2;
|
|
|
|
const mats = {};
|
|
function colorMat(key) {
|
|
const k = 'c:' + colorKey(key, DEFAULT_OUT);
|
|
return mats[k] || (mats[k] = new THREE.MeshStandardMaterial({ color: COLORS[colorKey(key, DEFAULT_OUT)].hex, roughness: 0.45 }));
|
|
}
|
|
function mat(key) {
|
|
if (mats[key]) return mats[key];
|
|
if (key === 'glass') mats[key] = new THREE.MeshStandardMaterial({ color: 0x9fbfcc, roughness: 0.05, metalness: 0.2, transparent: true, opacity: 0.28, depthWrite: false, side: THREE.DoubleSide });
|
|
else if (key === 'rubber') mats[key] = new THREE.MeshStandardMaterial({ color: 0x1b1b1b, roughness: 0.8 });
|
|
else mats[key] = new THREE.MeshStandardMaterial({ color: 0x9a9da0, roughness: 0.3, metalness: 0.7 });
|
|
return mats[key];
|
|
}
|
|
|
|
const toM = 0.001;
|
|
const toShape = (pts, holes) => {
|
|
const s = new THREE.Shape(pts.map(p => new THREE.Vector2(p.x * toM, p.y * toM)));
|
|
(holes || []).forEach(h => s.holes.push(new THREE.Path(h.map(p => new THREE.Vector2(p.x * toM, p.y * toM)))));
|
|
return s;
|
|
};
|
|
function slab(g, pts, holes, z0, z1, matIn, matOut, shadow) {
|
|
if (pts.length < 3 || areaOf(pts) < 1) return;
|
|
const FOIL = matOut && matOut !== matIn ? 1 : 0;
|
|
const add = (a, b, m) => {
|
|
const mesh = new THREE.Mesh(new THREE.ExtrudeGeometry(toShape(pts, holes), { depth: (b - a) * toM, bevelEnabled: false }), m);
|
|
mesh.position.z = a * toM;
|
|
mesh.castShadow = shadow !== false;
|
|
mesh.receiveShadow = true;
|
|
g.add(mesh);
|
|
};
|
|
add(z0, z1 - FOIL, matIn);
|
|
if (FOIL) add(z1 - FOIL, z1, matOut);
|
|
}
|
|
const box = (g, m, x, y, z, w, h, d) => {
|
|
const mesh = new THREE.Mesh(new THREE.BoxGeometry(w * toM, h * toM, d * toM), m);
|
|
mesh.position.set(x * toM, y * toM, z * toM);
|
|
mesh.castShadow = true;
|
|
g.add(mesh);
|
|
};
|
|
|
|
// Gekoppelde zijde (op.joinL/joinR, zie WallModel.resolveOpenings): geen speling en geen kaderstijl;
|
|
// 'stijl' = de helft van een tussenstijl die het kozijn ernaast afmaakt, 'stolp' = niets (bladen tegen elkaar).
|
|
const sideGap = (join) => join ? 0 : P.gap;
|
|
const sideKader = (join) => join === 'stolp' ? 0 : join ? P.tussen / 2 : P.kader;
|
|
|
|
// Lokaal: x vanaf links, y vanaf de onderkant, +z = buiten (mm in, meters uit).
|
|
function build3D(op, fill, place) {
|
|
const f = normalize(fill);
|
|
if (!f) return null;
|
|
const g = new THREE.Group();
|
|
const mIn = colorMat(f.in), mOut = colorMat(f.out);
|
|
const depth = Math.min(P.depth, place.depth || P.depth);
|
|
const z1 = place.zOut, z0 = z1 - depth;
|
|
const hR = op.hR !== undefined ? op.hR : op.h;
|
|
const kL = sideKader(op.joinL), kR = sideKader(op.joinR);
|
|
const outer = insetPoly([{ x: 0, y: 0 }, { x: op.w, y: 0 }, { x: op.w, y: hR }, { x: 0, y: op.h }], [P.gap, sideGap(op.joinR), P.gap, sideGap(op.joinL)]);
|
|
const glass = (pts) => slab(g, pts, null, z1 - 50 - P.glass / 2, z1 - 50 + P.glass / 2, mat('glass'), null, false);
|
|
|
|
if (f.type === 'raam') {
|
|
const inner = insetPoly(outer, [P.kader, kR, P.kader, kL]);
|
|
slab(g, outer, [inner], z0, z1, mIn, mOut);
|
|
let pane = inner;
|
|
if (f.rooster && Math.min(inner[3].y, inner[2].y) - inner[0].y > P.rooster + 200) {
|
|
pane = insetPoly(inner, [0, 0, P.rooster, 0]);
|
|
const band = [pane[3], pane[2], inner[2], inner[3]];
|
|
slab(g, [band[0], band[1], band[2], band[3]], null, z1 - 105, z1 - 8, mIn, mOut);
|
|
[0.3, 0.55, 0.8].forEach(t => {
|
|
const a = insetPoly(inner, [0, 20, P.rooster * t - 4, 20]), b = insetPoly(inner, [0, 20, P.rooster * t + 4, 20]);
|
|
const slot = [b[3], b[2], a[2], a[3]];
|
|
slab(g, slot, null, z1 - 8, z1 - 6, mat('rubber'));
|
|
slab(g, slot, null, z1 - 107, z1 - 105, mat('rubber'));
|
|
});
|
|
}
|
|
glass(pane);
|
|
return g;
|
|
}
|
|
|
|
const sill = place.exterior !== false ? P.dorpel : 0;
|
|
const frameOuter = insetPoly(outer, [sill, 0, 0, 0]);
|
|
const inner = insetPoly(frameOuter, [0, kR, P.kader, kL]);
|
|
const u = [...(kL ? [frameOuter[0], inner[0]] : []), inner[3], inner[2], ...(kR ? [inner[1], frameOuter[1]] : []), frameOuter[2], frameOuter[3]];
|
|
slab(g, u, null, z0, z1, mIn, mOut);
|
|
if (sill) box(g, mat('rubber'), (outer[0].x + outer[1].x) / 2, outer[0].y + sill / 2, z1 - depth / 2 + 15, outer[1].x - outer[0].x, sill, depth + 30);
|
|
|
|
const ix0 = inner[0].x, ix1 = inner[1].x, iy0 = inner[0].y;
|
|
const top = below(inner);
|
|
const topAt = (x) => inner[3].y + (x - inner[3].x) / (inner[2].x - inner[3].x) * (inner[2].y - inner[3].y);
|
|
const region = (x0, x1, y0, y1) => clipPoly(rect(x0, x1, y0, Math.min(y1, 1e6)), top);
|
|
const bar = (pts) => slab(g, pts, null, z0 + 10, z1 - 10, mIn, mOut);
|
|
const link = `${Math.round(op.x || 0)}|${Math.round(op.y || 0)}|${op.w}`;
|
|
if (f.type === 'schuifdeur') {
|
|
buildSlideLeaves(g, f, { ix0, ix1, iy0, topAt, z0, z1, mIn, mOut, sill, place, link, op });
|
|
return g;
|
|
}
|
|
|
|
const hingeR = f.hinge === 'rechts';
|
|
const d = doorSplit(f, ix0, ix1, iy0, Math.min(topAt(ix0), topAt(ix1)));
|
|
const { side, leafR, la, lb, transom, ly1 } = d;
|
|
if (side) {
|
|
const [t0, g0, g1] = leafR ? [la - P.tussen, ix0, la - P.tussen] : [lb, lb + P.tussen, ix1];
|
|
bar(region(t0, t0 + P.tussen, iy0, ly1));
|
|
bar(region(g0, g1, iy0, iy0 + P.kader));
|
|
glass(region(g0, g1, iy0 + P.kader, ly1));
|
|
}
|
|
if (transom) {
|
|
bar(region(ix0, ix1, ly1, ly1 + P.tussen));
|
|
glass(region(ix0, ix1, ly1 + P.tussen, Infinity));
|
|
}
|
|
|
|
const L = doorLeaf(f, d, iy0, sill, top, topAt);
|
|
if (!L) return g;
|
|
const { leaf, lx0, lxR, lb0, lt, lw, holes } = L;
|
|
const lzOut = z1 - 15, lzIn = lzOut - P.leafT;
|
|
const outward = f.swing === 'buiten';
|
|
const hx = hingeR ? lxR : lx0, hz = outward ? lzOut : lzIn;
|
|
const pivot = new THREE.Group(), lg = new THREE.Group();
|
|
pivot.position.set(hx * toM, 0, hz * toM);
|
|
lg.position.set(-hx * toM, 0, -hz * toM);
|
|
pivot.add(lg);
|
|
g.add(pivot);
|
|
if (holes) slab(lg, holes[0], null, (lzIn + lzOut) / 2 - P.glass / 2, (lzIn + lzOut) / 2 + P.glass / 2, mat('glass'), null, false);
|
|
slab(lg, leaf, holes, lzIn, lzOut, mIn, mOut);
|
|
const hy = Math.min(lb0 + 1050, (lb0 + lt) / 2);
|
|
if (lw >= 400) {
|
|
const kx = hingeR ? lx0 + 75 : lxR - 75, gd = hingeR ? 60 : -60;
|
|
[[lzOut, 1], [lzIn, -1]].forEach(([z, s]) => {
|
|
box(lg, mat('beslag'), kx, hy - 30, z + s * 5, 34, 210, 10); // schild
|
|
box(lg, mat('beslag'), kx, hy, z + s * 30, 20, 20, 50); // nek
|
|
box(lg, mat('beslag'), kx + gd, hy, z + s * 55, 140, 20, 20); // greep
|
|
});
|
|
}
|
|
const dir = (hingeR ? -1 : 1) * (outward ? -1 : 1);
|
|
pivot.userData.door = {
|
|
kind: 'swing', dir, max: Math.PI / 2, open: 0, target: 0, link,
|
|
base: pivot.position.x, center: new THREE.Vector3((lx0 + lxR) / 2 * toM, hy * toM, (lzIn + lzOut) / 2 * toM)
|
|
};
|
|
return g;
|
|
}
|
|
|
|
const SLIDE = { overlap: 50, gap: 12, railH: 40, railD: 45, leafT: 40, frame: 70 };
|
|
// Deurblad en zij-/bovenlicht binnen de kaderopening ix0..ix1 vanaf iy0 (lowTop = laagste bovenkant).
|
|
function doorSplit(f, ix0, ix1, iy0, lowTop) {
|
|
const leafR = f.leaf === 'rechts';
|
|
const side = ix1 - ix0 - P.leafW - P.tussen >= P.minLight;
|
|
const la = side && leafR ? ix1 - P.leafW : ix0, lb = side && !leafR ? ix0 + P.leafW : ix1;
|
|
const transom = lowTop - iy0 - P.leafH - P.tussen >= P.minLight;
|
|
return { side, leafR, la, lb, transom, ly1: transom ? iy0 + P.leafH : Infinity };
|
|
}
|
|
|
|
// Deurblad (3 mm speling, onderaan 10 mm boven dorpel/vloer) met het glas erin.
|
|
function doorLeaf(f, d, iy0, sill, top, topAt) {
|
|
const leaf = clipPoly(rect(d.la + 3, d.lb - 3, iy0 + (sill ? 3 : 10), Math.min(d.ly1 - 3, 1e6)), (p) => top({ x: p.x, y: p.y + 3 }));
|
|
if (leaf.length < 3) return null;
|
|
const xs = leaf.map(p => p.x), ys = leaf.map(p => p.y);
|
|
const lx0 = Math.min(...xs), lxR = Math.max(...xs), lb0 = Math.min(...ys), lt = Math.min(topAt(lx0), topAt(lxR), d.ly1) - 3;
|
|
const lw = lxR - lx0;
|
|
let holes = null;
|
|
if (f.volglas && lw >= 400 && lt - lb0 >= 800) {
|
|
holes = [rect(lx0 + 110, lxR - 110, lb0 + 140, lt - 110)]; // glasdeur: smal kader rondom
|
|
} else if (f.glas && lw >= 500 && lt - lb0 >= 1400) {
|
|
const gx = f.hinge === 'rechts' ? lxR - lw * 0.3 : lx0 + lw * 0.3, gw = Math.min(160, lw * 0.18);
|
|
holes = [rect(gx - gw / 2, gx + gw / 2, lb0 + 350, lt - 300)];
|
|
}
|
|
return { leaf, lx0, lxR, lb0, lt, lw, holes };
|
|
}
|
|
|
|
function slideLeaves(f, ix0, ix1, iy0, sill, topAt) {
|
|
const n = f.leaves, opbouw = f.mount === 'opbouw';
|
|
const ov = opbouw ? SLIDE.overlap : -3;
|
|
const xa = ix0 - ov, xb = ix1 + ov;
|
|
const yb = iy0 + (sill ? 3 : 10);
|
|
const yt = Math.min(topAt(ix0), topAt(ix1)) + (opbouw ? SLIDE.overlap : -3);
|
|
const lw = (xb - xa) / n;
|
|
const dirs = n === 2 ? [-1, 1] : [f.dir === 'rechts' ? 1 : -1];
|
|
const leaves = dirs.map((dir, i) => ({
|
|
dir, x0: xa + i * lw + (n === 2 ? (i ? 1 : 0) : 0), x1: xa + (i + 1) * lw - (n === 2 && !i ? 1 : 0)
|
|
}));
|
|
const pane = (l) => f.glas && l.x1 - l.x0 > 2 * SLIDE.frame + 100 ? rect(l.x0 + SLIDE.frame, l.x1 - SLIDE.frame, yb + SLIDE.frame + 30, yt - SLIDE.frame) : null;
|
|
return { n, opbouw, xa, xb, yb, yt, lw, dirs, leaves, pane };
|
|
}
|
|
|
|
function buildSlideLeaves(g, f, o) {
|
|
const S = slideLeaves(f, o.ix0, o.ix1, o.iy0, o.sill, o.topAt);
|
|
const { n, opbouw, xa, xb, yb, yt, lw, dirs } = S;
|
|
const out = f.side === 'buiten';
|
|
const faceIn = o.place.faceIn !== undefined ? o.place.faceIn : o.z0;
|
|
const faceOut = o.place.faceOut !== undefined ? o.place.faceOut : o.z1;
|
|
const lt = opbouw ? SLIDE.leafT : P.leafT;
|
|
const [lz0, lz1] = opbouw
|
|
? (out ? [faceOut + SLIDE.gap, faceOut + SLIDE.gap + lt] : [faceIn - SLIDE.gap - lt, faceIn - SLIDE.gap])
|
|
: [(faceIn + faceOut) / 2 - lt / 2, (faceIn + faceOut) / 2 + lt / 2];
|
|
S.leaves.forEach(l => {
|
|
const { dir, x0, x1 } = l;
|
|
const lg = new THREE.Group();
|
|
g.add(lg);
|
|
const pts = rect(x0, x1, yb, yt);
|
|
const pane = S.pane(l);
|
|
if (pane) {
|
|
slab(lg, pts, [pane], lz0, lz1, colorMat(f.in), opbouw ? null : colorMat(f.out));
|
|
slab(lg, pane, null, (lz0 + lz1) / 2 - 4, (lz0 + lz1) / 2 + 4, mat('glass'), null, false);
|
|
} else {
|
|
slab(lg, pts, null, lz0, lz1, colorMat(f.in), opbouw ? null : colorMat(f.out));
|
|
}
|
|
const hx = dir < 0 ? x1 - 60 : x0 + 60, hy = Math.min(yb + 1050, (yb + yt) / 2);
|
|
if (opbouw) [lz0 - 18, lz1 + 18].forEach(z => box(lg, mat('beslag'), hx, hy, z, 20, 400, 20));
|
|
else [lz0 - 1, lz1 + 1].forEach(z => box(lg, mat('beslag'), hx, hy, z, 24, 160, 2));
|
|
lg.userData.door = {
|
|
kind: 'slide', dir, max: (x1 - x0 - (opbouw ? 2 * SLIDE.overlap : 60)) * toM, open: 0, target: 0, link: o.link,
|
|
base: 0, center: new THREE.Vector3((x0 + x1) / 2 * toM, hy * toM, (lz0 + lz1) / 2 * toM)
|
|
};
|
|
});
|
|
if (opbouw) {
|
|
const ra = n === 2 ? xa - lw : (dirs[0] < 0 ? xa - lw : xa), rb = n === 2 ? xb + lw : (dirs[0] < 0 ? xb : xb + lw);
|
|
const rz = out ? faceOut + SLIDE.railD / 2 : faceIn - SLIDE.railD / 2;
|
|
box(g, mat('beslag'), (ra + rb) / 2, yt + SLIDE.railH / 2 + 5, rz, rb - ra, SLIDE.railH, SLIDE.railD);
|
|
}
|
|
}
|
|
|
|
function planSymbol(op, fill, faces) {
|
|
const f = normalize(fill);
|
|
if (!f || f.type === 'raam') return [];
|
|
const zIn = faces.zIn, zOut = faces.zOut;
|
|
const ix0 = sideGap(op.joinL) + sideKader(op.joinL), ix1 = op.w - sideGap(op.joinR) - sideKader(op.joinR);
|
|
const out = [];
|
|
if (f.type === 'deur') {
|
|
const hingeR = f.hinge === 'rechts';
|
|
const { la, lb } = doorSplit(f, ix0, ix1, 0, 0);
|
|
const L = lb - la, hx = hingeR ? lb : la, s = hingeR ? -1 : 1;
|
|
const outward = f.swing === 'buiten', hz = outward ? zOut : zIn, dz = outward ? 1 : -1;
|
|
out.push({ kind: 'leaf', pts: [{ x: hx, z: hz }, { x: hx, z: hz + dz * L }] });
|
|
const arc = [];
|
|
for (let k = 0; k <= 16; k++) { const t = k / 16 * Math.PI / 2; arc.push({ x: hx + s * L * Math.cos(t), z: hz + dz * L * Math.sin(t) }); }
|
|
out.push({ kind: 'arc', pts: arc });
|
|
return out;
|
|
}
|
|
const n = f.leaves, opbouw = f.mount === 'opbouw', sideOut = f.side === 'buiten';
|
|
const ov = opbouw ? SLIDE.overlap : -3;
|
|
const xa = ix0 - ov, xb = ix1 + ov, lw = (xb - xa) / n;
|
|
const lt = opbouw ? SLIDE.leafT : P.leafT;
|
|
const [z0, z1] = opbouw
|
|
? (sideOut ? [zOut + SLIDE.gap, zOut + SLIDE.gap + lt] : [zIn - SLIDE.gap - lt, zIn - SLIDE.gap])
|
|
: [(zIn + zOut) / 2 - lt / 2, (zIn + zOut) / 2 + lt / 2];
|
|
const dirs = n === 2 ? [-1, 1] : [f.dir === 'rechts' ? 1 : -1];
|
|
const za = sideOut ? Math.max(zOut, z1) + 140 : Math.min(zIn, z0) - 140;
|
|
dirs.forEach((dir, i) => {
|
|
const x0 = xa + i * lw, x1 = x0 + lw;
|
|
out.push({ kind: 'leaf', closed: true, pts: [{ x: x0, z: z0 }, { x: x1, z: z0 }, { x: x1, z: z1 }, { x: x0, z: z1 }] });
|
|
const c = (x0 + x1) / 2, len = Math.min(500, lw * 0.6);
|
|
const a = { x: c - dir * len / 2, z: za }, b = { x: c + dir * len / 2, z: za };
|
|
out.push({ kind: 'arrow', pts: [a, b] });
|
|
out.push({ kind: 'arrow', pts: [{ x: b.x - dir * 90, z: za - 45 }, b, { x: b.x - dir * 90, z: za + 45 }] });
|
|
out.push({ kind: 'rail', closed: true, pts: [{ x: x0 + dir * lw, z: z0 }, { x: x1 + dir * lw, z: z0 }, { x: x1 + dir * lw, z: z1 }, { x: x0 + dir * lw, z: z1 }] });
|
|
});
|
|
return out;
|
|
}
|
|
|
|
// Aanzicht van buiten, lokaal als build3D (x vanaf links, y vanaf de onderkant van de opening): gesloten omtrekken.
|
|
function viewLines(op, fill, exterior) {
|
|
const f = normalize(fill);
|
|
if (!f) return [];
|
|
const hR = op.hR !== undefined ? op.hR : op.h;
|
|
const kL = sideKader(op.joinL), kR = sideKader(op.joinR);
|
|
const outer = insetPoly([{ x: 0, y: 0 }, { x: op.w, y: 0 }, { x: op.w, y: hR }, { x: 0, y: op.h }], [P.gap, sideGap(op.joinR), P.gap, sideGap(op.joinL)]);
|
|
const out = [outer];
|
|
const add = (pts) => { if (pts && pts.length > 2 && areaOf(pts) > 1) out.push(pts); };
|
|
if (f.type === 'raam') {
|
|
const inner = insetPoly(outer, [P.kader, kR, P.kader, kL]);
|
|
add(inner);
|
|
if (f.rooster && Math.min(inner[3].y, inner[2].y) - inner[0].y > P.rooster + 200) add(insetPoly(inner, [0, 0, P.rooster, 0]));
|
|
return out;
|
|
}
|
|
const sill = exterior !== false ? P.dorpel : 0;
|
|
const frameOuter = insetPoly(outer, [sill, 0, 0, 0]);
|
|
const inner = insetPoly(frameOuter, [0, kR, P.kader, kL]);
|
|
if (sill) add(frameOuter);
|
|
add(inner);
|
|
const ix0 = inner[0].x, ix1 = inner[1].x, iy0 = inner[0].y;
|
|
const top = below(inner);
|
|
const topAt = (x) => inner[3].y + (x - inner[3].x) / (inner[2].x - inner[3].x) * (inner[2].y - inner[3].y);
|
|
const region = (x0, x1, y0, y1) => clipPoly(rect(x0, x1, y0, Math.min(y1, 1e6)), top);
|
|
if (f.type === 'schuifdeur') {
|
|
const S = slideLeaves(f, ix0, ix1, iy0, sill, topAt);
|
|
if (!S.opbouw || f.side === 'buiten') S.leaves.forEach(l => { add(region(l.x0, l.x1, S.yb, S.yt)); add(S.pane(l)); });
|
|
return out;
|
|
}
|
|
const d = doorSplit(f, ix0, ix1, iy0, Math.min(topAt(ix0), topAt(ix1)));
|
|
if (d.side) {
|
|
const t0 = d.leafR ? d.la - P.tussen : d.lb;
|
|
add(region(t0, t0 + P.tussen, iy0, d.ly1));
|
|
const [g0, g1] = d.leafR ? [ix0, d.la - P.tussen] : [d.lb + P.tussen, ix1];
|
|
add(region(g0, g1, iy0, iy0 + P.kader));
|
|
}
|
|
if (d.transom) add(region(ix0, ix1, d.ly1, d.ly1 + P.tussen));
|
|
const L = doorLeaf(f, d, iy0, sill, top, topAt);
|
|
if (L) { add(L.leaf); (L.holes || []).forEach(add); }
|
|
return out;
|
|
}
|
|
|
|
return { COLORS, FILL_TYPES, HINGES, SWINGS, SLIDE_MOUNTS, SLIDE_SIDES, SLIDE_DIRS, PROFILE: P, normalize, defaultFill, build3D, planSymbol, viewLines, colorMaterial: colorMat };
|
|
})();
|