mini-itx.openscad

mb = [170.3, 170.3, 2];
psu = [40.5, 151.5, 82.5];
mb_right_space = 11;
duct = [120, 130, 30];
duct_offset = 20;
fan_height = 30;
fan_size = 100;
case_thick = 3;

pcie_lp_bracket_height = 80;
pcie_lp_z_clearance = 66;

mb_bottom_space = pcie_lp_bracket_height - pcie_lp_z_clearance - mb.z;
ceiling = psu.z - mb_bottom_space;
case_corner_radius = 15;

block_size = 5;
outer_space = 200;

case = [case_thick * 2 + psu.x + mb.x + mb_right_space, case_corner_radius * 2 + mb.y, case_thick * 2 + mb_bottom_space + ceiling];

// bottom
if (1) {
    difference () {
        outer_cube();
        // inner
        translate([-outer_space, -case_corner_radius, -mb_bottom_space])
            cube([outer_space * 2, case_corner_radius + mb.y, outer_space]);
        // extrude case rounding
        translate([-(case_thick + psu.x - case_corner_radius), mb.y, -mb_bottom_space])
            cube([case.x - case_corner_radius * 2, case_corner_radius - case_thick, outer_space]);
        // cut sides
        translate([-(case_thick + psu.x), -outer_space, -(mb_bottom_space + case_thick)])
            cube([case_thick, outer_space + mb.y, case_thick]);
        translate([mb.x + mb_right_space, -outer_space, -(mb_bottom_space + case_thick)])
            cube([case_thick, outer_space + mb.y, case_thick]);
        // cut top
        translate([-outer_space, 0, ceiling])
            cube([outer_space * 2, outer_space, outer_space]);
    }    

    // reinforce bottom
    union () {
        translate([0, 0, -mb_bottom_space])
            cube_with_holder(mb.x, block_size, case_thick, 2);
        translate([0, 0, -mb_bottom_space])
            cube([block_size, mb.y, case_thick]);
        translate([mb.x - block_size, 0, -mb_bottom_space])
            cube([block_size, mb.y, case_thick]);
    }

    // mb holder 1
    translate([0, 0, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space, 2);

    // mb holder 2
    difference () {
        translate([-block_size, mb.y - block_size, -mb_bottom_space])
            cube([block_size * 2, block_size + case_corner_radius, mb_bottom_space + mb.z + block_size]);
        translate([0, mb.y - block_size, 0])
            cube([block_size, block_size, mb.z]);
    }

    // mb holder 3
    translate([mb.x - block_size, 0, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space, 2);
    translate([mb.x, 0, -mb_bottom_space])
        cube_with_holder(block_size, block_size, mb_bottom_space + block_size, 2);

    // mb holder 4
    difference () {
        translate([mb.x - block_size, mb.y - block_size, -mb_bottom_space])
            cube([block_size * 2, block_size + case_corner_radius - case_thick, mb_bottom_space + mb.z + block_size]);
        translate([mb.x - block_size, mb.y - block_size, 0])
            cube([block_size, block_size, mb.z]);
    }


    psu_holders(-mb_bottom_space, 2);

    // backpanel holders
    translate([0, -(case_thick * 2), -mb_bottom_space])
        cube([block_size, case_thick, case_thick]);
    translate([mb.x - block_size, -(case_thick * 2), -mb_bottom_space])
        cube([block_size, case_thick, case_thick]);
}

// top
if (1) {
    translate([-130, 0, 50]) rotate([0, 180, 0]) {
        // top and side panels
        difference () {
            outer_cube();
            translate([-psu.x, -outer_space, -outer_space])
                cube([psu.x + mb.x + mb_right_space, outer_space * 2, outer_space + ceiling]);
            translate([-outer_space, mb.y, -outer_space])
                cube([outer_space - psu.x, outer_space, outer_space + ceiling]);
            translate([mb.x, mb.y, -outer_space])
                cube([outer_space, outer_space, outer_space + ceiling]);
            // holes in side panel
            translate([mb.x - 100, 20, -mb_bottom_space / 2])
                rotate([90, 0, 90])
                    punch_honeycomb(8, 5, 200);
        }

        // duct
        translate([duct_offset, -case_corner_radius, ceiling - duct.z]) {
            difference () {
                d = case_corner_radius + duct.y;
                union () {
                    cube([duct.x, d, duct.z]);
                    translate([0, d - (fan_size + case_thick), fan_height - (ceiling - duct.z)])
                        cube_with_holder(duct.x, fan_size + case_thick, ceiling - fan_height, 4);
                }
                translate([case_thick, d, fan_height - (ceiling - duct.z) + case_thick])
                    cube_with_holder(duct.x - case_thick * 2, 0, ceiling - fan_height - case_thick, 4);
                translate([case_thick, 0, case_thick])
                    cube([duct.x - case_thick * 2, d, duct.z * case_thick * 2]);
                translate([(duct.x - fan_size) / 2, duct.y - fan_size + case_corner_radius, -outer_space])
                    cube([fan_size, fan_size, outer_space * 2]);
                translate([(duct.x - fan_size) / 2, duct.y - fan_size + case_corner_radius - case_thick, fan_height - (ceiling - duct.z)])
                    cube([fan_size, case_thick, case_thick]);
            }
        }

        // mb holder 3
        translate([mb.x - block_size, 0, mb.z])
            cube_with_holder(block_size + mb_right_space + case_thick, block_size + 1, block_size, 3);
    
        // psu holders
        psu_holders(ceiling - case_thick, 4);

        // backpanel holders
        translate([0, -(case_thick * 2), ceiling - case_thick])
            cube([block_size, case_thick, case_thick]);
        translate([0, 0, ceiling - case_thick])
            cube([block_size, case_thick, case_thick]);
        translate([mb.x - block_size, -(case_thick * 2), ceiling - case_thick])
            cube([block_size, case_thick, case_thick]);
        translate([mb.x - block_size, 0, ceiling - case_thick])
            cube([block_size, case_thick, case_thick]);

        // ratch
        translate([-(case_thick + psu.x), 0, -(case_thick * 2 + mb_bottom_space)])
            cube([case_thick * 2, mb.y, case_thick]);
        translate([mb.x + mb_right_space - case_thick, 0, -(case_thick * 2 + mb_bottom_space)])
            cube([case_thick * 2, mb.y, case_thick]);
    }
}

module outer_cube() {
    translate([-(case_thick + psu.x), -case_corner_radius, -(case_thick + mb_bottom_space)])
        linear_extrude(height = case.z)
            round_rect(case.x, case.y, case_corner_radius);
}

module round_rect(w, d, r) {
    union () {
        translate([0, r])
            square([w, d - r * 2]);
        translate([r, 0])
            square([w - r * 2, d]);
        translate([r, r])
            circle(r, $fn = 32);
        translate([w - r, r])
            circle(r, $fn = 32);
        translate([r, d - r])
            circle(r, $fn = 32);
        translate([w - r, d - r])
            circle(r, $fn = 32);
    }
}

module psu_holders(z, holder_side) {
    translate([-psu.x, -case_thick * 2, z])
        cube([case_thick, case_thick * 2, case_thick]);
    translate([-case_thick, -case_thick * 2, z])
        cube([case_thick, case_thick * 2, case_thick]);
    translate([-psu.x, psu.y, z])
        cube_with_holder(block_size, block_size, case_thick, holder_side);
    translate([-block_size, psu.y, z])
        cube_with_holder(block_size, block_size, case_thick, holder_side);
}

module cube_with_holder(w, d, h, holder_side) {
    cube([w, d, h]);
    translate([0, d, 0]) {
        if (holder_side == 1) {
            linear_extrude(height = h)
                polygon(points = [[0, 0], [0, w], [w, 0]]);
        } else if (holder_side == 2) {
            translate([w, 0, 0])
                rotate([0, -90, 0])
                    linear_extrude(height = w)
                        polygon(points = [[0, 0], [0, h], [h, 0]]);
        } else if (holder_side == 3) {
            linear_extrude(height = h)
                polygon(points = [[0, 0], [w, 0], [w, w]]);
        } else {
            translate([0, 0, h])
                rotate([0, 90, 0])
                    linear_extrude(height = w)
                        polygon(points = [[0, 0], [0, h], [h, 0]]);
        }
    }
}

module corner_cube4(w, d, r, h, needs_holder) {
    if (needs_holder != 0) {
        cube_with_holder(r, r, h, 1);
        translate([w - r, 0])
            cube_with_holder(r, r, h, 3);
    } else {
        cube([r, r, h]);
        translate([w - r, 0])
            cube([r, r, h]);
    }
    translate([0, d - r])
        cube([r, r, h]);
    translate([w - r, d - r])
        cube([r, r, h]);
}

module punch_honeycomb(w, d, h) {
    hex_size = 10;
    for (x = [0 : w - 1]) {
        for (y = [0 : d - 1]) {
            translate([x * hex_size * sqrt(3), hex_size + y * hex_size, 0])
                cylinder(h = h, r = hex_size * 0.45, $fn = 6);
            translate([(x * 2 + 1) * hex_size / 2 * sqrt(3), 1.5 * hex_size + y * hex_size, 0])
                cylinder(h = h, r = hex_size * 0.45, $fn  = 6);
        }
    }
}