forgecad 0.1.0

package/examples/ac-unit-glm47.forge.js

@@ -0,0 +1,108 @@
+// AC Unit Model
+// Shows inside and outside units separated by a wall
+
+// === Parameters ===
+const wallThick = param("Wall Thickness", 200, { min: 100, max: 400, unit: "mm" });
+const wallHeight = param("Wall Height", 2500, { min: 1500, max: 4000, unit: "mm" });
+const wallWidth = param("Wall Width", 3000, { min: 1000, max: 5000, unit: "mm" });
+
+// Inside Unit (Evaporator)
+const inW = param("Inside Width", 800, { min: 400, max: 1200, unit: "mm" });
+const inH = param("Inside Height", 300, { min: 200, max: 500, unit: "mm" });
+const inD = param("Inside Depth", 250, { min: 150, max: 400, unit: "mm" });
+
+// Outside Unit (Condenser)
+const outW = param("Outside Width", 900, { min: 500, max: 1500, unit: "mm" });
+const outH = param("Outside Height", 700, { min: 400, max: 1000, unit: "mm" });
+const outD = param("Outside Depth", 400, { min: 200, max: 600, unit: "mm" });
+
+// === Wall ===
+// Create a wall with a hole for the pipes
+const wall = box(wallWidth, wallThick, wallHeight, true);
+const pipeHole = cylinder(wallThick + 10, 60).rotate(90, 0, 0);
+const wallWithHole = wall.subtract(pipeHole);
+
+// === Inside Unit ===
+// Main housing
+const insideBox = box(inW, inD, inH, true);
+
+// Air vents (slats on the front facing the room)
+const vents = [];
+const ventCount = 8;
+const ventPadZ = 20; // Padding from top/bottom
+const ventSpacing = (inH - 2 * ventPadZ) / (ventCount - 1);
+
+for (let i = 0; i < ventCount; i++) {
+  // Centered box (true) ensures it aligns with the unit's center X
+  vents.push(
+    box(inW - 20, 2, 4, true)
+      .translate(0, -inD / 2 - 1, -inH / 2 + ventPadZ + i * ventSpacing)
+  );
+}
+
+// Control panel area (simple box on top right)
+// Centered box, translated so its right edge aligns with the unit's right edge
+const panelW = 100;
+const panel = box(panelW, 10, 40, true)
+  .translate(inW / 2 - panelW / 2, -inD / 2 - 5, inH / 2 - 20);
+
+const insideUnit = union(insideBox, ...vents, panel)
+  .translate(0, -wallThick / 2 - inD / 2, 0);
+
+// === Outside Unit ===
+// Main housing
+const outsideBox = box(outW, outD, outH, true);
+
+// Fan grill (grid of holes on the back)
+const grillHoles = [];
+const grillRows = 5;
+const grillCols = 8;
+const grillPadX = 40;
+const grillPadZ = 40;
+const grillStepX = (outW - 2 * grillPadX) / (grillCols - 1);
+const grillStepZ = (outH - 2 * grillPadZ) / (grillRows - 1);
+
+for (let r = 0; r < grillRows; r++) {
+  for (let c = 0; c < grillCols; c++) {
+    grillHoles.push(
+      cylinder(10, 8).translate(
+        -outW / 2 + grillPadX + c * grillStepX,
+        outD / 2 + 1,
+        -outH / 2 + grillPadZ + r * grillStepZ
+      )
+    );
+  }
+}
+
+// Compressor bump (raised area on top)
+// Centered box to align with unit
+const compressorBump = box(outW * 0.6, outD * 0.6, 50, true)
+  .translate(0, 0, outH / 2 - 25);
+
+const outsideUnit = outsideBox
+  .subtract(...grillHoles)
+  .add(compressorBump)
+  .translate(0, wallThick / 2 + outD / 2, 0);
+
+// === Connecting Pipes ===
+// Two pipes running through the wall connecting the units
+// Length spans the wall thickness. Centered (true) so they bridge the gap exactly.
+const pipeRadius = 15;
+const pipeOffsetX = inW * 0.25; // Position pipes at 25% width
+const pipeZ1 = -inH / 2 + inH * 0.2; // Lower pipe
+const pipeZ2 = -inH / 2 + inH * 0.4; // Upper pipe
+
+const pipe1 = cylinder(wallThick, pipeRadius, undefined, undefined, true)
+  .rotate(90, 0, 0)
+  .translate(-pipeOffsetX, 0, pipeZ1);
+const pipe2 = cylinder(wallThick, pipeRadius, undefined, undefined, true)
+  .rotate(90, 0, 0)
+  .translate(pipeOffsetX, 0, pipeZ2);
+
+// === Assembly ===
+return [
+  { name: "Wall", shape: wallWithHole.color("#CCCCCC") },
+  { name: "Inside Unit", shape: insideUnit.color("#F0F0F0") },
+  { name: "Outside Unit", shape: outsideUnit.color("#E0E0E0") },
+  { name: "Pipes", shape: union(pipe1, pipe2).color("#333333") }
+];

package/examples/ac-unit-glm5.forge.js

@@ -0,0 +1,174 @@
+// Home AC Unit V3 - Fixed cylinder orientation and positioning
+
+// Parameters
+const wallThick = param("Wall Thickness", 20, { min: 10, max: 40, unit: "mm" });
+const indoorWidth = param("Indoor Width", 80, { min: 60, max: 120, unit: "mm" });
+const indoorHeight = param("Indoor Height", 30, { min: 20, max: 50, unit: "mm" });
+const indoorDepth = param("Indoor Depth", 20, { min: 15, max: 35, unit: "mm" });
+const outdoorWidth = param("Outdoor Width", 70, { min: 50, max: 100, unit: "mm" });
+const outdoorHeight = param("Outdoor Height", 55, { min: 40, max: 80, unit: "mm" });
+const outdoorDepth = param("Outdoor Depth", 30, { min: 20, max: 50, unit: "mm" });
+
+// --- Wall (reference) ---
+// Centered on Y=0: front at Y=-wallThick/2, back at Y=+wallThick/2
+const wall = box(120, wallThick, 100, true).color('#d4c4a8');
+
+// --- INDOOR UNIT (on FRONT of wall, -Y side) ---
+const indoorBody = box(indoorWidth, indoorDepth, indoorHeight, true)
+  .color('#f5f5f5')
+  .attachTo(wall, 'front', 'back', [0, 0, 20]); // Raised 20mm above center
+
+// Front panel (flush with indoor body front)
+const frontPanel = roundedRect(indoorWidth - 4, indoorHeight - 4, 3, true)
+  .extrude(2)
+  .color('#ffffff')
+  .attachTo(indoorBody, 'front', 'back');
+
+// Air outlet vents
+const ventCount = 5;
+const ventSpacing = indoorHeight / (ventCount + 1);
+const vents = [];
+for (let i = 1; i <= ventCount; i++) {
+  const z = -indoorHeight/2 + i * ventSpacing;
+  const vent = box(indoorWidth - 20, 2, 3, true)
+    .color('#333333')
+    .attachTo(frontPanel, 'front', 'center', [0, -1, z]);
+  vents.push(vent);
+}
+
+// Display panel
+const display = box(15, 1, 6, true)
+  .color('#1a1a2e')
+  .attachTo(frontPanel, 'front', 'center', [indoorWidth/4, -1, indoorHeight/4]);
+
+// LED indicator
+const led = sphere(1.5).color('#00ff00')
+  .attachTo(display, 'front', 'front', [0, -1, -2]);
+
+// Mounting bracket
+const bracket = box(indoorWidth - 10, 3, 5)
+  .color('#888888')
+  .attachTo(indoorBody, 'back', 'front');
+
+// --- OUTDOOR UNIT (on BACK of wall, +Y side) ---
+const outdoorBody = box(outdoorWidth, outdoorDepth, outdoorHeight, true)
+  .color('#e8e8e8')
+  .attachTo(wall, 'back', 'front', [0, 0, 10]); // Raised slightly
+
+// Big fan housing - CYLINDER MUST BE ORIENTED ALONG Y FIRST!
+const fanRadius = outdoorHeight * 0.35;
+const fanDepth = outdoorDepth - 8;
+const fanHousing = cylinder(fanDepth, fanRadius)
+  .pointAlong([0, 1, 0])  // Orient along Y axis (perpendicular to wall)
+  .color('#555555')
+  .attachTo(outdoorBody, 'front', 'back'); // Cylinder's back face at outdoor body's front
+
+// Fan blades
+const fanBlade = cylinder(3, fanRadius - 3)
+  .pointAlong([0, 1, 0])
+  .color('#222222')
+  .attachTo(fanHousing, 'front', 'front');
+
+// Fan grille (concentric rings)
+const grilleInner = circle2d(fanRadius * 0.4).color('#666666');
+const grilleMiddle = circle2d(fanRadius * 0.7)
+  .subtract(circle2d(fanRadius * 0.6))
+  .color('#666666');
+const grilleOuter = circle2d(fanRadius * 0.9)
+  .subtract(circle2d(fanRadius * 0.85))
+  .color('#666666');
+const grille = union2d(grilleInner, grilleMiddle, grilleOuter)
+  .extrude(0.5)
+  .attachTo(fanBlade, 'front', 'front');
+
+// Heat exchanger fins (on side, vertical)
+const finCount = 8;
+const fins = [];
+for (let i = 0; i < finCount; i++) {
+  const fin = box(0.5, outdoorDepth - 8, outdoorHeight - 10, true)
+    .color('#cc8844')
+    .attachTo(outdoorBody, 'right', 'center', [outdoorWidth/2 - 3 + i * 3, 0, 0]);
+  fins.push(fin);
+}
+
+// Outdoor unit legs
+const legH = 8;
+const leg1 = box(8, 8, legH).color('#444444')
+  .attachTo(outdoorBody, 'bottom', 'top', [outdoorWidth/3, outdoorDepth/3, -legH/2]);
+const leg2 = box(8, 8, legH).color('#444444')
+  .attachTo(outdoorBody, 'bottom', 'top', [-outdoorWidth/3, outdoorDepth/3, -legH/2]);
+
+// --- CONNECTING PIPES ---
+const pipeR = 4;
+
+// Get bounding boxes for precise pipe routing
+const indoorBB = indoorBody.boundingBox();
+const outdoorBB = outdoorBody.boundingBox();
+
+// Pipe exit point: bottom-back of indoor unit
+const exitX = -indoorWidth/3;
+const exitY = indoorBB.min[1]; // Back of indoor unit (most negative Y)
+const exitZ = indoorBB.min[2] + 8; // Near bottom
+
+// Pipe entry point: bottom-front of outdoor unit  
+const entryX = outdoorWidth/3;
+const entryY = outdoorBB.max[1]; // Front of outdoor unit (most positive Y)
+const entryZ = outdoorBB.min[2] + 12;
+
+// Segment 1: Drop down from indoor unit
+const dropH = 20;
+const pipe1 = cylinder(dropH, pipeR)
+  .pointAlong([0, 0, -1])  // Pointing down
+  .translate(exitX, exitY + 2, exitZ)
+  .color('#c4a066');
+
+// Segment 2: Horizontal through wall
+const midZ = exitZ - dropH;
+const pipe2Len = entryY - exitY + 4; // From indoor exit to outdoor entry
+const pipe2 = cylinder(pipe2Len, pipeR)
+  .pointAlong([0, 1, 0])  // Pointing toward outdoor (positive Y)
+  .translate(exitX, exitY + pipe2Len/2, midZ)
+  .color('#c4a066');
+
+// Segment 3: Rise up to outdoor unit
+const riseH = entryZ - midZ;
+const pipe3 = cylinder(riseH, pipeR)
+  .pointAlong([0, 0, 1])  // Pointing up
+  .translate(entryX, entryY - 2, midZ)
+  .color('#c4a066');
+
+// Segment 4: Connect into outdoor unit
+const pipe4 = cylinder(12, pipeR)
+  .pointAlong([0, -1, 0])  // Pointing toward outdoor unit
+  .translate(entryX, entryY + 6, entryZ)
+  .color('#c4a066');
+
+// --- Return as named objects ---
+return [
+  { name: "Wall", shape: wall },
+  
+  // Indoor unit
+  { name: "Indoor Body", shape: indoorBody },
+  { name: "Front Panel", shape: frontPanel },
+  { name: "Vents", group: vents.map((v, i) => ({ name: `Vent ${i + 1}`, shape: v })) },
+  { name: "Display", shape: display },
+  { name: "LED", shape: led },
+  { name: "Mounting Bracket", shape: bracket },
+  
+  // Outdoor unit  
+  { name: "Outdoor Body", shape: outdoorBody },
+  { name: "Fan Housing", shape: fanHousing },
+  { name: "Fan Blades", shape: fanBlade },
+  { name: "Fan Grille", shape: grille },
+  { name: "Heat Fins", group: fins.map((f, i) => ({ name: `Fin ${i + 1}`, shape: f })) },
+  { name: "Legs", group: [
+    { name: "Left Leg", shape: leg1 },
+    { name: "Right Leg", shape: leg2 }
+  ] },
+  
+  // Pipes
+  { name: "Pipe 1 (drop)", shape: pipe1 },
+  { name: "Pipe 2 (horizontal)", shape: pipe2 },
+  { name: "Pipe 3 (rise)", shape: pipe3 },
+  { name: "Pipe 4 (connect)", shape: pipe4 },
+];

package/examples/ac-unit-kimi25.forge.js

@@ -0,0 +1,236 @@
+// Home AC Unit V3 - Fixed pipe connections to properly enter indoor unit
+// Coordinate system: Z-up (X=left/right, Y=forward/back, Z=up/down)
+// Front (-Y) = indoor side, Back (+Y) = outdoor side
+
+// Parameters
+const wallThick = param("Wall Thickness", 150, { min: 100, max: 300, unit: "mm" });
+const indoorW = param("Indoor Width", 700, { min: 500, max: 1000, unit: "mm" });
+const indoorH = param("Indoor Height", 250, { min: 180, max: 350, unit: "mm" });
+const indoorD = param("Indoor Depth", 200, { min: 150, max: 300, unit: "mm" });
+const outdoorW = param("Outdoor Width", 800, { min: 600, max: 1200, unit: "mm" });
+const outdoorH = param("Outdoor Height", 550, { min: 400, max: 700, unit: "mm" });
+const outdoorD = param("Outdoor Depth", 300, { min: 200, max: 400, unit: "mm" });
+const mountHeight = param("Mount Height", 2000, { min: 1500, max: 2500, unit: "mm" });
+const pipeSpacing = param("Pipe Spacing", 80, { min: 50, max: 150, unit: "mm" });
+
+// --- Wall (vertical, separates indoor and outdoor) ---
+const wallW = Math.max(indoorW, outdoorW) + 200;
+const wallH = 2500;
+const wall = box(wallW, wallThick, wallH, true)
+  .translate(0, 0, wallH / 2)
+  .color('#E8E4D9');
+
+// --- Indoor Unit (on the -Y side of wall) ---
+// Position: back face flush with wall front (Y = -wallThick/2), centered at mountHeight
+const indoorUnitY = -wallThick/2 - indoorD/2;
+const indoorUnitZ = mountHeight;
+
+// Main body
+const indoorBody = box(indoorW, indoorD, indoorH, true)
+  .color('#F5F5F0')
+  .translate(0, indoorUnitY, indoorUnitZ);
+
+// Front panel with vent slats
+const ventPanel = box(indoorW - 20, 5, indoorH * 0.6, true)
+  .color('#E0E0E0')
+  .translate(0, indoorUnitY - indoorD/2 - 2, indoorUnitZ - indoorH * 0.15);
+
+// Top vent (air outlet)
+const topVent = box(indoorW - 40, indoorD - 10, 15, true)
+  .color('#D0D0D0')
+  .translate(0, indoorUnitY, indoorUnitZ + indoorH/2 - 5);
+
+// Display panel
+const display = box(80, 3, 30, true)
+  .color('#1a1a2e')
+  .translate(indoorW * 0.3, indoorUnitY - indoorD/2 - 1, indoorUnitZ + indoorH * 0.25);
+
+// LED indicator
+const led = cylinder(2, 3, undefined, undefined, true)
+  .color('#00ff00')
+  .pointAlong([0, -1, 0])
+  .translate(indoorW * 0.3, indoorUnitY - indoorD/2 - 3, indoorUnitZ + indoorH * 0.25);
+
+// Indoor mounting brackets (L-brackets on wall)
+const bracketThick = 10;
+const bracketW = 60;
+const bracketV = box(bracketThick, bracketW, 100, true).color('#606060');
+const bracketH = box(60, bracketThick, bracketW, true).color('#606060')
+  .translate(0, bracketW/2, -50 + bracketThick/2);
+
+const indoorBracketL = union(bracketV, bracketH)
+  .translate(-indoorW/2 + 80, -wallThick/2 - bracketThick/2, mountHeight - indoorH/2);
+
+const indoorBracketR = union(bracketV, bracketH)
+  .translate(indoorW/2 - 80, -wallThick/2 - bracketThick/2, mountHeight - indoorH/2);
+
+// --- Outdoor Unit (on the +Y side of wall) ---
+// Position: front face flush with wall back (Y = wallThick/2)
+const outdoorUnitY = wallThick/2 + outdoorD/2;
+const outdoorUnitZ = mountHeight - (outdoorH - indoorH)/2;
+
+// Main body
+const outdoorBody = box(outdoorW, outdoorD, outdoorH, true)
+  .color('#FFFFFF')
+  .translate(0, outdoorUnitY, outdoorUnitZ);
+
+// Fan grill - vertical cylinder facing forward (along -Y)
+const fanRadius = Math.min(outdoorW, outdoorH) * 0.35;
+const fanGrill = cylinder(10, fanRadius, fanRadius, undefined, true)
+  .color('#404040')
+  .pointAlong([0, -1, 0])
+  .translate(0, outdoorUnitY + outdoorD/2 + 5, outdoorUnitZ);
+
+// Fan blades
+const bladeCount = 5;
+const fanBlades = [];
+for (let i = 0; i < bladeCount; i++) {
+  const angle = (i / bladeCount) * 360;
+  const blade = box(fanRadius * 0.7, 5, 30, true)
+    .color('#333333')
+    .rotate(angle, 0, 0)
+    .translate(0, outdoorUnitY + outdoorD/2 + 5, outdoorUnitZ);
+  fanBlades.push(blade);
+}
+
+// Side vents
+const sideVents = [];
+for (let i = 0; i < 6; i++) {
+  const y = (i - 2.5) * (outdoorH * 0.6 / 5);
+  const sv = box(5, outdoorD - 20, 12, true)
+    .color('#C0C0C0')
+    .translate(outdoorW/2 + 2, outdoorUnitY, outdoorUnitZ + y);
+  sideVents.push(sv);
+}
+
+// Outdoor mounting feet
+const footW = 100;
+const footD = 15;
+const footH = 40;
+
+const leftFoot = box(footD, outdoorD - 20, footH, true)
+  .color('#505050')
+  .translate(-outdoorW/2 + 100, outdoorUnitY, outdoorUnitZ - outdoorH/2 - footH/2);
+
+const rightFoot = box(footD, outdoorD - 20, footH, true)
+  .color('#505050')
+  .translate(outdoorW/2 - 100, outdoorUnitY, outdoorUnitZ - outdoorH/2 - footH/2);
+
+// Wall mounting plate for outdoor unit
+const mountPlate = box(200, 10, 200, true)
+  .color('#505050')
+  .translate(0, wallThick/2 + 5, outdoorUnitZ);
+
+// --- Connecting Pipes ---
+// Two refrigerant lines going from outdoor unit, through wall, into indoor unit
+const pipeR = 12;
+
+// Pipe Z position - aligned with bottom portion of indoor unit
+const pipeZ = mountHeight - indoorH/2 + 50;
+
+// Calculate Y positions for pipe segments
+// Indoor unit back face is at Y = indoorUnitY + indoorD/2 = -75 + 100 = 25? No...
+// indoorUnitY = -75 - 100 = -175
+// Indoor extends from Y=-275 (front) to Y=-75 (back, against wall)
+// Wall is at Y=-75 to Y=+75
+// Outdoor extends from Y=+75 (front, facing wall) to Y=+375 (back)
+
+// Pipe 1 - the larger insulated line
+// Outdoor segment: from outdoor front (Y=75) extending backward into unit
+const pipe1Outdoor = cylinder(200, pipeR + 6, undefined, undefined, true)
+  .pointAlong([0, -1, 0])  // Points toward -Y (toward wall)
+  .color('#8B4513')  // Copper
+  .translate(-pipeSpacing/2, outdoorUnitY - outdoorD/2 - 50, pipeZ);
+
+// Wall segment: through the wall thickness
+const pipe1Wall = cylinder(wallThick + 20, pipeR + 8, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#1a5f7a')  // Blue insulation
+  .translate(-pipeSpacing/2, 0, pipeZ);
+
+// Indoor segment: from wall (Y=-75) extending into indoor unit (to Y=-175 center)
+const pipe1Indoor = cylinder(120, pipeR + 8, undefined, undefined, true)
+  .pointAlong([0, -1, 0])  // Points toward -Y (into indoor unit)
+  .color('#1a5f7a')
+  .translate(-pipeSpacing/2, indoorUnitY + indoorD/2 - 60, pipeZ);
+
+// Pipe 2 - smaller line
+const pipe2Outdoor = cylinder(200, pipeR, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#8B4513')
+  .translate(pipeSpacing/2, outdoorUnitY - outdoorD/2 - 50, pipeZ);
+
+const pipe2Wall = cylinder(wallThick + 20, pipeR, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#1a5f7a')
+  .translate(pipeSpacing/2, 0, pipeZ);
+
+const pipe2Indoor = cylinder(120, pipeR, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#1a5f7a')
+  .translate(pipeSpacing/2, indoorUnitY + indoorD/2 - 60, pipeZ);
+
+// Wall sleeves
+const sleeve1 = cylinder(wallThick + 10, pipeR + 15, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#888888')
+  .translate(-pipeSpacing/2, 0, pipeZ);
+
+const sleeve2 = cylinder(wallThick + 10, pipeR + 10, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#888888')
+  .translate(pipeSpacing/2, 0, pipeZ);
+
+// Connection points (visual only - where pipes enter the units)
+const conn1Indoor = cylinder(20, pipeR + 10, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#606060')
+  .translate(-pipeSpacing/2, indoorUnitY + indoorD/2, pipeZ);
+
+const conn1Outdoor = cylinder(20, pipeR + 8, undefined, undefined, true)
+  .pointAlong([0, 1, 0])
+  .color('#606060')
+  .translate(-pipeSpacing/2, outdoorUnitY - outdoorD/2, pipeZ);
+
+const conn2Indoor = cylinder(20, pipeR + 4, undefined, undefined, true)
+  .pointAlong([0, -1, 0])
+  .color('#606060')
+  .translate(pipeSpacing/2, indoorUnitY + indoorD/2, pipeZ);
+
+const conn2Outdoor = cylinder(20, pipeR + 2, undefined, undefined, true)
+  .pointAlong([0, 1, 0])
+  .color('#606060')
+  .translate(pipeSpacing/2, outdoorUnitY - outdoorD/2, pipeZ);
+
+return [
+  { name: "Wall", shape: wall },
+  { name: "Indoor Brackets", group: [
+    { name: "Left Bracket", shape: indoorBracketL },
+    { name: "Right Bracket", shape: indoorBracketR }
+  ] },
+  { name: "Indoor Unit Body", shape: indoorBody },
+  { name: "Indoor Vent", shape: ventPanel },
+  { name: "Indoor Top Vent", shape: topVent },
+  { name: "Display Panel", shape: display },
+  { name: "Power LED", shape: led },
+  { name: "Outdoor Mount Plate", shape: mountPlate },
+  { name: "Outdoor Unit Body", shape: outdoorBody },
+  { name: "Fan Grill", shape: fanGrill },
+  { name: "Fan Blades", group: fanBlades.map((b, i) => ({ name: `Blade ${i + 1}`, shape: b })) },
+  { name: "Side Vents", group: sideVents.map((v, i) => ({ name: `Vent ${i + 1}`, shape: v })) },
+  { name: "Outdoor Feet", group: [
+    { name: "Left Foot", shape: leftFoot },
+    { name: "Right Foot", shape: rightFoot }
+  ] },
+  { name: "Pipe 1 (Outdoor)", shape: pipe1Outdoor },
+  { name: "Pipe 1 (Wall)", shape: pipe1Wall },
+  { name: "Pipe 1 (Indoor)", shape: pipe1Indoor },
+  { name: "Pipe 2 (Outdoor)", shape: pipe2Outdoor },
+  { name: "Pipe 2 (Wall)", shape: pipe2Wall },
+  { name: "Pipe 2 (Indoor)", shape: pipe2Indoor },
+  { name: "Wall Sleeves", shape: union(sleeve1, sleeve2) },
+  { name: "Conn Indoor 1", shape: conn1Indoor },
+  { name: "Conn Outdoor 1", shape: conn1Outdoor },
+  { name: "Conn Indoor 2", shape: conn2Indoor },
+  { name: "Conn Outdoor 2", shape: conn2Outdoor },
+];

package/examples/ac-unit-minimax.forge.js

@@ -0,0 +1,123 @@
+// Home AC Unit V3 - Fixed positioning
+// Indoor unit on front of wall, outdoor unit on back, connected through wall
+
+// Parameters
+const wallThick = param("Wall Thickness", 15, { min: 10, max: 30, unit: "mm" });
+const wallWidth = param("Wall Width", 200, { min: 150, max: 300, unit: "mm" });
+const wallHeight = param("Wall Height", 150, { min: 100, max: 250, unit: "mm" });
+
+// Indoor unit parameters
+const indoorW = param("Indoor Width", 70, { min: 50, max: 100, unit: "mm" });
+const indoorD = param("Indoor Depth", 20, { min: 15, max: 35, unit: "mm" });
+const indoorH = param("Indoor Height", 28, { min: 20, max: 45, unit: "mm" });
+
+// Outdoor unit parameters
+const outdoorW = param("Outdoor Width", 75, { min: 55, max: 110, unit: "mm" });
+const outdoorD = param("Outdoor Depth", 30, { min: 20, max: 50, unit: "mm" });
+const outdoorH = param("Outdoor Height", 55, { min: 35, max: 85, unit: "mm" });
+const fanR = param("Fan Radius", 20, { min: 12, max: 30, unit: "mm" });
+
+// Pipe parameters
+const pipeR = param("Pipe Radius", 4, { min: 2, max: 8, unit: "mm" });
+
+// === Build the wall (NOT centered - easier to position against) ===
+const wall = box(wallWidth, wallThick, wallHeight).color('#999999');
+
+// === Indoor Unit (mounted on FRONT of wall) ===
+// Main body
+const indoorMain = box(indoorW, indoorD, indoorH).color('#e8e8e8');
+
+// Vent grille at bottom
+const vent = rect(indoorW - 8, 4).extrude(2).color('#555555')
+  .translate(indoorW / 2, 0, -indoorH / 2 + 5);
+const indoorWithVent = union(indoorMain, vent);
+
+// Position: attach to front of wall, offset outward
+const indoor = indoorWithVent.color('#f0f0f0')
+  .attachTo(wall, 'front', 'back', [0, -2, 20]);
+
+// Display panel - 2D rect extruded, oriented vertically
+const display = rect(15, 8).extrude(1).color('#222222')
+  .rotate(90, 0, 0)  // Rotate to stand upright
+  .attachTo(indoor, 'front', 'back', [indoorW / 2 - 15, -1, indoorH / 2 - 8]);
+
+// === Outdoor Unit (mounted on BACK of wall) ===
+// Main body
+const outdoorMain = box(outdoorW, outdoorD, outdoorH).color('#b8b8b8');
+
+// Base/platform for outdoor unit
+const outdoorBase = box(outdoorW + 8, outdoorD + 8, 6).color('#888888')
+  .attachTo(outdoorMain, 'bottom', 'top', [0, 0, -3]);
+
+const outdoorWithBase = union(outdoorMain, outdoorBase);
+
+// Position: attach to back of wall, offset outward
+const outdoor = outdoorWithBase.color('#cccccc')
+  .attachTo(wall, 'back', 'front', [0, 2, 20]);
+
+// === Fan Assembly (on front of outdoor unit, pointing outward) ===
+// Fan grille - circle with hole, extruded
+const grilleOuter = circle2d(fanR + 3).extrude(2).color('#666666');
+const grilleInner = circle2d(fanR).extrude(3).color('#333333');
+const grille = difference(grilleOuter, grilleInner);
+
+// Rotate grille to be perpendicular to front face (facing outward along +Y)
+const grilleRotated = grille.rotate(90, 0, 0)
+  .attachTo(outdoor, 'front', 'back', [0, -1, 0]);
+
+// Fan blades - radial pattern
+const blade = box(3, fanR - 4, 2).translate(0, (fanR - 4) / 2 + 2, 0).color('#555555');
+const fan = circularPattern(blade, 5).color('#666666')
+  .rotate(90, 0, 0)  // Rotate to stand upright in grille
+  .attachTo(outdoor, 'front', 'back', [0, -1, 0]);
+
+// Fan hub - cylinder pointing outward
+const hub = cylinder(8, fanR / 4).color('#444444')
+  .rotate(90, 0, 0)  // Point along Y axis
+  .attachTo(outdoor, 'front', 'center', [0, -1, 0]);
+
+// === Connector Pipes (through the wall) ===
+// Get positions from the attached shapes
+const indoorBB = indoor.boundingBox();
+const outdoorBB = outdoor.boundingBox();
+
+// Pipe goes from indoor back to outdoor front through wall
+// Wall is at Y=0 to Y=wallThick, so pipe should span from indoor back to outdoor front
+const pipeStartY = indoorBB.max[1];  // Back of indoor
+const pipeEndY = outdoorBB.min[1];   // Front of outdoor
+const pipeLen = pipeEndY - pipeStartY;
+
+// Vertical offset on the units
+const pipeZ = 20;
+
+// Main refrigerant pipe - goes through wall along Y axis
+const mainPipe = cylinder(pipeLen, pipeR)
+  .pointAlong([0, 1, 0])  // Along Y axis
+  .translate(0, (pipeStartY + pipeEndY) / 2, pipeZ)
+  .color('#aa6644');
+
+// Second refrigerant line - offset to the right
+const line2 = cylinder(pipeLen, pipeR * 0.7)
+  .pointAlong([0, 1, 0])
+  .translate(pipeR * 2 + 2, (pipeStartY + pipeEndY) / 2, pipeZ)
+  .color('#aa6644');
+
+// Condensate drain line - lower down
+const drain = cylinder(pipeLen, pipeR * 0.6)
+  .pointAlong([0, 1, 0])
+  .translate(0, (pipeStartY + pipeEndY) / 2, pipeZ - pipeR * 2 - 2)
+  .color('#44aa66');
+
+// Return all objects as separate items to preserve colors
+return [
+  { name: "Wall", shape: wall },
+  { name: "Indoor Unit", shape: indoor },
+  { name: "Display", shape: display },
+  { name: "Outdoor Unit", shape: outdoor },
+  { name: "Fan Grille", shape: grilleRotated },
+  { name: "Fan Blades", shape: fan },
+  { name: "Fan Hub", shape: hub },
+  { name: "Main Pipe", shape: mainPipe },
+  { name: "Refrigerant Line", shape: line2 },
+  { name: "Drain Line", shape: drain },
+];