Skadis Peg Board - 3D CAD Model

3D Model Components

• Blueprint Root script — Position: [0.0, 0.0, 5.8]
  • Reference Image image — Position: [68.4, 26.9, -5.9]

Blueprint Script (TypeScript)

const PARAMS = {
    dim: 'disabled',
    rows: 5,
    columns: 4,
    depth: 5,
}

function createHalfCylinder(height: number, radius: number) {
    const diameter = radius * 2
    const capCutoff = Manifold.cube(diameter, true).translate([-radius, 0, 0])
    const fullCylinder = Manifold.cylinder(height, radius)
    const halfCylinder = fullCylinder.subtract(capCutoff)
    return halfCylinder
}

function createExtrudedPill(height: number, diameter: number, l: number) {
    const radius = diameter / 2

    const middleCube = Manifold.cube([l - diameter, diameter, height], true)

    let halfCylinderA = createHalfCylinder(height, radius).translate([
        l / 2 - radius,
        0,
        -height / 2,
    ])

    let halfCylinderB = createHalfCylinder(height, radius)
        .rotate([0, 0, 180])
        .translate([-l / 2 + radius, 0, -height / 2])
    return middleCube.add(halfCylinderA.add(halfCylinderB))
}

function createSkadisHole() {
    return createExtrudedPill(20, 5, 15)
}

function createSkadisBoard(rows: number, columns: number) {
    const SKADIS_DATA = {
        marginX: 17.5,
        marginY: 12.5,
        columnOffset: 25,
        rowOffset: 35,
        holeWidth: 5,
        holeHeight: 15,
        depth: PARAMS.depth,
    }

    function createPeg(x: number, y: number) {
        let w = Manifold.cube([1, 1, 33], true)
        w = w.translate([x, y, 0])
        return w
    }

    let start = createPeg(0, 0)

    let bX = 0
    let bY = 0

    for (let y = 0; y < rows; y++) {
        /**
         * start each row on or off for the offset pattern
         */
        let renderCurrent = y % 2 == 0

        let oY = y * SKADIS_DATA.holeHeight * 1.3
        for (let x = 0; x < columns; x++) {
            let oX = x * 19.5

            if (renderCurrent) {
                let a = createSkadisHole()
                    .rotate([0, 0, 90])
                    // hopefully make it easier to handle to set its origin to its
                    // top left coner so to say
                    .translate([SKADIS_DATA.holeWidth / 2, SKADIS_DATA.holeHeight / 2, 0])
                a = a.translate([oX, oY, 0])
                start = start.add(a)

                if (oX > bX) {
                    bX = oX
                }
                if (oY > bY) {
                    bY = oY
                }
            }
            renderCurrent = !renderCurrent
            // x % 2 == 0  y % 2 == 1
            if (rows % 2 === 1 && x % 2 == 1) {
                // renderCurrent = !renderCurrent
            }
        }
    }

    let m = createPeg(bX, bY)
    let baseWH: number[] = [
        bX + SKADIS_DATA.holeWidth + SKADIS_DATA.marginX * 2,
        bY + SKADIS_DATA.holeHeight + SKADIS_DATA.marginY * 2,
        SKADIS_DATA.depth,
    ]

    let result = Manifold.cube(baseWH, true).translate([
        baseWH[0] / 2 - SKADIS_DATA.marginX,
        baseWH[1] / 2 - SKADIS_DATA.marginY,
        0,
    ])

    //start = start.add(m)
    return result.subtract(start)
}

return { result: createSkadisBoard(PARAMS.rows, PARAMS.columns), PARAMS }