40:I[328484,["$2","$2f","$30","$31","$32","$33","$34"],"ToolPlayer"] 44:I[27201,["$2"],"IconMark"] 41:T6286,const TAU = Math.PI * 2; const KINDS = { pcb: [['qfp', 'conn', 'qfp', 'conn'], ['soic', 'header', 'button', 'cap', 'soic', 'xtal', 'vias'], ['smd', 'smd', 'smd', 'xtal', 'vias']], schematic: [['ic', 'ic'], ['opamp', 'tr', 'seg', 'ic', 'tr', 'tr'], ['res', 'res', 'cap2', 'diode', 'res', 'cap2']], }; KINDS.mixed = KINDS.pcb.map((a, i) => a.concat(KINDS.schematic[i])); const PREFIX = { qfp: 'U', ic: 'U', soic: 'U', opamp: 'U', conn: 'J', header: 'J', button: 'SW', cap: 'C', cap2: 'C', xtal: 'Y', smd: 'R', res: 'R', diode: 'D', tr: 'Q', seg: 'DS', vias: '' }; const VALUES = { res: ['10k', '4.7k', '220R', '1M', '47k', '330R', '100R', '2.2k'], smd: ['10k', '4.7k', '100R', '0R', '1k', '22R'], cap: ['100uF', '470uF', '220uF', '1000uF'], cap2: ['100nF', '10uF', '22pF', '1uF', '4.7nF', '33pF'], xtal: ['16MHz', '32.768k', '8MHz', '12MHz', '25MHz'], diode: ['1N4148', '1N4007', 'BAT54', 'LED'], tr: ['2SC1815', '2SA1015', 'BC547', '2N3904', 'BC557'], opamp: ['LM358', 'TL072', 'NE5532', 'LM324'], ic: ['74HC595', 'NE555', 'ATMEGA328', 'CD4017', '74LS04', 'MAX232', 'LM317'], soic: ['74HC14', 'AMS1117', 'CH340G', '24LC256', 'LM393'], qfp: ['STM32F407', 'ATSAMD21', 'RP2040', 'ESP32-S3', 'XC6SLX9'], conn: ['GPIO', 'EXP BUS', 'PCIE', 'DDR SLOT'], header: ['JTAG', 'PWR', 'I2C', 'UART', 'SPI'], button: ['RESET', 'BOOT', 'USER'], seg: ['DISP', 'LED7'], }; function rng(n, st = 1) { const a = []; for (let i = 0; i < n; i += st) a.push(i); return a; } function spec(kind, r, s) { const S = (a, b) => Math.max(1, Math.round(r.int(a, b) * s)); switch (kind) { case 'qfp': { const n = Math.max(6, S(8, 16)), st = r.pick([1, 1, 2]); return { w: n, h: n, L: rng(n, st), R: rng(n, st), T: rng(n, st), B: rng(n, st) }; } case 'conn': { const n = Math.max(8, S(14, 30)); return { w: n, h: 2, T: rng(n), B: r.chance(0.5) ? rng(n, 2) : [], rot: true }; } case 'soic': { const n = Math.max(3, S(4, 9)); return { w: 3, h: n, L: rng(n), R: rng(n), rot: true }; } case 'header': { const n = Math.max(2, S(3, 7)); return { w: 2, h: n, L: rng(n), rot: true }; } case 'button': { const n = Math.max(3, S(3, 4)); return { w: n, h: n, L: [n >> 1], R: [n >> 1] }; } case 'cap': { const n = Math.max(2, S(2, 4)); return { w: n, h: n, L: [n >> 1], R: [n >> 1], rot: true }; } case 'xtal': return { w: Math.max(3, S(3, 4)), h: 1, L: [0], R: [0], rot: true }; case 'smd': return { w: 2, h: 1, L: [0], R: [0], rot: true }; case 'vias': return { w: 2, h: 2 }; case 'ic': { const w = Math.max(3, S(4, 7)), h = Math.max(4, S(6, 14)), st = r.pick([1, 2]); return { w, h, L: rng(h, st), R: rng(h, st), T: r.chance(0.3) ? rng(w, 2) : [], rot: true }; } case 'opamp': return { w: 3, h: 3, L: [0, 2], R: [1] }; case 'tr': return { w: 3, h: 3, L: [1], T: [2], B: [2] }; case 'seg': { const w = Math.max(3, S(3, 6)); return { w, h: 4, B: rng(w) }; } case 'res': case 'diode': return { w: 3, h: 1, L: [0], R: [0], rot: true }; default: return { w: 2, h: 1, L: [0], R: [0], rot: true }; // cap2 } } function simplify(pts) { const o = []; for (const q of pts) { const l = o[o.length - 1]; if (!l || l[0] !== q[0] || l[1] !== q[1]) o.push(q); } if (o.length < 3) return o; const out = [o[0]]; for (let k = 1; k < o.length - 1; k++) { const a = out[out.length - 1], b = o[k], c = o[k + 1]; if ((a[0] === b[0] && b[0] === c[0]) || (a[1] === b[1] && b[1] === c[1])) continue; out.push(b); } out.push(o[o.length - 1]); return out; } function build(p, cols, rows, reserve) { const r = kit.rand(p.seed); const grid = new Uint8Array(cols * rows); const at = (x, y) => (x < 0 || y < 0 || x >= cols || y >= rows ? 255 : grid[y * cols + x]); const set = (x, y, v) => { if (x >= 0 && y >= 0 && x < cols && y < rows) grid[y * cols + x] = v; }; const free = (x, y) => at(x, y) === 0; // Density map: 1 = full density, lower = emptier areas. const nz = kit.noise(p.seed * 31 + 7), asp = Math.max(cols, rows); const maskAt = (x, y) => { if (p.maskType === 'none' || p.maskStrength <= 0) return 1; const mu = (x / asp) * p.maskScale, mv = (y / asp) * p.maskScale; let m; switch (p.maskType) { case 'ridges': m = nz.ridged2(mu, mv, 5) * 1.1; break; case 'cells': m = kit.math.clamp(nz.worley2(mu * 1.2, mv * 1.2) * 1.4, 0, 1); break; case 'islands': m = kit.math.smoothstep(-0.15, 0.25, nz.simplex2(mu * 0.7, mv * 0.7)); break; case 'radial': { const dx = x / cols - 0.5, dy = y / rows - 0.5; m = 1.15 - Math.hypot(dx, dy) * 2.2 + nz.fbm2(mu, mv, 4) * 0.3; break; } default: m = nz.fbm2(mu, mv, 5) * 0.9 + 0.5; } if (p.maskInvert) m = 1 - m; return 1 - p.maskStrength * (1 - kit.math.smoothstep(0.38, 0.62, m)); }; const comps = [], traces = [], ends = [], vias = [], holes = [], dots = []; const sch = p.style !== 'pcb'; if (p.frame) for (const [hx, hy] of [[0, 0], [cols - 3, 0], [0, rows - 3], [cols - 3, rows - 3]]) { holes.push([hx + 1, hy + 1]); for (let j = 0; j < 3; j++) for (let i = 0; i < 3; i++) set(hx + i, hy + j, 1); } if (reserve) for (let j = reserve.y - 1; j < reserve.y + reserve.h + 1; j++) for (let i = reserve.x - 1; i < reserve.x + reserve.w + 1; i++) set(i, j, 1); const kinds = KINDS[p.style] || KINDS.pcb; const area = cols * rows, counters = {}; const target = 1 + Math.round((area / 7000) * p.density); const tries = [60, Math.round((area / 130) * p.density), Math.round((area / 80) * p.density)]; for (let cls = 0; cls < 3; cls++) { let placed = 0; for (let t = 0; t < tries[cls]; t++) { if (cls === 0 && placed >= target) break; const kind = r.pick(kinds[cls]); let s = spec(kind, r, p.compScale); if (s.rot && r.chance(0.5)) s = { w: s.h, h: s.w, L: s.T, T: s.L, R: s.B, B: s.R }; const pad = cls === 2 ? 1 : 2; if (s.w + 2 * pad >= cols || s.h + 2 * pad >= rows) continue; const x = r.int(pad, cols - s.w - pad), y = r.int(pad, rows - s.h - pad); const kp = maskAt(x + s.w / 2, y + s.h / 2); if (kp < 1 && r() > (cls === 0 ? 0.35 + 0.65 * kp : kp)) continue; let ok = true; for (let j = y - pad; j < y + s.h + pad && ok; j++) for (let i = x - pad; i < x + s.w + pad; i++) if (at(i, j) !== 0) { ok = false; break; } if (!ok) continue; for (let j = y; j < y + s.h; j++) for (let i = x; i < x + s.w; i++) set(i, j, 1); const pre = PREFIX[kind]; counters[pre] = (counters[pre] || 0) + 1; const c = { kind, x, y, w: s.w, h: s.h, pins: [], label: pre ? pre + counters[pre] : '' }; const add = (arr, f) => { for (const k of arr || []) { const q = f(k); q.used = false; c.pins.push(q); set(q.x, q.y, 3); } }; add(s.L, (j) => ({ x: x - 1, y: y + j, dx: -1, dy: 0, side: 'L' })); add(s.R, (j) => ({ x: x + s.w, y: y + j, dx: 1, dy: 0, side: 'R' })); add(s.T, (i) => ({ x: x + i, y: y - 1, dx: 0, dy: -1, side: 'T' })); add(s.B, (i) => ({ x: x + i, y: y + s.h, dx: 0, dy: 1, side: 'B' })); comps.push(c); placed++; } } const r2 = kit.rand(p.seed * 13 + 5); for (const c of comps) { const vs = VALUES[c.kind]; c.value = vs ? r2.pick(vs) : ''; c.lr = c.w * c.h >= 30 ? 0 : r2(); } const segFree = (a, b) => { const dx = Math.sign(b[0] - a[0]), dy = Math.sign(b[1] - a[1]); let x = a[0], y = a[1]; for (;;) { if (!free(x, y)) return false; if (x === b[0] && y === b[1]) return true; x += dx; y += dy; } }; const mark = (pts) => { for (let k = 0; k < pts.length - 1; k++) { const a = pts[k], b = pts[k + 1], dx = Math.sign(b[0] - a[0]), dy = Math.sign(b[1] - a[1]); let x = a[0], y = a[1]; for (;;) { if (at(x, y) === 0) set(x, y, 2); if (x === b[0] && y === b[1]) break; x += dx; y += dy; } } }; const chamfer = () => p.style === 'pcb' || (p.style === 'mixed' && r.chance(0.5)); const route = (pa, pb, bm) => { const s = [pa.x + pa.dx, pa.y + pa.dy], e = [pb.x + pb.dx, pb.y + pb.dy]; if (!free(s[0], s[1]) || !free(e[0], e[1])) return false; const cands = []; if (bm) { if (pa.dx !== 0) cands.push([s, [bm.x, s[1]], [bm.x, e[1]], e], [s, [s[0], bm.y], [e[0], bm.y], e]); else cands.push([s, [s[0], bm.y], [e[0], bm.y], e], [s, [bm.x, s[1]], [bm.x, e[1]], e]); } if (r.chance(0.5)) cands.push([s, [e[0], s[1]], e], [s, [s[0], e[1]], e]); else cands.push([s, [s[0], e[1]], e], [s, [e[0], s[1]], e]); for (let k = 0; k < 8; k++) { const mx = r.int(Math.min(s[0], e[0]), Math.max(s[0], e[0])); const my = r.int(Math.min(s[1], e[1]), Math.max(s[1], e[1])); cands.push([s, [mx, s[1]], [mx, e[1]], e], [s, [s[0], my], [e[0], my], e]); } for (const c of cands) { let ok = true; for (let k = 0; k < c.length - 1 && ok; k++) ok = segFree(c[k], c[k + 1]); if (!ok) continue; mark(c); traces.push({ pts: simplify([[pa.x, pa.y], ...c, [pb.x, pb.y]]), cham: chamfer() }); pa.used = pb.used = true; if (sch && r.chance(0.3)) dots.push([pa.x, pa.y]); return true; } return false; }; const facing = (A, B) => { const dx = B.x + B.w / 2 - (A.x + A.w / 2), dy = B.y + B.h / 2 - (A.y + A.h / 2); const h = dx > 0 ? 'R' : 'L', v = dy > 0 ? 'B' : 'T'; for (const sd of Math.abs(dx) > Math.abs(dy) ? [h, v] : [v, h]) if (A.pins.some((q) => !q.used && q.side === sd)) return sd; return null; }; const wired = comps.filter((c) => c.pins.length); const nConn = Math.round(wired.length * p.connections); for (let t = 0; t < nConn && wired.length > 1; t++) { const big = wired.filter((c) => c.pins.length >= 6); const A = big.length && r.chance(0.65) ? r.pick(big) : r.pick(wired); const near = wired.filter((c) => c !== A).map((c) => [c, Math.abs(c.x + c.w / 2 - A.x - A.w / 2) + Math.abs(c.y + c.h / 2 - A.y - A.h / 2)]).sort((a, b) => a[1] - b[1]); const nearBig = near.filter(([c]) => c.pins.length >= 6); const pool = nearBig.length && r.chance(0.7) ? nearBig : near; const B = pool[r.int(0, Math.min(3, pool.length - 1))][0]; const sa = facing(A, B), sb = facing(B, A); if (!sa || !sb) continue; const pa = A.pins.filter((q) => !q.used && q.side === sa), pb = B.pins.filter((q) => !q.used && q.side === sb); const k = Math.max(1, Math.min(pa.length, pb.length, Math.round(p.bus * r.range(0.7, 1)))); const i0 = r.int(0, pa.length - k), j0 = r.int(0, pb.length - k), rev = r.chance(0.5); const a0 = pa[i0], b0 = pb[j0]; const bx = Math.round((a0.x + b0.x) / 2 + r.range(-0.25, 0.25) * Math.abs(a0.x - b0.x)); const by = Math.round((a0.y + b0.y) / 2 + r.range(-0.25, 0.25) * Math.abs(a0.y - b0.y)); const sg = rev ? -1 : 1; for (let i = 0; i < k; i++) route(pa[i0 + i], pb[rev ? j0 + k - 1 - i : j0 + i], { x: bx + i * sg, y: by + i * sg }); } for (const c of comps) for (const q of c.pins) { if (q.used || !r.chance(p.stubs * maskAt(q.x, q.y))) continue; let x = q.x, y = q.y, dx = q.dx, dy = q.dy, steps = 0; const pts = [[x, y]], long = sch && r.chance(0.12); let len = long ? 9999 : r.int(1, 6); for (let leg = 0; leg < 2; leg++) { let n = 0; while (n < len && free(x + dx, y + dy)) { x += dx; y += dy; set(x, y, 2); n++; } steps += n; if (n) pts.push([x, y]); if (leg === 0) { if (r.chance(0.5)) break; const sg = r.chance(0.5) ? 1 : -1; [dx, dy] = [dy * sg, dx * sg]; len = long ? 9999 : r.int(1, 5); } } if (steps < 1) continue; q.used = true; traces.push({ pts: simplify(pts), cham: chamfer() }); ends.push({ x, y, dx, dy, t: r.int(0, 3), pcb: p.style === 'pcb' || (p.style === 'mixed' && r.chance(0.5)) }); } if (p.style !== 'schematic') { const nv = Math.round((area / 90) * p.density); for (let t = 0; t < nv; t++) { const x = r.int(1, cols - 2), y = r.int(1, rows - 2); if (free(x, y) && free(x + 1, y) && free(x - 1, y) && free(x, y + 1) && free(x, y - 1) && r() < maskAt(x, y)) { set(x, y, 2); vias.push([x, y]); } } } return { comps, traces, ends, vias, holes, dots }; } defineTool({ render(ctx, p) { const { g, width: W, height: H, px, state } = ctx; const Wd = W / px, Hd = H / px, md = (Math.min(Wd, Hd) * p.margin) / 100; const cols = Math.max(12, Math.floor((Wd - 2 * md) / p.cellSize)), rows = Math.max(12, Math.floor((Hd - 2 * md) / p.cellSize)); const u = p.cellSize * px, ox = (W - cols * u) / 2, oy = (H - rows * u) / 2; // Title block, reserved in the grid so nothing is placed under it. const tt = p.titleType, lt = p.labelType; const title = (p.titleText || '').trim(); const sub = 'DWG-' + String(p.seed).padStart(4, '0') + ' / SHEET 1 OF 1'; let tb = null; if (title) { const ms = (s, t) => { let m = null; try { m = kit.type.measure(s, t); } catch (e) {} const sz = t.size || 12 * px; return { width: m && m.width > 0 ? m.width : s.length * sz * 0.62, height: m && m.height > 0 ? m.height : sz * 1.2 }; }; const m1 = ms(title, tt), m2 = ms(sub, lt); const pad = u * 1.2; const bw = Math.ceil((Math.max(m1.width, m2.width) + pad * 2) / u), bh = Math.ceil((m1.height + m2.height + pad * 2.8) / u); const off = p.frame ? 4 : 1; if (bw + off + 2 < cols && bh + 2 < rows) tb = { x: cols - bw - off, y: rows - bh - 1, w: bw, h: bh, pad, h1: m1.height }; } const key = [p.style, p.seed, p.density, p.compScale, p.connections, p.bus, p.stubs, p.frame, cols, rows, p.maskType, p.maskScale, p.maskStrength, p.maskInvert, tb ? [tb.x, tb.y, tb.w, tb.h].join(',') : ''].join('|'); if (state.key !== key) { state.key = key; state.L = build(p, cols, rows, tb); } const L = state.L; const X = (i) => ox + (i + 0.5) * u, Y = (j) => oy + (j + 0.5) * u; g.fillStyle = p.background; g.fillRect(0, 0, W, H); g.lineCap = 'round'; g.lineJoin = 'round'; if (p.grid > 0) { g.strokeStyle = p.ink; g.lineWidth = 0.5 * px; for (const major of [false, true]) { g.globalAlpha = Math.min(1, p.grid * (major ? 1.8 : 0.6)); const step = major ? u * 5 : u; g.beginPath(); for (let x = ox % step; x <= W; x += step) { g.moveTo(x, 0); g.lineTo(x, H); } for (let y = oy % step; y <= H; y += step) { g.moveTo(0, y); g.lineTo(W, y); } g.stroke(); } g.globalAlpha = 1; } const lw = p.lineWeight * px; const R = (a, b, w, h) => g.rect(a, b, w, h); const C = (x, y, rad) => { g.moveTo(x + rad, y); g.arc(x, y, rad, 0, TAU); }; const Ln = (a, b, c, d) => { g.moveTo(a, b); g.lineTo(c, d); }; const acc = [], dots = L.dots.map(([i, j]) => [X(i), Y(j)]); const drawComp = (c) => { const d = u * 0.14; const cx0 = ox + c.x * u, cy0 = oy + c.y * u, cx1 = ox + (c.x + c.w) * u, cy1 = oy + (c.y + c.h) * u; const x0 = cx0 + d, y0 = cy0 + d, x1 = cx1 - d, y1 = cy1 - d; const mx = (x0 + x1) / 2, my = (y0 + y1) / 2, w = x1 - x0, h = y1 - y0, m = Math.min(w, h), hz = w >= h; for (const q of c.pins) { const qx = X(q.x), qy = Y(q.y); Ln(qx, qy, q.dx ? (q.dx < 0 ? x0 : x1) : qx, q.dy ? (q.dy < 0 ? y0 : y1) : qy); } const A = (t, o) => (hz ? [x0 + w * t, my + o] : [mx + o, y0 + h * t]); const LA = (t1, o1, t2, o2) => { const a = A(t1, o1), b = A(t2, o2); Ln(a[0], a[1], b[0], b[1]); }; const s = u * 0.35; switch (c.kind) { case 'qfp': { R(x0, y0, w, h); const i1 = m * 0.1, i2 = m * 0.24, t = u * 0.35; R(x0 + i1, y0 + i1, w - 2 * i1, h - 2 * i1); acc.push(() => R(x0 + i2, y0 + i2, w - 2 * i2, h - 2 * i2)); for (let q = cx0 + u * 0.5; q < cx1 - 1; q += u * 0.5) { Ln(q, y0, q, y0 - t); Ln(q, y1, q, y1 + t); } for (let q = cy0 + u * 0.5; q < cy1 - 1; q += u * 0.5) { Ln(x0, q, x0 - t, q); Ln(x1, q, x1 + t, q); } break; } case 'conn': { R(x0, y0, w, h); const i = u * 0.3, t = u * 0.25; R(x0 + i, y0 + i, w - 2 * i, h - 2 * i); if (hz) for (let q = cx0 + u * 0.5; q < cx1 - 1; q += u * 0.5) { Ln(q, y0, q, y0 + t); Ln(q, y1, q, y1 - t); } else for (let q = cy0 + u * 0.5; q < cy1 - 1; q += u * 0.5) { Ln(x0, q, x0 + t, q); Ln(x1, q, x1 - t, q); } break; } case 'soic': case 'ic': { R(x0, y0, w, h); const nr = Math.min(m * 0.2, u * 0.5); if (!hz) { g.moveTo(mx + nr, y0); g.arc(mx, y0, nr, 0, Math.PI); } else { g.moveTo(x0, my - nr); g.arc(x0, my, nr, -Math.PI / 2, Math.PI / 2); } if (c.kind === 'soic') acc.push(() => C(x0 + u * 0.4, y0 + u * 0.4, u * 0.12)); break; } case 'header': { R(x0, y0, w, h); for (let j = 0; j < c.h; j++) for (let i = 0; i < c.w; i++) { if (i === 0 && j === 0) R(X(c.x) - u * 0.25, Y(c.y) - u * 0.25, u * 0.5, u * 0.5); else C(X(c.x + i), Y(c.y + j), u * 0.24); } break; } case 'button': R(x0, y0, w, h); C(mx, my, m * 0.36); C(mx, my, m * 0.2); break; case 'cap': C(mx, my, m * 0.48); C(mx, my, m * 0.32); acc.push(() => { Ln(mx - m * 0.1, my, mx + m * 0.1, my); Ln(mx, my - m * 0.1, mx, my + m * 0.1); }); break; case 'xtal': { if (hz) { const rd = h / 2; g.moveTo(x0 + rd, y0); g.lineTo(x1 - rd, y0); g.arc(x1 - rd, my, rd, -Math.PI / 2, Math.PI / 2); g.lineTo(x0 + rd, y1); g.arc(x0 + rd, my, rd, Math.PI / 2, Math.PI * 1.5); } else { const rd = w / 2; g.moveTo(x1, y0 + rd); g.lineTo(x1, y1 - rd); g.arc(mx, y1 - rd, rd, 0, Math.PI); g.lineTo(x0, y0 + rd); g.arc(mx, y0 + rd, rd, Math.PI, TAU); } break; } case 'smd': R(x0, y0, w, h); if (hz) { R(x0, y0, w * 0.3, h); R(x1 - w * 0.3, y0, w * 0.3, h); } else { R(x0, y0, w, h * 0.3); R(x0, y1 - h * 0.3, w, h * 0.3); } break; case 'vias': for (let j = 0; j < 2; j++) for (let i = 0; i < 2; i++) C(X(c.x + i), Y(c.y + j), u * 0.24); break; case 'opamp': g.moveTo(x0, y0); g.lineTo(x1, my); g.lineTo(x0, y1); g.closePath(); acc.push(() => { const a = x0 + w * 0.18, b = u * 0.15; Ln(a - b, Y(c.y), a + b, Y(c.y)); Ln(a, Y(c.y) - b, a, Y(c.y) + b); Ln(a - b, Y(c.y + 2), a + b, Y(c.y + 2)); }); break; case 'tr': { C(mx, my, m * 0.47); const bx = mx - m * 0.15, pxx = X(c.x + 2); Ln(bx, my - m * 0.25, bx, my + m * 0.25); Ln(x0, my, bx, my); Ln(bx, my - m * 0.1, pxx, y0 + m * 0.18); Ln(pxx, y0 + m * 0.18, pxx, y0); Ln(bx, my + m * 0.1, pxx, y1 - m * 0.18); Ln(pxx, y1 - m * 0.18, pxx, y1); acc.push(() => C(pxx - m * 0.12, y1 - m * 0.24, u * 0.08)); break; } case 'seg': { R(x0, y0, w, h); const n = Math.max(1, Math.floor(w / (h * 0.62))), dw = w / n; acc.push(() => { for (let k = 0; k < n; k++) { const a = x0 + k * dw + dw * 0.24; R(a, y0 + h * 0.15, dw * 0.52, h * 0.35); R(a, y0 + h * 0.5, dw * 0.52, h * 0.35); } }); break; } case 'res': { LA(0, 0, 0.2, 0); LA(0.8, 0, 1, 0); let a = A(0.2, 0); g.moveTo(a[0], a[1]); for (let k = 0; k < 6; k++) { a = A(0.2 + (0.6 * (k + 0.5)) / 6, k % 2 ? s : -s); g.lineTo(a[0], a[1]); } a = A(0.8, 0); g.lineTo(a[0], a[1]); break; } case 'diode': { LA(0, 0, 0.3, 0); LA(0.7, 0, 1, 0); LA(0.7, -s, 0.7, s); const a = A(0.3, -s), b = A(0.3, s), e = A(0.7, 0); g.moveTo(a[0], a[1]); g.lineTo(b[0], b[1]); g.lineTo(e[0], e[1]); g.closePath(); break; } default: // cap2 LA(0, 0, 0.4, 0); LA(0.6, 0, 1, 0); LA(0.4, -s * 1.3, 0.4, s * 1.3); LA(0.6, -s * 1.3, 0.6, s * 1.3); } }; const tracePath = (pts, cham) => { g.moveTo(X(pts[0][0]), Y(pts[0][1])); for (let k = 1; k < pts.length; k++) { const bx = X(pts[k][0]), by = Y(pts[k][1]); if (cham > 0 && k < pts.length - 1) { const ax = X(pts[k - 1][0]), ay = Y(pts[k - 1][1]), cx = X(pts[k + 1][0]), cy = Y(pts[k + 1][1]); const l1 = Math.hypot(bx - ax, by - ay), l2 = Math.hypot(cx - bx, cy - by); const dd = Math.min(cham, l1 / 2, l2 / 2); g.lineTo(bx - ((bx - ax) / l1) * dd, by - ((by - ay) / l1) * dd); g.lineTo(bx + ((cx - bx) / l2) * dd, by + ((cy - by) / l2) * dd); } else g.lineTo(bx, by); } }; g.strokeStyle = p.ink; g.lineWidth = lw; g.beginPath(); if (p.frame) { R(ox - u * 0.5, oy - u * 0.5, cols * u + u, rows * u + u); for (const [hx, hy] of L.holes) { C(X(hx), Y(hy), u * 1.2); C(X(hx), Y(hy), u * 0.6); } } for (const c of L.comps) drawComp(c); for (const t of L.traces) if (t.pts.length > 1) tracePath(t.pts, t.cham ? u * 0.9 : 0); for (const v of L.vias) C(X(v[0]), Y(v[1]), u * 0.28); for (const e of L.ends) { const x = X(e.x), y = Y(e.y), nx = -e.dy, ny = e.dx; if (e.pcb) C(x, y, u * 0.32); else if (e.t === 0) dots.push([x, y]); else if (e.t === 1) { [0.45, 0.3, 0.15].forEach((hl, k) => { const ax = x + e.dx * u * 0.2 * k, ay = y + e.dy * u * 0.2 * k; Ln(ax - nx * u * hl, ay - ny * u * hl, ax + nx * u * hl, ay + ny * u * hl); }); } else if (e.t === 2) { const tx = x + e.dx * u * 0.45, ty = y + e.dy * u * 0.45; g.moveTo(x - nx * u * 0.22, y - ny * u * 0.22); g.lineTo(tx, ty); g.lineTo(x + nx * u * 0.22, y + ny * u * 0.22); g.closePath(); } else C(x, y, u * 0.22); } g.stroke(); g.strokeStyle = p.accent; g.beginPath(); for (const f of acc) f(); g.stroke(); if (dots.length) { g.fillStyle = p.accent; g.beginPath(); const dr = lw * 1.2 + u * 0.08; for (const [x, y] of dots) C(x, y, dr); g.fill(); } if (p.pinNumbers) { g.fillStyle = p.labelColor; const fs = Math.max(4 * px, Math.min((lt.size || 7 * px) * 0.75, u * 0.62)); const base = typeof lt.font === 'string' && /[\d.]+px/.test(lt.font) ? lt.font : '10px ui-monospace, Menlo, monospace'; g.font = base.replace(/[\d.]+px/, fs.toFixed(1) + 'px'); g.textBaseline = 'middle'; for (const c of L.comps) { if (c.pins.length < 6) continue; const x0 = ox + c.x * u, y0 = oy + c.y * u, x1 = x0 + c.w * u, y1 = y0 + c.h * u, ins = u * 0.35; c.pins.forEach((q, i) => { const n = String(i + 1); if (q.side === 'L' || q.side === 'R') { g.textAlign = q.side === 'L' ? 'left' : 'right'; g.fillText(n, q.side === 'L' ? x0 + ins : x1 - ins, Y(q.y)); } else { g.save(); g.translate(X(q.x), q.side === 'T' ? y0 + ins : y1 - ins); g.rotate(-Math.PI / 2); g.textAlign = q.side === 'T' ? 'right' : 'left'; g.fillText(n, 0, 0); g.restore(); } }); } g.textAlign = 'left'; } if (tb) { const bx = ox + tb.x * u, by = oy + tb.y * u, bw = tb.w * u, bh = tb.h * u; g.fillStyle = p.background; g.fillRect(bx, by, bw, bh); g.strokeStyle = p.ink; g.lineWidth = lw; const sy = by + tb.pad + tb.h1 + tb.pad * 0.4; g.beginPath(); R(bx, by, bw, bh); Ln(bx, sy, bx + bw, sy); g.stroke(); g.fillStyle = p.ink; kit.type.draw(g, title, tt, bx + tb.pad, by + tb.pad, { width: bw - tb.pad * 2 }); g.fillStyle = p.labelColor; kit.type.draw(g, sub, lt, bx + tb.pad, sy + tb.pad * 0.4, { width: bw - tb.pad * 2 }); } if (p.labels) { g.fillStyle = p.labelColor; const gap = u * 0.25; const al = lt.align === 'center' || lt.align === 'right' ? lt.align : 'left'; const ax = al === 'left' ? 0 : al === 'center' ? 0.5 : 1; const place = (txt, x, y, rot, align, valign) => { g.save(); g.translate(x, y); if (rot) g.rotate(-Math.PI / 2); kit.type.draw(g, txt, lt, 0, 0, { align, valign }); g.restore(); }; for (const c of L.comps) { if (c.lr > p.labelAmount) continue; const txt = p.labelContent === 'value' ? c.value : p.labelContent === 'both' ? [c.label, c.value].filter(Boolean).join('\n') : c.label; if (!txt) continue; const sides = new Set(c.pins.map((q) => q.side)); const x0 = ox + c.x * u, y0 = oy + c.y * u, w = c.w * u, h = c.h * u; const vert = p.labelRotate && c.h > c.w * 1.4; const big = c.w >= 4 && c.h >= 4; if (big && (c.kind === 'qfp' || c.kind === 'ic')) place(txt, x0 + w / 2, y0 + h / 2, vert, 'center', 'middle'); else if (vert && !sides.has('L')) place(txt, x0 - gap, y0 + h * (1 - ax), true, al, 'bottom'); else if (vert && !sides.has('R')) place(txt, x0 + w + gap, y0 + h * (1 - ax), true, al, 'top'); else if (!sides.has('T')) place(txt, x0 + w * ax, y0 - gap, false, al, 'bottom'); else if (!sides.has('B')) place(txt, x0 + w * ax, y0 + h + gap, false, al, 'top'); else if (c.w >= 3 && c.h >= 3) place(txt, x0 + w / 2, y0 + h / 2, vert, 'center', 'middle'); } } }, }); 37:["$","$L40",null,{"spec":{"code":"$41","name":"Circuit Blueprint","presets":[{"name":"Dark PCB","values":{"ink":"#d6d6d2","style":"pcb","accent":"#a9a9a4","background":"#232323"}},{"name":"Dense Schematic","values":{"ink":"#e4e4e0","frame":false,"stubs":0.6,"style":"schematic","accent":"#ffffff","labels":true,"density":1.5,"cellSize":6,"background":"#151515","lineWeight":0.8,"connections":2.2}},{"name":"Blueprint","values":{"bus":12,"ink":"#dfe7ff","grid":0.07,"frame":false,"style":"mixed","accent":"#ffffff","density":0.6,"cellSize":8,"compScale":1.7,"background":"#263f8a","connections":2.5}},{"name":"Green Board","values":{"ink":"#7fe0a6","style":"pcb","accent":"#e8c36a","labels":true,"density":1.3,"cellSize":7,"background":"#0d3a2b"}},{"name":"Patent Paper","values":{"ink":"#1d2222","style":"mixed","accent":"#0f8f4e","labels":true,"density":0.8,"cellSize":11,"background":"#aab3b2","lineWeight":1.3}}],"animated":false,"renderer":"canvas2d","sections":[{"label":"Layout","controls":[{"key":"style","type":"select","label":"Style","default":"pcb","options":[{"label":"PCB board","value":"pcb"},{"label":"Schematic","value":"schematic"},{"label":"Mixed","value":"mixed"}]},{"key":"seed","type":"seed","label":"Seed","default":7},{"key":"generate","type":"button","label":"Generate","action":"reseed"},{"key":"cellSize","max":20,"min":4,"step":0.5,"type":"slider","label":"Grid unit","default":7},{"key":"density","max":2,"min":0.2,"step":0.01,"type":"slider","label":"Density","default":1.2},{"key":"compScale","max":2.2,"min":0.5,"step":0.01,"type":"slider","label":"Part size","default":1.3},{"key":"margin","max":25,"min":0,"step":0.5,"type":"slider","label":"Edge margin %","default":6}]},{"label":"Density map","controls":[{"key":"maskType","type":"select","label":"Noise","default":"clouds","options":[{"label":"None","value":"none"},{"label":"Fractal clouds","value":"clouds"},{"label":"Ridges","value":"ridges"},{"label":"Cells","value":"cells"},{"label":"Islands","value":"islands"},{"label":"Radial","value":"radial"}]},{"key":"maskScale","max":10,"min":0.5,"step":0.1,"type":"slider","label":"Noise scale","default":2.5},{"key":"maskStrength","max":1,"min":0,"step":0.01,"type":"slider","label":"Emptiness","default":0.8},{"key":"maskInvert","type":"toggle","label":"Invert map","default":false}]},{"label":"Wiring","controls":[{"key":"connections","max":5,"min":0,"step":0.05,"type":"slider","label":"Connections","default":3.2},{"key":"bus","max":16,"min":1,"step":1,"type":"slider","label":"Bus width","default":10},{"key":"stubs","max":1,"min":0,"step":0.01,"type":"slider","label":"Loose ends","default":0.45},{"key":"lineWeight","max":3,"min":0.4,"step":0.05,"type":"slider","label":"Line weight","default":1}]},{"label":"Text","controls":[{"key":"labels","type":"toggle","label":"Part labels","default":false},{"key":"labelContent","type":"select","label":"Label content","default":"ref","options":[{"label":"Designators (U1, R4)","value":"ref"},{"label":"Values (10k, LM358)","value":"value"},{"label":"Both","value":"both"}]},{"key":"labelAmount","max":1,"min":0,"step":0.01,"type":"slider","label":"Labeled parts","default":0.7},{"key":"labelType","type":"type","label":"Label type","fields":["font","style","size","leading","tracking","align","case"],"default":"{\"font\":\"g:jetbrains-mono\",\"weight\":500,\"italic\":false,\"size\":7,\"leading\":1.1,\"tracking\":2,\"wordSpacing\":0,\"align\":\"left\",\"case\":\"upper\",\"decoration\":\"none\",\"paragraph\":0,\"indent\":0,\"axes\":{},\"features\":{}}"},{"key":"labelRotate","type":"toggle","label":"Vertical labels","default":true},{"key":"pinNumbers","type":"toggle","label":"Pin numbers","default":false},{"key":"titleText","type":"text","label":"Title block (empty = none)","default":""},{"key":"titleType","type":"type","label":"Title type","fields":["font","style","size","tracking","align","case"],"default":"{\"font\":\"g:space-grotesk\",\"weight\":600,\"italic\":false,\"size\":16,\"leading\":1,\"tracking\":4,\"wordSpacing\":0,\"align\":\"left\",\"case\":\"upper\",\"decoration\":\"none\",\"paragraph\":0,\"indent\":0,\"axes\":{},\"features\":{}}"}]},{"label":"Details","controls":[{"key":"frame","type":"toggle","label":"Board frame","default":true},{"key":"grid","max":0.3,"min":0,"step":0.01,"type":"slider","label":"Paper grid","default":0},{"key":"background","type":"color","label":"Background","default":"#232323"},{"key":"ink","type":"color","label":"Lines","default":"#d6d6d2"},{"key":"accent","type":"color","label":"Accent","default":"#a9a9a4"},{"key":"labelColor","type":"color","label":"Text","default":"#c9c9c2"}]}],"description":"Generates detailed PCB layouts and electronic schematics: chips, connectors, passive parts and symbols wired by routed traces, in blueprint, dark or paper palettes."},"versionId":"5669153c-49b9-4ec2-a4c0-fa8ab25becf5","toolId":"e17cc0e4-0c88-4aac-be97-74cd9a0a0589","carry":{"bus":4,"ink":"#ffffff","grid":0,"seed":4214,"frame":false,"stubs":0.68,"style":"pcb","accent":"#a9a9a4","labels":false,"margin":4,"density":1.35,"cellSize":6.5,"maskType":"radial","compScale":1.24,"labelType":"{\"font\":\"g:jetbrains-mono\",\"weight\":500,\"italic\":false,\"size\":7,\"leading\":1.1,\"tracking\":2,\"wordSpacing\":0,\"align\":\"left\",\"case\":\"upper\",\"decoration\":\"none\",\"paragraph\":0,\"indent\":0,\"axes\":{},\"features\":{}}","maskScale":2.2,"titleText":"","titleType":"{\"font\":\"g:space-grotesk\",\"weight\":600,\"italic\":false,\"size\":16,\"leading\":1,\"tracking\":4,\"wordSpacing\":0,\"align\":\"left\",\"case\":\"upper\",\"decoration\":\"none\",\"paragraph\":0,\"indent\":0,\"axes\":{},\"features\":{}}","background":"#104BFF","labelColor":"#c9c9c2","lineWeight":1,"maskInvert":false,"pinNumbers":false,"connections":1.3,"labelAmount":0.7,"labelRotate":false,"labelContent":"ref","maskStrength":0.82},"reportErrors":true,"footer":"$L42","headExtra":"$L43"}] 39:null 3f:[["$","title","0",{"children":"Circuit Blueprint · Blueprint"}],["$","meta","1",{"name":"description","content":"Generates detailed PCB layouts and electronic schematics: chips, connectors, passive parts and symbols wired by routed traces, in blueprint, dark or paper palettes."}],["$","link","2",{"rel":"canonical","href":"https://blueprint.page/p/circuit-blueprint"}],["$","meta","3",{"property":"og:title","content":"Circuit Blueprint"}],["$","meta","4",{"property":"og:description","content":"Generates detailed PCB layouts and electronic schematics: chips, connectors, passive parts and symbols wired by routed traces, in blueprint, dark or paper palettes."}],["$","meta","5",{"property":"og:url","content":"https://blueprint.page/p/circuit-blueprint"}],["$","meta","6",{"property":"og:site_name","content":"Blueprint"}],["$","meta","7",{"property":"og:image","content":"https://blueprint.page/welcome/opengraph-image.jpg"}],["$","meta","8",{"property":"og:type","content":"website"}],["$","meta","9",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","10",{"name":"twitter:title","content":"Circuit Blueprint"}],["$","meta","11",{"name":"twitter:description","content":"Generates detailed PCB layouts and electronic schematics: chips, connectors, passive parts and symbols wired by routed traces, in blueprint, dark or paper palettes."}],["$","meta","12",{"name":"twitter:image","content":"https://blueprint.page/welcome/opengraph-image.jpg"}],["$","link","13",{"rel":"icon","href":"/favicon.ico?v=2026-10-28","sizes":"any","type":"image/x-icon"}],["$","link","14",{"rel":"icon","href":"/icon.png?v=2026-10-28","sizes":"192x192","type":"image/png"}],["$","link","15",{"rel":"apple-touch-icon","href":"/apple-touch-icon.png?v=2026-10-28","sizes":"180x180","type":"image/png"}],["$","$L44","16",{}]]