Assembly model of a dog house designed to accommodate a Great Dane, built using 2x4 lumber

// Dog House for a Great Dane
// Assembly model of a dog house designed to accommodate a Great Dane, built using 2x4 lumber
// Categories: Maker

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import submodules; each defines geometry at top level. Importing assembles the scene.
import "frame.kcl" as frame
import "front-wall.kcl" as frontWall
import "roof.kcl" as roof
import "back-frame.kcl" as backFrame
import "left-wall.kcl" as leftWall
import "right-wall.kcl" as rightWall
import "floor.kcl" as floor


// Dog House (Great Dane) - 2x4 Helpers
// Utility helpers for extruding 2x4 lumber profiles.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and define parameters
import * from "dimensions.kcl"
export woodColor = "#a0825c"
export woodRoughness = 80
export woodMetalness = 0

fn prism(minX, minY, minZ, sizeX, sizeY, sizeZ) {
  return startSketchOn(XY)
    // Start a 2D sketch on the global XY plane
    |> rectangle(width = sizeX, height = sizeY, corner = [minX, minY]) // Draw the 2x4 cross‑section at the given corner
    |> extrude(length = sizeZ) // Create a 3D prism by extruding the rectangle along +Z
    |> appearance(color = woodColor, roughness = woodRoughness, metalness = woodMetalness) // Apply a wood‑like material
    |> translate(z = minZ) // Position the prism so its bottom sits at minZ
}

// 2x4 along X (length in X), depth in Y, thickness in Z.
export fn twoByFourX(minX, minY, minZ, lengthX) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = lengthX,
    sizeY = studDepth,
    sizeZ = studThickness,
  ) // Orients the 2x4 with its long axis in X
}

// 2x4 along X, thickness in Y, depth in Z (rotated).
export fn twoByFourXRotated(minX, minY, minZ, lengthX) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = lengthX,
    sizeY = studThickness,
    sizeZ = studDepth,
  )
}

// 2x4 along Y (length in Y), depth in X, thickness in Z.
export fn twoByFourY(minX, minY, minZ, lengthY) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = studDepth,
    sizeY = lengthY,
    sizeZ = studThickness,
  ) // Long axis in Y
}

// 2x4 along Y, thickness in X, depth in Z (rotated).
export fn twoByFourYRotated(minX, minY, minZ, lengthY) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = studThickness,
    sizeY = lengthY,
    sizeZ = studDepth,
  )
}

// 2x4 along Z (length in Z), depth in X, thickness in Y.
export fn twoByFourZ(minX, minY, minZ, lengthZ) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = studDepth,
    sizeY = studThickness,
    sizeZ = lengthZ,
  )
}

// 2x4 along Z, thickness in X, depth in Y (rotated).
export fn twoByFourZRotated(minX, minY, minZ, lengthZ) {
  return prism(
    minX = minX,
    minY = minY,
    minZ = minZ,
    sizeX = studThickness,
    sizeY = studDepth,
    sizeZ = lengthZ,
  )
}


// Dog House (Great Dane) - Back Frame
// Back frame plates and slats for the dog house.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import parameters
import * from "dimensions.kcl"
import * from "2x4.kcl"

// Back plates
// Top plate spanning the back wall at studTopZ
topBackPlate = twoByFourX(
  minX = -frameWidth / 2 + studDepth,
  minY = frameLength - studDepth,
  minZ = studTopZ,
  lengthX = frameWidth - (2 * studDepth),
)

// Back slats (fixed)
// Compute a vertical slat and pattern it across X to close the back wall
backSlatWidth = studDepth
backSlatGap = 2
backSlatPitch = backSlatWidth + backSlatGap
backSlatStartX = -interiorWidth / 2
backSlatEndX = interiorWidth / 2 - backSlatWidth
backSlatSpanX = backSlatEndX - backSlatStartX
backSlatCount = floor(backSlatSpanX / backSlatPitch) + 1
backSlatActualPitch = backSlatSpanX / (backSlatCount - 1)
backSlatDepth = studThickness
backSlatY = frameLength - backSlatDepth

backSlats = patternLinear3d(
  [
    twoByFourZ(
      minX = backSlatStartX,
      minY = backSlatY,
      minZ = studBaseZ,
      lengthZ = studHeight,
    )
  ],
  axis = [1, 0, 0],
  distance = backSlatActualPitch,
  instances = backSlatCount,
) // Distribute slats across the back opening along X


// Dog House (Great Dane) - Dimensions
// Shared dimension constants for the Great Dane dog house.
// Note: this module defines parameters only; it emits no geometry.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Core dimensions (inches)
export studThickness = 1.5
export studDepth = 3.5
export plateHeight = studThickness

export bedLength = 52
export bedWidth = 36
export clearance = 2

export interiorLength = bedLength + 2 * clearance
export interiorWidth = bedWidth + 2 * clearance
export interiorWallHeight = 32
export roofRise = 12

export floorZ = 0
export innerFloorZ = plateHeight

export eaveZ = innerFloorZ + interiorWallHeight
export peakZ = eaveZ + roofRise

export frameLength = interiorLength + 2 * studDepth
export frameWidth = interiorWidth + 2 * studDepth

// Front opening sizing (2x4 frame only)
export openingSideClearance = 0.5
export openingWidth = interiorWidth - (2 * openingSideClearance)

// Derived stud heights
export studBaseZ = plateHeight
export studTopZ = eaveZ - plateHeight
export studHeight = studTopZ - studBaseZ


// Dog House (Great Dane) - Dog Bone Sign
// Parametric bone sign profile, extruded and wood-colored.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and declare parameters
import * from "2x4.kcl"

// Bone profile parameters (adjusted for a thicker center bar)
boneHalfWidth = 6.06
boneNeckTopX = -3.31
boneNeckBottomX = -3.07
boneNeckTopZ = 3.6
boneNeckBottomZ = -0.6

boneTopLobeInterior = [-4.95, 5.08]
boneTopLobeEnd = [-6.06, 1.13]
boneBottomLobeInterior = [-5.04, -2.99]
boneBottomLobeEnd = [boneNeckBottomX, boneNeckBottomZ]

export signThickness = 0.75
export signWidth = boneHalfWidth * 2
export signHeight = boneTopLobeInterior[1] - boneBottomLobeInterior[1]

boneBottomOffsetZ = -boneBottomLobeInterior[1]

boneSketch = startSketchOn(XZ)
boneProfile = startProfile(boneSketch, at = [0, boneNeckTopZ])
  |> xLine(length = boneNeckTopX)
  |> arc(interiorAbsolute = boneTopLobeInterior, endAbsolute = boneTopLobeEnd)
  |> arc(interiorAbsolute = boneBottomLobeInterior, endAbsolute = boneBottomLobeEnd)
  |> xLine(length = -boneBottomLobeEnd[0])
  |> mirror2d(axis = Y)

dogBoneSign = boneProfile
  |> extrude(length = signThickness)
  |> appearance(color = woodColor, roughness = woodRoughness, metalness = woodMetalness)
  |> translate(z = boneBottomOffsetZ)

[dogBoneSign]


// Dog House (Great Dane) - Door
// Door panel and hardware placement for the dog house.

@settings(experimentalFeatures = allow, defaultLengthUnit = in)

import * from "dimensions.kcl"
import * from "2x4.kcl"
import "1528A31_strap-hinge.stp" as strapHingeRaw
import "1614A11_swinging-bar-latch.stp" as latchRaw

// Door (single wide door)
doorClearance = 0.5
doorPanelWidth = openingWidth - (2 * doorClearance)
doorPanelHeight = studHeight - (2 * doorClearance)
doorBottomZ = studBaseZ + doorClearance
doorTopZ = doorBottomZ + doorPanelHeight
doorStileWidth = studDepth
doorRailHeight = studDepth

doorInnerWidth = doorPanelWidth - (2 * doorStileWidth)
doorInnerHeight = doorPanelHeight - (2 * doorRailHeight)

doorSlatWidth = studDepth
doorSlatGap = 2
doorSlatPitch = doorSlatWidth + doorSlatGap
doorSlatStartX = -doorInnerWidth / 2
doorSlatEndX = doorInnerWidth / 2 - doorSlatWidth
doorSlatSpanX = doorSlatEndX - doorSlatStartX
doorSlatCount = floor(doorSlatSpanX / doorSlatPitch) + 1
doorSlatActualPitch = doorSlatSpanX / (doorSlatCount - 1)
doorRailMinX = -doorPanelWidth / 2 + doorStileWidth
doorSlatMinZ = doorBottomZ + doorRailHeight

hingeLength = 6
hingeInset = 4
hingeFaceOffset = 0.02
hingeThickness = 0.245
hingeRotateAngle = 90deg

latchFaceOffset = 0.02
latchEdgeInset = 0.5
latchMaxX = 3.152
latchMaxY = 1.22
latchCenterZ = 1.451
latchRotateAngleX = -90deg
latchRotateAngleY = 180deg
latchRotateAngleZ = 180deg

latchOffsetX = doorStileWidth + studThickness
latchOffsetY = 6 * studDepth
latchOffsetZ = -4 * studDepth

crateDoorY = -studThickness
crateDoorHingeY = crateDoorY - hingeFaceOffset - hingeThickness
doorOutsideY = crateDoorY

hingeLeftX = -doorPanelWidth / 2
hingeBottomZ = doorBottomZ + hingeInset + hingeLength / 2
hingeTopZ = doorTopZ - hingeInset - (hingeLength / 2)
doorMidZ = doorBottomZ + doorPanelHeight / 2

fn hingeTemplate() {
  return appearance(
    strapHingeRaw,
    color = "#b0b0b0",
    metalness = 1,
    roughness = 0.35,
  )
}

fn latchTemplate() {
  return appearance(
         latchRaw,
         color = "#2b2b2b",
         metalness = 0.6,
         roughness = 0.45,
       )
    |> rotate(axis = [1, 0, 0], angle = latchRotateAngleX)
    |> rotate(axis = Z, angle = latchRotateAngleZ)
    |> rotate(axis = Y, angle = latchRotateAngleY)
}

fn doorStile(minX, doorY) {
  return twoByFourZ(
    minX = minX,
    minY = doorY,
    minZ = doorBottomZ,
    lengthZ = doorPanelHeight,
  )
}

fn doorRail(minZ, doorY) {
  return twoByFourXRotated(
    minX = doorRailMinX,
    minY = doorY,
    minZ = minZ,
    lengthX = doorInnerWidth,
  )
}

fn doorSlats(doorY) {
  return patternLinear3d(
    [
      twoByFourZ(
        minX = doorSlatStartX,
        minY = doorY,
        minZ = doorSlatMinZ,
        lengthZ = doorInnerHeight,
      )
    ],
    axis = [1, 0, 0],
    distance = doorSlatActualPitch,
    instances = doorSlatCount,
  )
}

crateDoorLeftStile = doorStile(minX = -doorPanelWidth / 2, doorY = crateDoorY)
crateDoorRightStile = doorStile(minX = doorPanelWidth / 2 - doorStileWidth, doorY = crateDoorY)
crateDoorBottomRail = doorRail(minZ = doorBottomZ, doorY = crateDoorY)
crateDoorTopRail = doorRail(minZ = doorTopZ - doorRailHeight, doorY = crateDoorY)
crateDoorSlats = doorSlats(doorY = crateDoorY)

crateDoorTopHinge = hingeTemplate()
  |> translate(x = hingeLeftX, y = crateDoorHingeY, z = hingeTopZ)
  |> rotate(axis = [0, 1, 0], angle = hingeRotateAngle)
crateDoorBottomHinge = clone(crateDoorTopHinge)
  |> translate(z = hingeBottomZ - hingeTopZ)

crateDoorLatch = latchTemplate()
  |> translate(x = doorPanelWidth / 2 - latchEdgeInset - latchMaxX + latchOffsetX, y = doorOutsideY - latchFaceOffset - latchMaxY + latchOffsetY, z = doorMidZ - latchCenterZ + latchOffsetZ)

crateDoorFrameParts = [
  crateDoorLeftStile,
  crateDoorRightStile,
  crateDoorBottomRail,
  crateDoorTopRail
]
crateDoorWithSlats = concat(crateDoorFrameParts, items = crateDoorSlats)
crateDoorParts = concat(
  crateDoorWithSlats,
  items = [
    crateDoorTopHinge,
    crateDoorBottomHinge,
    crateDoorLatch
  ],
)

crateDoorParts


// Dog House (Great Dane) - Floor
// Floor slats and base layout for the dog house.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and define parameters
import * from "dimensions.kcl"
import * from "2x4.kcl"

// Floor slat spacing
floorSlatSpacing = 6
floorSlatWidth = studDepth

// Floor slats
// One slat geometry, then a linear 3D pattern to fill the length.
floorSlatStartY = studDepth
floorSlatEndY = frameLength - studDepth - floorSlatWidth
floorSlatSpan = floorSlatEndY - floorSlatStartY
floorSlatCount = floor(floorSlatSpan / floorSlatSpacing) + 1
floorSlatActualPitch = floorSlatSpan / (floorSlatCount - 1)

floorSlat = twoByFourX(
  minX = -interiorWidth / 2,
  minY = floorSlatStartY,
  minZ = floorZ,
  lengthX = interiorWidth,
) // Single slat across the interior width


floorSlats = patternLinear3d(
  [floorSlat],
  axis = [0, 1, 0],
  distance = floorSlatActualPitch,
  instances = floorSlatCount,
) // Fill along Y with uniform pitch


// Dog House (Great Dane) - Base Frame
// Base plate layout for the dog house frame.

@settings(experimentalFeatures = allow, defaultLengthUnit = in)

import * from "dimensions.kcl"
import * from "2x4.kcl"

// Base plates
leftBottomPlate = twoByFourY(
  minX = -frameWidth / 2,
  minY = 0,
  minZ = floorZ,
  lengthY = frameLength,
)
rightBottomPlate = twoByFourY(
  minX = frameWidth / 2 - studDepth,
  minY = 0,
  minZ = floorZ,
  lengthY = frameLength,
)
frontBottomPlate = twoByFourX(
  minX = -frameWidth / 2 + studDepth,
  minY = 0,
  minZ = floorZ,
  lengthX = frameWidth - (2 * studDepth),
)
backBottomPlate = twoByFourX(
  minX = -frameWidth / 2 + studDepth,
  minY = frameLength - studDepth,
  minZ = floorZ,
  lengthX = frameWidth - (2 * studDepth),
)


// Dog House (Great Dane) - Front Wall
// Front wall studs and plates around the door opening.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and define parameters
import * from "dimensions.kcl"
import * from "2x4.kcl"
import * from "dog-bone-sign.kcl"
import "dog-bone-sign.kcl" as dogBoneSign

// Top front plate
// Spans the front wall at studTopZ (underside of top plate elevation)
topFrontPlate = twoByFourX(
  minX = -frameWidth / 2 + studDepth,
  minY = 0,
  minZ = studTopZ,
  lengthX = frameWidth - (2 * studDepth),
)

// Front wall studs around the opening (studs oriented with depth along Y)
frontStudLeftX = -openingWidth / 2 - studThickness
frontStudRightX = openingWidth / 2
frontStudLeft = twoByFourZRotated(
  minX = frontStudLeftX,
  minY = 0,
  minZ = studBaseZ,
  lengthZ = studHeight,
) // Left jamb stud for the door opening
frontStudRight = twoByFourZRotated(
  minX = frontStudRightX,
  minY = 0,
  minZ = studBaseZ,
  lengthZ = studHeight,
) // Right jamb stud for the door opening


// Dog bone sign centered on the front gable
signTopClearance = 1
signFrontOffset = 0.1
signBottomZ = peakZ - signTopClearance - signHeight
signY = -signThickness - signFrontOffset
frontDogBoneSign = dogBoneSign
  |> translate(x = 0, y = signY, z = signBottomZ)


// Dog House (Great Dane) - Left Wall
// Left wall studs, slats, and side door placement.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and define parameters
import * from "dimensions.kcl"
import * from "2x4.kcl"
import "door.kcl" as door

// Slat sizing and cadence
sideSlatWidth = studDepth
sideSlatGap = 2
sideSlatPitch = sideSlatWidth + sideSlatGap

// Side door placement (left wall)
sideDoorClearance = 0.5
sideDoorPanelWidth = openingWidth - (2 * sideDoorClearance)
sideDoorCenterY = frameLength / 2
sideDoorStartY = sideDoorCenterY - (sideDoorPanelWidth / 2)
sideDoorEndY = sideDoorCenterY + sideDoorPanelWidth / 2
sideDoorX = -frameWidth / 2 - 9
sideDoorY = sideDoorCenterY - frameWidth - (studThickness * 4) - 1

// Top plate along Y at studTopZ
topLeftPlate = twoByFourY(
  minX = -frameWidth / 2,
  minY = 0,
  minZ = studTopZ,
  lengthY = frameLength,
)

// Corner studs (vertical)
frontLeftStud = twoByFourZ(
  minX = -frameWidth / 2,
  minY = 0,
  minZ = studBaseZ,
  lengthZ = studHeight,
)
backLeftStud = twoByFourZ(
  minX = -frameWidth / 2,
  minY = frameLength - studThickness,
  minZ = studBaseZ,
  lengthZ = studHeight,
)

// Side slats with door gap: pattern in front of and behind the opening
sideSlatStartY = studDepth
sideSlatEndY = frameLength - studDepth - sideSlatWidth

fn sideSlatsWithDoor(minX) {
  frontSlatEndY = sideDoorStartY - sideSlatWidth
  frontSlatSpanY = frontSlatEndY - sideSlatStartY
  frontSlatCount = floor(frontSlatSpanY / sideSlatPitch) + 1

  frontSlats = patternLinear3d(
    [
      twoByFourZRotated(
        minX = minX,
        minY = sideSlatStartY,
        minZ = studBaseZ,
        lengthZ = studHeight,
      )
    ],
    axis = [0, 1, 0],
    distance = sideSlatPitch,
    instances = frontSlatCount,
  )

  backSlatStartY = sideDoorEndY + sideSlatGap
  backSlatSpanY = sideSlatEndY - backSlatStartY
  backSlatCount = floor(backSlatSpanY / sideSlatPitch) + 2

  backSlats = patternLinear3d(
    [
      twoByFourZRotated(
        minX = minX,
        minY = backSlatStartY,
        minZ = studBaseZ,
        lengthZ = studHeight,
      )
    ],
    axis = [0, 1, 0],
    distance = sideSlatPitch,
    instances = backSlatCount,
  )

  return [frontSlats, backSlats]
}

leftSlats = sideSlatsWithDoor(minX = -frameWidth / 2)

// Side door module cloned and placed in the wall opening
sideDoorLeft = map(
  door,
  f = fn(@part) {
    return clone(part)
      |> rotate(axis = Z, angle = -90deg)
      |> translate(x = sideDoorX, y = sideDoorY, z = 0)
  },
)


// Dog House (Great Dane) - Right Wall
// Right wall studs, plates, and slats.

// Define units
@settings(experimentalFeatures = allow, defaultLengthUnit = in)

// Import and define parameters
import * from "dimensions.kcl"
import * from "2x4.kcl"

// Side slat spacing
sideSlatWidth = studDepth
sideSlatGap = 2
sideSlatPitch = sideSlatWidth + sideSlatGap

// Right wall plates
// Continuous top plate along Y at studTopZ
topRightPlate = twoByFourY(
  minX = frameWidth / 2 - studDepth,
  minY = 0,
  minZ = studTopZ,
  lengthY = frameLength,
)

// Right wall corner studs
frontRightStud = twoByFourZ(
  minX = frameWidth / 2 - studDepth,
  minY = 0,
  minZ = studBaseZ,
  lengthZ = studHeight,
) // Front corner
backRightStud = twoByFourZ(
  minX = frameWidth / 2 - studDepth,
  minY = frameLength - studThickness,
  minZ = studBaseZ,
  lengthZ = studHeight,
) // Rear corner


// Side slats (vertical)
// Single slat geometry then patterned along Y to fill the wall bay
sideSlatStartY = studDepth
sideSlatEndY = frameLength - studDepth - sideSlatWidth
sideSlatSpanY = sideSlatEndY - sideSlatStartY
sideSlatCount = floor(sideSlatSpanY / sideSlatPitch) + 1
sideSlatActualPitch = sideSlatSpanY / (sideSlatCount - 1)

fn sideSlats(minX) {
  return patternLinear3d(
    [
      twoByFourZRotated(
        minX = minX,
        minY = sideSlatStartY,
        minZ = studBaseZ,
        lengthZ = studHeight,
      )
    ],
    axis = [0, 1, 0],
    distance = sideSlatActualPitch,
    instances = sideSlatCount,
  ) // Replicate the vertical slat along Y with computed pitch
}

rightSlats = sideSlats(minX = frameWidth / 2 - studThickness)


// Dog House (Great Dane) - Roof
// Roof rafters and slats for the dog house.

@settings(experimentalFeatures = allow, defaultLengthUnit = in)

import * from "dimensions.kcl"
import * from "2x4.kcl"

// Side slat spacing (match wall cadence for rafters)
sideSlatWidth = studDepth
sideSlatGap = 2
sideSlatPitch = sideSlatWidth + sideSlatGap
sideSlatStartY = studDepth
sideSlatEndY = frameLength - studDepth - sideSlatWidth
sideSlatSpanY = sideSlatEndY - sideSlatStartY
sideSlatCount = floor(sideSlatSpanY / sideSlatPitch) + 1
sideSlatActualPitch = sideSlatSpanY / (sideSlatCount - 1)

// Roof framing
roofHalfWidth = frameWidth / 2
roofAngle = atan(roofRise / roofHalfWidth)
rafterLength = sqrt(roofHalfWidth * roofHalfWidth + roofRise * roofRise)
rafterThickness = studThickness
rafterWidth = studDepth
rafterMidZ = (peakZ + eaveZ) / 2
ridgeBoardZ = peakZ - studDepth

rafterStartY = sideSlatStartY + (sideSlatWidth - rafterWidth) / 2
rafterEndY = frameLength - studDepth - rafterWidth
rafterSpanY = rafterEndY - rafterStartY
rafterCount = sideSlatCount
rafterSpacing = sideSlatActualPitch

// Collar ties (brace rafters together to reduce ridge load)
collarTieHeightFactor = 0.5
collarTieCenterZ = eaveZ + roofRise * collarTieHeightFactor
collarTieHalfWidth = roofHalfWidth * (peakZ - collarTieCenterZ) / (peakZ - eaveZ) - (studThickness / 2)
collarTieLength = 2 * collarTieHalfWidth
collarTieMinZ = collarTieCenterZ - (studThickness / 2)

// Import upper side wall beams as reference geometry
topRightPlate = twoByFourY(
  minX = frameWidth / 2 - studDepth,
  minY = 0,
  minZ = studTopZ,
  lengthY = frameLength,
)

topLeftPlate = twoByFourY(
  minX = -frameWidth / 2,
  minY = 0,
  minZ = studTopZ,
  lengthY = frameLength,
)

// Create half-width rafter beams to make slot cuts
rightRafterhalf = twoByFourX(
       minX = -rafterLength / 2 - 3,
       minY = rafterStartY,
       minZ = -rafterThickness / 2,
       lengthX = rafterLength + 3,
     )
  |> rotate(axis = [0, 1, 0], angle = -roofAngle)
  |> translate(x = roofHalfWidth / 2, y = 3.5 / 2, z = rafterMidZ)
  |> scale(x = 1.025, z = 1.025, global = false)

leftRafterHalf = twoByFourX(
       minX = -rafterLength / 2,
       minY = rafterStartY,
       minZ = -rafterThickness / 2,
       lengthX = rafterLength + 3,
     )
  |> rotate(axis = [0, 1, 0], angle = roofAngle)
  |> translate(x = -roofHalfWidth / 2, y = -3.5 / 2, z = rafterMidZ)
  |> scale(x = 1.025, z = 1.025, global = false)

// Model the left and right rafters. Subtract interface to mesh with other beams
rightRafter = twoByFourX(
       minX = -rafterLength / 2 - 3,
       minY = rafterStartY,
       minZ = -rafterThickness / 2,
       lengthX = rafterLength + 3,
     )
  |> rotate(axis = [0, 1, 0], angle = -roofAngle)
  |> translate(x = roofHalfWidth / 2, y = 0, z = rafterMidZ)
  |> subtract(tools = leftRafterHalf)
  |> subtract(tools = topLeftPlate)

leftRafter = twoByFourX(
       minX = -rafterLength / 2,
       minY = rafterStartY,
       minZ = -rafterThickness / 2,
       lengthX = rafterLength + 3,
     )
  |> rotate(axis = [0, 1, 0], angle = roofAngle)
  |> translate(x = -roofHalfWidth / 2, y = 0, z = rafterMidZ)
  |> subtract(tools = rightRafterhalf)
  |> subtract(tools = topRightPlate)

// Create the center collar tie
collarTie = twoByFourX(
       minX = -collarTieHalfWidth + 2.25,
       minY = rafterStartY,
       minZ = collarTieMinZ + 0.5,
       lengthX = collarTieLength - 4.5,
     )
  |> subtract(tools = [clone(leftRafter), clone(rightRafter)])

// Pattern the roof beams the length of the roof
rightRafters = patternLinear3d(
  [rightRafter],
  axis = [0, 1, 0],
  distance = rafterSpacing,
  instances = rafterCount,
)

leftRafters = patternLinear3d(
  [leftRafter],
  axis = [0, 1, 0],
  distance = rafterSpacing,
  instances = rafterCount,
)

collarTies = patternLinear3d(
  [collarTie],
  axis = [0, 1, 0],
  distance = rafterSpacing,
  instances = rafterCount,
)

// Model a ridgeboard to hold it all together
ridgeBoardSlots = startSketchOn(YZ)
  |> startProfile(at = [
       rafterStartY - 0.025,
       ridgeBoardZ + 3.75
     ])
  |> yLine(length = -3.16)
  |> xLine(length = 3.55)
  |> yLine(length = 3.18)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()
  |> extrude(length = 5, symmetric = true)
  |> patternLinear3d(instances = rafterCount, distance = rafterSpacing, axis = [0, 1, 0])

ridgeBoard = twoByFourYRotated(
       minX = -studThickness / 2,
       minY = 0,
       minZ = ridgeBoardZ + 1,
       lengthY = frameLength,
     )
  |> subtract(tools = ridgeBoardSlots)

// Apply wooden appearance
[
       rightRafters,
       leftRafters,
       collarTies,
       ridgeBoard
     ]
  |> appearance(color = woodColor, roughness = woodRoughness, metalness = woodMetalness)


dog-house-great-dane

KCL