qsi 0.2.0

A small and fast simulation framework.
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
159

//! Math utilities and components

use crate::ecs::Component;
pub use cgmath::{Deg, EuclideanSpace, Matrix4, Point3, Rad, SquareMatrix, Vector3, perspective};

/// Transform component for position, rotation, and scale
#[derive(Debug, Clone)]
pub struct Transform {
    pub position: Vector3<f32>,
    pub rotation: Vector3<f32>, // Euler angles in radians
    pub scale: Vector3<f32>,
}

impl Component for Transform {}

impl Default for Transform {
    fn default() -> Self {
        Self {
            position: Vector3::new(0.0, 0.0, 0.0),
            rotation: Vector3::new(0.0, 0.0, 0.0),
            scale: Vector3::new(1.0, 1.0, 1.0),
        }
    }
}

impl Transform {
    /// Create a new transform at the given position
    pub fn at_position(position: Vector3<f32>) -> Self {
        Self {
            position,
            ..Default::default()
        }
    }

    /// Create a new transform with the given rotation (in degrees)
    pub fn with_rotation_deg(rotation: Vector3<f32>) -> Self {
        Self {
            rotation: Vector3::new(
                rotation.x.to_radians(),
                rotation.y.to_radians(),
                rotation.z.to_radians(),
            ),
            ..Default::default()
        }
    }

    /// Create a new transform with the given scale
    pub fn with_scale(scale: Vector3<f32>) -> Self {
        Self {
            scale,
            ..Default::default()
        }
    }

    /// Set position
    pub fn set_position(&mut self, position: Vector3<f32>) {
        self.position = position;
    }

    /// Set rotation in degrees
    pub fn set_rotation_deg(&mut self, rotation: Vector3<f32>) {
        self.rotation = Vector3::new(
            rotation.x.to_radians(),
            rotation.y.to_radians(),
            rotation.z.to_radians(),
        );
    }

    /// Set rotation in radians
    pub fn set_rotation_rad(&mut self, rotation: Vector3<f32>) {
        self.rotation = rotation;
    }

    /// Set scale
    pub fn set_scale(&mut self, scale: Vector3<f32>) {
        self.scale = scale;
    }

    /// Get the transformation matrix
    pub fn matrix(&self) -> Matrix4<f32> {
        Matrix4::from_translation(self.position)
            * Matrix4::from_angle_y(Rad(self.rotation.y))
            * Matrix4::from_angle_x(Rad(self.rotation.x))
            * Matrix4::from_angle_z(Rad(self.rotation.z))
            * Matrix4::from_nonuniform_scale(self.scale.x, self.scale.y, self.scale.z)
    }

    /// Get the rotation in degrees
    pub fn rotation_deg(&self) -> Vector3<f32> {
        Vector3::new(
            self.rotation.x.to_degrees(),
            self.rotation.y.to_degrees(),
            self.rotation.z.to_degrees(),
        )
    }
}

/// Velocity component for physics simulations
#[derive(Debug, Clone)]
pub struct Velocity {
    pub linear: Vector3<f32>,
    pub angular: Vector3<f32>, // Radians per second
}

impl Component for Velocity {}

impl Default for Velocity {
    fn default() -> Self {
        Self {
            linear: Vector3::new(0.0, 0.0, 0.0),
            angular: Vector3::new(0.0, 0.0, 0.0),
        }
    }
}

impl Velocity {
    /// Create a new velocity with the given linear velocity
    pub fn linear(linear: Vector3<f32>) -> Self {
        Self {
            linear,
            ..Default::default()
        }
    }

    /// Create a new velocity with the given angular velocity
    pub fn angular(angular: Vector3<f32>) -> Self {
        Self {
            angular,
            ..Default::default()
        }
    }
}

/// Utility functions for common math operations
pub mod utils {
    use super::*;

    /// Create a look-at matrix
    pub fn look_at(eye: Point3<f32>, target: Point3<f32>, up: Vector3<f32>) -> Matrix4<f32> {
        Matrix4::look_at_rh(eye, target, up)
    }

    /// Create a perspective projection matrix
    pub fn perspective_matrix(fov_deg: f32, aspect: f32, near: f32, far: f32) -> Matrix4<f32> {
        perspective(Deg(fov_deg), aspect, near, far)
    }

    /// Lerp between two vectors
    pub fn lerp(a: Vector3<f32>, b: Vector3<f32>, t: f32) -> Vector3<f32> {
        a + (b - a) * t
    }

    /// Spherical linear interpolation for rotation
    pub fn slerp_euler(a: Vector3<f32>, b: Vector3<f32>, t: f32) -> Vector3<f32> {
        // Simple linear interpolation for Euler angles
        // Note: This doesn't handle angle wrapping properly
        lerp(a, b, t)
    }
}