nodarium_utils 0.1.0

A collection of utilities for Nodarium
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

use super::{create_geometry_data, wrap_geometry_data, PathData};
use glam::{Mat4, Vec3};

fn create_circle(res: usize) -> Vec<f32> {
    let angle = (2.0 * std::f32::consts::PI) / res as f32;
    let mut circle = Vec::new();
    for i in 0..res {
        circle.push((angle * i as f32).cos());
        circle.push((angle * i as f32).sin());
    }
    circle
}

pub fn extrude_path(input_path: PathData, res_x: usize) -> Vec<i32> {
    let point_amount = input_path.points.len() / 4;
    let face_amount = (point_amount - 1) * res_x * 2;
    let vertices_amount = point_amount * res_x;

    let circle = create_circle(res_x);

    let mut geometry_data = create_geometry_data(vertices_amount, face_amount);

    let geometry = wrap_geometry_data(&mut geometry_data);

    let normals = geometry.normals;
    let positions = geometry.positions;
    let indices = geometry.faces;

    let path: &[f32] = input_path.points;

    for i in 0..input_path.length {
        let index_offset = i * res_x * 6;
        let position_offset = i * res_x;

        let pos = Vec3::new(path[i * 4], path[i * 4 + 1], path[i * 4 + 2]);
        let thickness = path[i * 4 + 3].max(0.000001);

        // Get direction of the current segment
        let segment_dir = (if i == 0 {
            Vec3::new(
                pos[0] - path[i * 4 + 4],
                pos[1] - path[i * 4 + 5],
                pos[2] - path[i * 4 + 6],
            )
        } else if i == point_amount - 1 {
            Vec3::new(
                path[i * 4 - 4] - pos[0],
                path[i * 4 - 3] - pos[1],
                path[i * 4 - 2] - pos[2],
            )
        } else {
            Vec3::new(
                path[i * 4 - 4] - path[i * 4 + 4],
                path[i * 4 - 3] - path[i * 4 + 5],
                path[i * 4 - 2] - path[i * 4 + 6],
            )
        })
        .normalize();

        // In our case the up vector is always the Y axis
        let up_vector = Vec3::NEG_Y;

        let binormal = up_vector.cross(segment_dir);

        let rotation_angle = up_vector.dot(segment_dir).acos();

        let rotation_matrix = Mat4::from_axis_angle(binormal, rotation_angle);

        for j in 0..res_x {
            if i < point_amount - 1 {
                let i_index_offset = index_offset + j * 6;
                let i_position_offset = position_offset + j;

                //log!("i: {}, j: {}, i_index_offset: {}, i_position_offset: {} res_x: {}", i, j, i_index_offset, i_position_offset,res_x);

                if j == res_x - 1 {
                    indices[i_index_offset] = (i_position_offset + 1) as i32;
                    indices[i_index_offset + 1] = (i_position_offset + 1 - res_x) as i32;
                    indices[i_index_offset + 2] = (i_position_offset) as i32;

                    indices[i_index_offset + 3] = (i_position_offset) as i32;
                    indices[i_index_offset + 4] = (i_position_offset + res_x) as i32;
                    indices[i_index_offset + 5] = (i_position_offset + 1) as i32;
                } else {
                    indices[i_index_offset] = (i_position_offset + res_x + 1) as i32;
                    indices[i_index_offset + 1] = (i_position_offset + 1) as i32;
                    indices[i_index_offset + 2] = (i_position_offset) as i32;

                    indices[i_index_offset + 3] = (i_position_offset) as i32;
                    indices[i_index_offset + 4] = (i_position_offset + res_x) as i32;
                    indices[i_index_offset + 5] = (i_position_offset + res_x + 1) as i32;
                }
            }

            // construct the points
            let idx = i * res_x * 3 + j * 3;

            let circle_x = circle[j * 2] * thickness;
            let circle_z = circle[j * 2 + 1] * thickness;

            let point = rotation_matrix.transform_point3(Vec3::new(circle_x, 0.0, circle_z)) + pos;
            let normal = rotation_matrix
                .transform_vector3(Vec3::new(circle_x, 0.0, circle_z))
                .normalize();

            normals[idx] = normal[0];
            normals[idx + 1] = normal[1];
            normals[idx + 2] = normal[2];

            positions[idx] = point[0];
            positions[idx + 1] = point[1];
            positions[idx + 2] = point[2];
        }
    }

    geometry_data
}