procedural_modelling 0.4.2

A framework-agnostic Procedural Modelling crate.
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

use super::mat5::{Mat5, Vec4Rotator};
use crate::math::{HasZero, Scalar, TransformTrait, Transformable, Vector, Vector4D};
use bevy::math::Vec4;

impl HasZero for Vec4 {
    #[inline(always)]
    fn zero() -> Self {
        Vec4::ZERO
    }

    #[inline(always)]
    fn is_zero(&self) -> bool {
        *self == Vec4::ZERO
    }
}

impl Vector<f32, 4> for Vec4 {
    #[inline(always)]
    fn distance(&self, other: &Self) -> f32 {
        Vec4::distance(*self, *other)
    }

    #[inline(always)]
    fn distance_squared(&self, other: &Self) -> f32 {
        Vec4::distance_squared(*self, *other)
    }

    #[inline(always)]
    fn length(&self) -> f32 {
        Vec4::length(*self)
    }

    #[inline(always)]
    fn length_squared(&self) -> f32 {
        Vec4::length_squared(*self)
    }

    #[inline(always)]
    fn dot(&self, other: &Self) -> f32 {
        Vec4::dot(*self, *other)
    }

    #[inline(always)]
    fn x(&self) -> f32 {
        self.x
    }

    #[inline(always)]
    fn y(&self) -> f32 {
        self.y
    }

    #[inline(always)]
    fn z(&self) -> f32 {
        self.z
    }

    #[inline(always)]
    fn w(&self) -> f32 {
        self.w
    }

    #[inline(always)]
    fn normalize(&self) -> Self {
        Vec4::normalize(*self)
    }

    #[inline(always)]
    fn splat(value: f32) -> Self {
        Vec4::splat(value)
    }

    #[inline(always)]
    fn from_x(x: f32) -> Self {
        Vec4::new(x, 0.0, 0.0, 0.0)
    }

    #[inline(always)]
    fn from_xy(x: f32, y: f32) -> Self {
        Vec4::new(x, y, 0.0, 0.0)
    }

    #[inline(always)]
    fn from_xyz(x: f32, y: f32, z: f32) -> Self {
        Vec4::new(x, y, z, 0.0)
    }

    #[inline(always)]
    fn is_about(&self, other: &Self, epsilon: f32) -> bool {
        self.x.is_about(other.x, epsilon)
            && self.y.is_about(other.y, epsilon)
            && self.z.is_about(other.z, epsilon)
            && self.w.is_about(other.w, epsilon)
    }
}

impl Vector4D for Vec4 {
    type S = f32;

    #[inline(always)]
    fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
        Vec4::new(x, y, z, w)
    }
}

// TODO: implement more methods to improve performance
impl Transformable<4> for Vec4 {
    type Rot = Vec4Rotator;
    type S = f32;
    type Trans = Mat5<f32>;
    type Vec = Vec4;

    fn transform(&mut self, t: &Self::Trans) -> &mut Self {
        *self = t.apply(*self);
        self
    }

    fn lerp(&mut self, other: &Self, t: Self::S) -> &mut Self {
        *self = Vec4::lerp(*self, *other, t);
        self
    }
}