hyperwood-bench 0.1.4

Our simplistic yet elegant bench is the first-ever Hyperwood design, embodying the project's essence of simplicity, functionality, and aesthetic clarity.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use hyperwood::{Model, Point, Slat, Variant, Vector};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Default)]
pub struct BenchParameters {
    width: isize,
    depth: isize,
    height: isize,
}

impl BenchParameters {
    pub fn new(width: isize, depth: isize, height: isize) -> Self {
        assert!(depth % 2 != 0, "Depth must be uneval");
        assert!(depth >= 9, "Depth must be equal or greater than 9");

        Self {
            width,
            depth,
            height,
        }
    }
}

#[derive(Serialize, Deserialize, Default)]
pub struct BenchProperties {
    width: f32,
    depth: f32,
    height: f32,
}

/// Generate a model from given parameters and variant.
pub fn build_model(
    parameters: BenchParameters,
    variant: Variant,
) -> Model<BenchParameters, BenchProperties> {
    let middle = parameters.depth / 2;
    let distance_leg_to_edge = 3;

    let mut slats = vec![];

    // keel
    slats.push(Slat {
        name: "Keel".to_string(),
        layer: middle,
        origin: Point {
            x: distance_leg_to_edge as f32,
            y: middle as f32,
            z: 1.0,
        },
        vector: Vector {
            x: parameters.width as f32 - 2.0 * distance_leg_to_edge as f32,
            y: 0.0,
            z: 0.0,
        },
    });

    // seat
    for y in 0..parameters.depth {
        if y % 2 == 0 {
            slats.push(Slat {
                name: "Seat".to_string(),
                layer: y,
                origin: Point {
                    x: 0.0,
                    y: y as f32,
                    z: parameters.height as f32,
                },
                vector: Vector {
                    x: parameters.width as f32,
                    y: 0.0,
                    z: 0.0,
                },
            });
        }
    }

    // shelf
    for y in 1..parameters.depth - 1 {
        if y % 2 == 0 {
            slats.push(Slat {
                name: "Shelf".to_string(),
                layer: y,
                origin: Point {
                    x: distance_leg_to_edge as f32 - 1.0,
                    y: y as f32,
                    z: 2.0,
                },
                vector: Vector {
                    x: parameters.width as f32 - 2.0 * distance_leg_to_edge as f32 + 2.0,
                    y: 0.0,
                    z: 0.0,
                },
            });
        }
    }

    // legs
    for y in 0..parameters.depth {
        if y % 2 != 0 {
            // outer legs reach the floor
            let z = match y == 1 || y == parameters.depth - 2 {
                true => 0.0,
                // or surround the keel
                false => match y == middle + 1 || y == middle - 1 {
                    true => 1.0,
                    // or otherwise end at the shelf
                    false => 2.0,
                },
            };

            // left
            slats.push(Slat {
                name: "Leg".to_string(),
                layer: y,
                origin: Point {
                    x: distance_leg_to_edge as f32,
                    y: y as f32,
                    z,
                },
                vector: Vector {
                    x: 0.0,
                    y: 0.0,
                    z: parameters.height as f32 - z,
                },
            });

            // right
            slats.push(Slat {
                name: "Leg".to_string(),
                layer: y,
                origin: Point {
                    x: parameters.width as f32 - distance_leg_to_edge as f32,
                    y: y as f32,
                    z,
                },
                vector: Vector {
                    x: 0.0,
                    y: 0.0,
                    z: parameters.height as f32 - z,
                },
            });
        }
    }

    let properties = BenchProperties {
        width: parameters.width as f32 * variant.x,
        depth: parameters.depth as f32 * variant.y,
        height: parameters.height as f32 * variant.z,
    };

    Model {
        parameters,
        properties,
        name: "Bench".to_owned(),
        variant,
        slats,
    }
}