This will be squashed anyway

Author: nat-rix

rask-engine/src/boxes.rs

@@ -159,9 +159,9 @@ impl From<&spine::skeleton::srt::SRT> for RBox {
 
 impl From<&Mat3> for RBox {
     fn from(mat: &Mat3) -> RBox {
-        let pos = Vec2::from(*mat * Vec3::new(-1.0, -1.0, 1.0));
-        let v1 = Mat2::from(mat) * Vec2::new(0.0, 2.0);
-        let v2 = Mat2::from(mat) * Vec2::new(2.0, 0.0);
+        let pos = (*mat * Vec3::new(-1.0, -1.0, 1.0)).into();
+        let v1 = (*mat * Vec3::new(0.0, 2.0, 0.0)).into();
+        let v2 = (*mat * Vec3::new(2.0, 0.0, 0.0)).into();
         RBox { pos, v1, v2 }
     }
 }

rask-engine/src/collide.rs

@@ -9,6 +9,7 @@ use crate::math::{Vec2, EPSILON};
 /// A trait for objects that can collide with other objects.
 pub trait Collide<Rhs = Self> {
     /// calculate the penetration depth (a scalar ratio of `dv`)
+    /// as well as the normal of the colliding edge
     /// of the collision after applying the velocity,
     /// if there was any.
     /// `dv` is the difference between the two velocities
@@ -39,8 +40,8 @@ impl Collide for Collidable {
 }
 
 impl Collidable {
-    pub fn shift(&self, dv: Vec2) -> Collidable {
-        match self {
+    pub fn shift(&mut self, dv: Vec2) {
+        *self = match self {
             Collidable::AABox(a) => Collidable::AABox(AABox {
                 pos: a.pos + dv,
                 size: a.size,
@@ -55,32 +56,6 @@ impl Collidable {
     }
 }
 
-/// calculate the minimal axis aligned bounding box that contains all `Collidable`s of a given set
-pub fn calculate_aabb<'a, I: Iterator<Item = &'a Collidable>>(vals: I) -> AABox {
-    let [(mut minx, mut maxx), (mut miny, mut maxy)] = [(f32::INFINITY, f32::NEG_INFINITY); 2];
-    let mut minmax = |v1: &Vec2, v2: &Vec2| {
-        minx = f32::min(minx, v1.x());
-        maxx = f32::max(maxx, v2.x());
-        miny = f32::min(miny, v1.y());
-        maxy = f32::max(maxy, v2.y());
-    };
-    for val in vals {
-        match val {
-            Collidable::Point(v) => minmax(v, v),
-            Collidable::AABox(AABox { pos, size }) => minmax(pos, &(*pos + *size)),
-            &Collidable::RBox(RBox { pos, v1, v2 }) => {
-                for point in &[pos, pos + v1, pos + v2, pos + v1 + v2] {
-                    minmax(point, point)
-                }
-            }
-        };
-    }
-    AABox {
-        pos: Vec2::new(minx, miny),
-        size: Vec2::new(maxx - minx, maxy - miny),
-    }
-}
-
 // Given a fraction of the dv vectors length,
 // return the amount to set the objects back
 // in case of a collision
@@ -104,6 +79,26 @@ macro_rules! impl_collide {
                 Self::$C(other)
             }
         }
+
+        impl Collide<$A> for Collidable {
+            fn collide_after(&self, other: &$A, dv: Vec2) -> Option<f32> {
+                match self {
+                    Collidable::Point(s) => s.collide_after(other, dv),
+                    Collidable::AABox(s) => s.collide_after(other, dv),
+                    Collidable::RBox(s) => s.collide_after(other, dv),
+                }
+            }
+        }
+
+        impl Collide<Collidable> for $A {
+            fn collide_after(&self, other: &Collidable, dv: Vec2) -> Option<f32> {
+                match other {
+                    Collidable::Point(s) => self.collide_after(s, dv),
+                    Collidable::AABox(s) => self.collide_after(s, dv),
+                    Collidable::RBox(s) => self.collide_after(s, dv),
+                }
+            }
+        }
     };
     (for {$A:ident, $B:ident} $item:item) => {
         impl Collide<$B> for $A {

rask-engine/src/engine/components.rs

@@ -50,7 +50,7 @@ pub struct Vel(pub Vec2);
 
 #[derive(Debug, Clone, Copy, Default, Component)]
 #[storage(VecStorage)]
-pub struct Vel_(pub Vec2);
+pub struct DeltaVel(pub Vec2);
 
 #[derive(Debug, Clone, Copy, Default, Component)]
 #[storage(VecStorage)]
@@ -116,9 +116,13 @@ pub struct Sprite {
     pub sub_id: u64,
 }
 
-#[derive(Debug, Clone, Component)]
-pub struct Transform {
-    pub mat3: Mat3,
+#[derive(Debug, Default, Clone, Component)]
+pub struct Transform(pub Mat3);
+
+impl Transform {
+    pub fn shift(&mut self, vec: Vec2) {
+        self.0 = Mat3::translation(vec.x(), vec.y()) * self.0
+    }
 }
 
 #[derive(Debug, Default, Clone, Copy, Component)]

rask-engine/src/engine/mod.rs

@@ -122,9 +122,9 @@ impl GameEngine for RaskEngine {
             .build();
         let _char = world
             .create_entity()
-            .with(Pos(Vec2::new(0.0, 0.0)))
+            .with(Pos(Vec2::new(0.3, 0.0)))
             .with(Vel(Vec2::new(0.0, 0.0)))
-            .with(Vel_(Vec2::zero()))
+            .with(DeltaVel(Vec2::zero()))
             .with(Speed(0.4))
             .with(Mass(1.0))
             .with(Animation {