cx-module-wall/assets/platform.scad

include <../config/platform.scad>
include <../config/thread.scad>
include <corner.scad>
include <wall.scad>

function platform_full_support_depth() 
    = platform_support_depth
    + thread_height
    + platform_thickness;

function platform_top_width()
    = platform_width
    - corner_radius * 2;

function platform_side_width() 
    = platform_height
    - corner_radius * 2;

function platform_connector_holes() = [
    0,
    platform_depth / 2 - corner_radius,
    platform_depth / 4 - corner_radius,
    -platform_depth / 4 - corner_radius
];

function platform_connector_space() 
    = thread_top_diameter
    + platform_thickness;

module platform_connector_hole(move_x, move_y, thickness = 0) { 
    translate([move_x, move_y]) {
        if (thickness == 0) {
            circle(r = thread_screw / 2);
        } else {
            cylinder(r = thread_screw / 2, h = thickness, center = true);
        }
    }
}

module platform_side_holes(thread = false) {
    move_x
    = platform_side_width() / 2
    - corner_radius
    - thread_screw;

    move_top_y
    = platform_full_support_depth() / 2
    - thread_screw;

    move_bottom_y
    = thread_top_diameter / 2
    - move_top_y;

    module thread(move_x, move_y) {
        translate([move_x, move_y]) {
            thread_object(false, platform_thickness);
        }
    }

    module screw(move_x, move_y) {
        translate([move_x, move_y]) {
            thread_screw_object(thread_height);
        }
    }
    
    if (thread) {
        screw(move_x, move_top_y);
        screw(0, move_top_y);
        thread(move_x, move_bottom_y);
        thread(-move_x, move_bottom_y);
    } else {
        thread_screw_hole(move_x, move_top_y); 
        thread_screw_hole(0, move_top_y);
        thread_screw_hole(move_x, move_bottom_y); 
        thread_screw_hole(-move_x, move_bottom_y);
    }

}

module platform_top_holes(thread = false) {
    move_x
    = platform_top_width() / 2
    - corner_radius
    - thread_screw;

    move_top_y
    = platform_full_support_depth() / 2
    - thread_screw;

    move_bottom_y
    = thread_top_diameter / 2
    - move_top_y;

    module thread(move_x, move_y) {
        translate([move_x, move_y]) {
            thread_object(false, platform_thickness);
        }
    }

    module screw(move_x, move_y) {
        translate([move_x, move_y]) {
            thread_screw_object(thread_height);
        }
    }
    
    if (thread) {
        screw(move_x, move_top_y);
        screw(-move_x, move_top_y);
        thread(move_x, move_bottom_y);
        thread(-move_x, move_bottom_y);
    } else {
        thread_screw_hole(move_x, move_top_y); 
        thread_screw_hole(-move_x, move_top_y);
        thread_screw_hole(move_x, move_bottom_y); 
        thread_screw_hole(-move_x, move_bottom_y); 
    }
}

module platform_mount_object() {
    rounding = corner_radius;

    holes_width 
    = platform_width 
    - rounding * 2 
    - thread_screw * 2
    - platform_side_thickness * 2;

    holes_height 
    = platform_height 
    - rounding * 2 
    - thread_screw * 2
    - platform_side_thickness;

    module base_shape() {
        move_x = platform_width / 2 - rounding;
        move_y = platform_height / 2 - rounding;
        
        hull() {
            corner(move_x, move_y); 
            corner(-move_x, move_y); 
            corner(move_x, -move_y); 
            corner(-move_x, -move_y); 
        }
    }
    
    base_thickness
    = platform_thickness
    + thread_height;

    module base_object() {
        linear_extrude(height = base_thickness, center = true) {
            base_shape();
        }
    }

    module bottom_object() {
        center = base_thickness / 2 - thread_height / 2;

        render() {
            difference() {
                base_object();
                
                translate([0, 0, center]) {
                    rotate([180, 0, 0]) {
                        width = holes_width;
                        height = holes_height;
                        thickness = platform_thickness;

                        wall_thread_object(width, height, thickness);
                    }
                }
            }
        }
    }

    module side_shape() {
        module cutout_shape() {
            move_x 
            = platform_width / 2 
            - platform_side_thickness
            - rounding;

            move_top_y 
            = platform_height / 2 
            - platform_side_thickness
            - rounding;
            
            move_bottom_y 
            = -platform_height / 2
            + rounding;

            hull() {
                corner(move_x, move_top_y);
                corner(-move_x, move_top_y);
                corner(move_x, move_bottom_y, false);
                corner(-move_x, move_bottom_y, false);
            }
        }

        module bottom_cutout_shape() {
            bottom
            = rounding / 2
            - platform_height / 2;
            
            translate([0, bottom]) {
                square([platform_width, rounding], center = true);
            }
        }

        render() {
            difference() {
                base_shape();
                cutout_shape();
                bottom_cutout_shape();
            }
        }
    }

    module side_object() {
        thickness = platform_support_depth;

        linear_extrude(height = thickness, center = true) {
            side_shape();
        }
    }

    bottom_center 
    = thread_height / 2
    + platform_thickness / 2
    - platform_full_support_depth() / 2;

    side_center 
    = platform_support_depth / 2
    + thread_height
    + platform_thickness
    - platform_full_support_depth() / 2;

    module layer_base_object() {
        translate([0, 0, bottom_center]) {
            bottom_object();
        }

        translate([0, 0, side_center]) {
            side_object();
        }
    }

    module top_holes() {
        center_y 
        = platform_height / 2
        - thread_height / 2;
        
        translate([0, center_y, 0]) {
            rotate([90, 0, 0]) {
                platform_top_holes(true);
            }
        }
    }

    module left_holes() {
        center_x 
        = platform_width / 2
        - thread_height / 2;

        translate([center_x, 0, 0]) {
            mirror([0, 1, 0]) {
                rotate([90, 0, 270]) {
                    platform_side_holes(true);
                }
            }
        }
    }

    module right_holes() {
        center_x 
        = thread_height / 2
        - platform_width / 2;

        translate([center_x, 0, 0]) {
            rotate([90, 0, 90]) {
                platform_side_holes(true);
            }
        }
    }

    render() {
        difference() {
            layer_base_object();
            top_holes();
            left_holes();
            right_holes();
        }
    }
}

module platform_top_shape() {
    move_x 
    = platform_top_width() / 2 
    - corner_radius;

    move_y
    = platform_depth / 2
    - corner_radius;

    module base_shape() {
        hull() {
            corner(move_x, move_y);
            corner(-move_x, move_y);
            corner(move_x, -move_y);
            corner(-move_x, -move_y);
        }
    }

    holes_y
    = platform_full_support_depth() / 2
    - platform_depth / 2;

    module connector_holes() {
        for (count = platform_connector_holes()) {
            move
            = count
            - platform_connector_space();

            platform_connector_hole(move_x, move);
            platform_connector_hole(-move_x, move);
        }
    }

    difference() {
        base_shape();

        connector_holes();

        translate([0, holes_y]) {
            platform_top_holes();
        }
    }
}

module platform_top_object() {
    height = platform_thickness;
    
    color("#9711EE") {
        render() {
            linear_extrude(height = height, center = true) {
                platform_top_shape();
            }
        }
    }
}

module platform_side_shape() {
    move_x
    = platform_side_width() / 2
    - corner_radius;

    move_y 
    = platform_depth / 2
    - corner_radius;

    module base_shape() {
        hull() {
            corner(0, -move_y / 1.5);
            corner(move_x, -move_y / 1.5);
            corner(move_x, -move_y);
            corner(-move_x, -move_y);
        }

        hull() {
            corner(0, -move_y / 1.5);
            corner(move_x, -move_y / 1.5);
            corner(move_x, move_y);
        }
    }

    support_holes_y
    = platform_full_support_depth() / 2
    - platform_depth / 2;

    module connector_holes() {
        for (count = platform_connector_holes()) {
            platform_connector_hole(move_x, count);
        }
    }

    difference() {
        base_shape();

        connector_holes();

        translate([0, support_holes_y]) {
            platform_side_holes();
        }
    }
}

module platform_side_object() {
    height = platform_thickness;

    color("#DA25B3") {
        render() {
            linear_extrude(height = height, center = true) {
                platform_side_shape();
            }
        }
    }
}

module platform_connector() {
    size = platform_connector_space();
    cube(size, center = true);
}