Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Vector-Tuple algebraic operation implementations #214

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Vector-Tuple algebraic operation implementations #214

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
366 changes: 366 additions & 0 deletions raylib/src/core/math.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -390,6 +390,70 @@ impl Neg for Vector2 {
}
}

impl Add<(f32, f32)> for Vector2 {
type Output = Vector2;
fn add(self, v: (f32, f32)) -> Self {
Vector2 {
x: self.x + v.0,
y: self.y + v.1,
}
}
}

impl AddAssign<(f32, f32)> for Vector2 {
fn add_assign(&mut self, v: (f32, f32)) {
*self = *self + v;
}
}

impl Sub<(f32, f32)> for Vector2 {
type Output = Vector2;
fn sub(self, v: (f32, f32)) -> Self {
Vector2 {
x: self.x - v.0,
y: self.y - v.1,
}
}
}

impl SubAssign<(f32, f32)> for Vector2 {
fn sub_assign(&mut self, v: (f32, f32)) {
*self = *self - v;
}
}

impl Mul<(f32, f32)> for Vector2 {
type Output = Vector2;
fn mul(self, v: (f32, f32)) -> Self {
Vector2 {
x: self.x * v.0,
y: self.y * v.1,
}
}
}

impl MulAssign<(f32, f32)> for Vector2 {
fn mul_assign(&mut self, v: (f32, f32)) {
*self = *self * v;
}
}

impl Div<(f32, f32)> for Vector2 {
type Output = Vector2;
fn div(self, v: (f32, f32)) -> Self {
Vector2 {
x: self.x / v.0,
y: self.y / v.1,
}
}
}

impl DivAssign<(f32, f32)> for Vector2 {
fn div_assign(&mut self, v: (f32, f32)) {
*self = *self / v;
}
}

optional_serde_struct! {
pub struct Vector3 {
pub x: f32,
Expand Down Expand Up @@ -848,6 +912,74 @@ impl Neg for Vector3 {
}
}

impl Add<(f32, f32, f32)> for Vector3 {
type Output = Vector3;
fn add(self, v: (f32, f32, f32)) -> Self {
Vector3 {
x: self.x + v.0,
y: self.y + v.1,
z: self.z + v.2,
}
}
}

impl AddAssign<(f32, f32, f32)> for Vector3 {
fn add_assign(&mut self, v: (f32, f32, f32)) {
*self = *self + v;
}
}

impl Sub<(f32, f32, f32)> for Vector3 {
type Output = Vector3;
fn sub(self, v: (f32, f32, f32)) -> Self {
Vector3 {
x: self.x - v.0,
y: self.y - v.1,
z: self.z - v.2,
}
}
}

impl SubAssign<(f32, f32, f32)> for Vector3 {
fn sub_assign(&mut self, v: (f32, f32, f32)) {
*self = *self - v;
}
}

impl Mul<(f32, f32, f32)> for Vector3 {
type Output = Vector3;
fn mul(self, v: (f32, f32, f32)) -> Self {
Vector3 {
x: self.x * v.0,
y: self.y * v.1,
z: self.z * v.2,
}
}
}

impl MulAssign<(f32, f32, f32)> for Vector3 {
fn mul_assign(&mut self, v: (f32, f32, f32)) {
*self = *self * v;
}
}

impl Div<(f32, f32, f32)> for Vector3 {
type Output = Vector3;
fn div(self, v: (f32, f32, f32)) -> Self {
Vector3 {
x: self.x / v.0,
y: self.y / v.1,
z: self.z / v.2,
}
}
}

impl DivAssign<(f32, f32, f32)> for Vector3 {
fn div_assign(&mut self, v: (f32, f32, f32)) {
*self = *self / v;
}
}

optional_serde_struct! {
pub struct Vector4 {
pub x: f32,
Expand Down Expand Up @@ -1284,6 +1416,33 @@ impl MulAssign for Quaternion {
}
}

impl Mul<(f32, f32, f32, f32)> for Quaternion {
type Output = Quaternion;
fn mul(self, q: (f32, f32, f32, f32)) -> Quaternion {
let qax = self.x;
let qay = self.y;
let qaz = self.z;
let qaw = self.w;
let qbx = q.0;
let qby = q.1;
let qbz = q.2;
let qbw = q.3;

Quaternion {
x: (qax * qbw) + (qaw * qbx) + (qay * qbz) - (qaz * qby),
y: (qay * qbw) + (qaw * qby) + (qaz * qbx) - (qax * qbz),
z: (qaz * qbw) + (qaw * qbz) + (qax * qby) - (qay * qbx),
w: (qaw * qbw) - (qax * qbx) - (qay * qby) - (qaz * qbz),
}
}
}

impl MulAssign<(f32, f32, f32, f32)> for Quaternion {
fn mul_assign(&mut self, q: (f32, f32, f32, f32)) {
*self = *self * q;
}
}

optional_serde_struct! {
pub struct Matrix {
pub m0: f32,
Expand Down Expand Up @@ -2094,4 +2253,211 @@ mod math_test {
"bad memory transmutation"
)
}

#[test]
fn vector2_tuple_add() {
let vector = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
assert_eq!(
vector + tuple,
vector + check,
"inconsistent math implementation"
);
}

#[test]
fn vector2_tuple_add_assign() {
let mut vector_1 = Vector2::new(1.0, 2.0);
let mut vector_2 = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
vector_1 += tuple;
vector_2 += check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector2_tuple_sub() {
let vector = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
assert_eq!(
vector - tuple,
vector - check,
"inconsistent math implementation"
);
}

#[test]
fn vector2_tuple_sub_assign() {
let mut vector_1 = Vector2::new(1.0, 2.0);
let mut vector_2 = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
vector_1 -= tuple;
vector_2 -= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector2_tuple_mul() {
let vector = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
assert_eq!(
vector * tuple,
vector * check,
"inconsistent math implementation"
);
}

#[test]
fn vector2_tuple_mul_assign() {
let mut vector_1 = Vector2::new(1.0, 2.0);
let mut vector_2 = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
vector_1 *= tuple;
vector_2 *= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector2_tuple_div() {
let vector = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
assert_eq!(
vector / tuple,
vector / check,
"inconsistent math implementation"
);
}

#[test]
fn vector2_tuple_div_assign() {
let mut vector_1 = Vector2::new(1.0, 2.0);
let mut vector_2 = Vector2::new(1.0, 2.0);
let tuple = (3.0, 4.0);
let check = Vector2::new(3.0, 4.0);
vector_1 /= tuple;
vector_2 /= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector3_tuple_add() {
let vector = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
assert_eq!(
vector + tuple,
vector + check,
"inconsistent math implementation"
);
}

#[test]
fn vector3_tuple_add_assign() {
let mut vector_1 = Vector3::new(1.0, 2.0, 3.0);
let mut vector_2 = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
vector_1 += tuple;
vector_2 += check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector3_tuple_sub() {
let vector = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
assert_eq!(
vector - tuple,
vector - check,
"inconsistent math implementation"
);
}

#[test]
fn vector3_tuple_sub_assign() {
let mut vector_1 = Vector3::new(1.0, 2.0, 3.0);
let mut vector_2 = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
vector_1 -= tuple;
vector_2 -= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector3_tuple_mul() {
let vector = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
assert_eq!(
vector * tuple,
vector * check,
"inconsistent math implementation"
);
}

#[test]
fn vector3_tuple_mul_assign() {
let mut vector_1 = Vector3::new(1.0, 2.0, 3.0);
let mut vector_2 = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
vector_1 *= tuple;
vector_2 *= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector3_tuple_div() {
let vector = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
assert_eq!(
vector / tuple,
vector / check,
"inconsistent math implementation"
);
}

#[test]
fn vector3_tuple_div_assign() {
let mut vector_1 = Vector3::new(1.0, 2.0, 3.0);
let mut vector_2 = Vector3::new(1.0, 2.0, 3.0);
let tuple = (4.0, 5.0, 6.0);
let check = Vector3::new(4.0, 5.0, 6.0);
vector_1 /= tuple;
vector_2 /= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}

#[test]
fn vector4_tuple_mul() {
let vector = Vector4::new(1.0, 2.0, 3.0, 4.0);
let tuple = (5.0, 6.0, 7.0, 8.0);
let check = Vector4::new(5.0, 6.0, 7.0, 8.0);
assert_eq!(
vector * tuple,
vector * check,
"inconsistent math implementation"
);
}

#[test]
fn vector4_tuple_mul_assign() {
let mut vector_1 = Vector4::new(1.0, 2.0, 3.0, 4.0);
let mut vector_2 = Vector4::new(1.0, 2.0, 3.0, 4.0);
let tuple = (5.0, 6.0, 7.0, 8.0);
let check = Vector4::new(5.0, 6.0, 7.0, 8.0);
vector_1 *= tuple;
vector_2 *= check;
assert_eq!(vector_1, vector_2, "inconsistent math implementation");
}
}
Loading