hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Divide Angle enum into separate Radians and Degrees types

Browse source
This commit is contained in:
Brendan Zabarauskas 2012-11-26 04:28:41 +10:00
parent eda42604b7
commit 5393e9a1f6
6 changed files with 62 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
src/angle.rs
View file

@ -1,94 +1,52 @@
use core::f64::consts::pi;
use num::cast::*;
use vec::Vec3;
pub enum Angle<T> {
degrees(T),
radians(T),
pub trait Angle<T>: Add<self,self>
, Sub<self,self>
, Mul<T,self>
, Div<T,self>
, Modulo<T,self>
, Neg<self> {
pure fn to_radians() -> Radians<T>;
pure fn to_degrees() -> Degrees<T>;
}
pub impl<T:Copy Num NumCast> Angle<T> {
pure fn degrees() -> T {
match self {
degrees(theta) => theta,
radians(theta) => theta * cast(180f64 / f64::consts::pi)
}
}
pub enum Radians<T> = T;
pub impl<T:Copy Num NumCast> Radians<T>: Angle<T> {
#[inline(always)] pure fn to_radians() -> Radians<T> { self }
#[inline(always)] pure fn to_degrees() -> Degrees<T> { Degrees(*self * cast(180.0 / pi)) }
pure fn radians() -> T {
match self {
degrees(theta) => theta * cast(f64::consts::pi / 180f64),
radians(theta) => theta
}
}
#[inline(always)] pure fn add(rhs: &Radians<T>) -> Radians<T> { self + *rhs }
#[inline(always)] pure fn sub(rhs: &Radians<T>) -> Radians<T> { self - *rhs }
#[inline(always)] pure fn mul(rhs: &T) -> Radians<T> { self * *rhs }
#[inline(always)] pure fn div(rhs: &T) -> Radians<T> { self / *rhs }
#[inline(always)] pure fn modulo(rhs: &T) -> Radians<T> { self % *rhs }
#[inline(always)] pure fn neg() -> Radians<T> {-self }
}
pub impl<T:Copy Num> Angle<T>: Add<T,Angle<T>> {
#[inline(always)]
pure fn add(rhs: &T) -> Angle<T> {
match self {
degrees(theta) => degrees(theta + *rhs),
radians(theta) => radians(theta + *rhs)
}
}
}
pub enum Degrees<T> = T;
pub impl<T:Copy Num> Angle<T>: Sub<T,Angle<T>> {
#[inline(always)]
pure fn sub(rhs: &T) -> Angle<T> {
match self {
degrees(theta) => degrees(theta - *rhs),
radians(theta) => radians(theta - *rhs)
}
}
}
pub impl<T:Copy Num> Angle<T>: Mul<T,Angle<T>> {
#[inline(always)]
pure fn mul(rhs: &T) -> Angle<T> {
match self {
degrees(theta) => degrees(theta * *rhs),
radians(theta) => radians(theta * *rhs)
}
}
}
pub impl<T:Copy Num> Angle<T>: Div<T,Angle<T>> {
#[inline(always)]
pure fn div(rhs: &T) -> Angle<T> {
match self {
degrees(theta) => degrees(theta / *rhs),
radians(theta) => radians(theta / *rhs)
}
}
}
pub impl<T:Copy Num> Angle<T>: Modulo<T,Angle<T>> {
#[inline(always)]
pure fn modulo(rhs: &T) -> Angle<T> {
match self {
degrees(theta) => degrees(theta % *rhs),
radians(theta) => radians(theta % *rhs)
}
}
}
pub impl<T:Copy Num> Angle<T>: Neg<Angle<T>> {
#[inline(always)]
pure fn neg() -> Angle<T> {
match self {
degrees(theta) => degrees(-theta),
radians(theta) => radians(-theta)
}
}
pub impl<T:Copy Num NumCast> Degrees<T>: Angle<T> {
#[inline(always)] pure fn to_radians() -> Radians<T> { Radians(*self * cast(pi / 180.0)) }
#[inline(always)] pure fn to_degrees() -> Degrees<T> { self }
#[inline(always)] pure fn add(rhs: &Degrees<T>) -> Degrees<T> { self + *rhs }
#[inline(always)] pure fn sub(rhs: &Degrees<T>) -> Degrees<T> { self - *rhs }
#[inline(always)] pure fn mul(rhs: &T) -> Degrees<T> { self * *rhs }
#[inline(always)] pure fn div(rhs: &T) -> Degrees<T> { self / *rhs }
#[inline(always)] pure fn modulo(rhs: &T) -> Degrees<T> { self % *rhs }
#[inline(always)] pure fn neg() -> Degrees<T> {-self }
}
pub struct AxisRotation<T> {
axis: Vec3<T>,
theta: Angle<T>,
theta: Radians<T>,
}
pub struct Euler<T> {
x: T, // pitch
y: T, // yaw
z: T, // roll
x: Radians<T>, // pitch
y: Radians<T>, // yaw
z: Radians<T>, // roll
}

2
src/funs/projection.rs
View file

@ -12,7 +12,7 @@ use num::ext::FloatExt;
// http://www.opengl.org/wiki/GluPerspective_code
//
#[inline(always)]
pure fn perspective<T:Copy FloatExt>(fovy: Angle<T>, aspectRatio: T, near: T, far: T) -> Mat4<T> {
pure fn perspective<T:Copy FloatExt>(fovy: Radians<T>, aspectRatio: T, near: T, far: T) -> Mat4<T> {
let ymax = near * tan(&fovy);
let xmax = ymax * aspectRatio;
return frustum(-xmax, xmax, -ymax, ymax, near, far);

8
src/funs/test/test_transform.rs
View file

@ -1,5 +1,5 @@
use funs::transform::*;
use angle::degrees;
use angle::Degrees;
use mat::Mat4;
use vec::{Vec3, Vec4};
@ -8,7 +8,7 @@ fn test_mat4_from_rotation() {
{
let pos = Vec4::new(1f32, 0f32, 0f32, 1f32);
// let tform = mat4_from_rotation(180f32, Vec3::unit_z());
let tform = mat4_from_rotation(degrees(180f32), Vec3::new(0f32, 0f32, 1f32));
let tform = mat4_from_rotation(Degrees(180f32).to_radians(), Vec3::new(0f32, 0f32, 1f32));
let newpos = tform.mul_v(&pos);
let expected = Vec4::new(-1f32, 0f32, 0f32, 1f32);
@ -20,8 +20,8 @@ fn test_mat4_from_rotation() {
// let tform_a = mat4_from_rotation(90f32, Vec3::unit_y());
// let tform_b = mat4_from_rotation(90f32, -Vec3::unit_y());
let tform_a = mat4_from_rotation(degrees(90f32), Vec3::new(0f32, 1f32, 0f32));
let tform_b = mat4_from_rotation(degrees(90f32), -Vec3::new(0f32, 1f32, 0f32));
let tform_a = mat4_from_rotation(Degrees(90f32).to_radians(), Vec3::new(0f32, 1f32, 0f32));
let tform_b = mat4_from_rotation(Degrees(90f32).to_radians(), -Vec3::new(0f32, 1f32, 0f32));
let newpos_a = tform_a.mul_v(&pos);
let newpos_b = tform_b.mul_v(&pos);

4
src/funs/transform.rs
View file

@ -3,7 +3,7 @@ use angle::Angle;
use mat::{Mat3, Mat4};
use num::cast::*;
pub pure fn mat3_from_rotation<T:Copy Num NumCast>(theta: Angle<T>, axis: Vec3<T>) -> Mat3<T> {
pub pure fn mat3_from_rotation<T:Copy Num NumCast>(theta: Radians<T>, axis: Vec3<T>) -> Mat3<T> {
let c: T = cos(&theta);
let s: T = sin(&theta);
let _0: T = cast(0);
@ -15,6 +15,6 @@ pub pure fn mat3_from_rotation<T:Copy Num NumCast>(theta: Angle<T>, axis: Vec3<T
t * axis.x * axis.z - s - axis.y, t * axis.y * axis.z - s * axis.x, t * axis.z * axis.z + c)
}
pub pure fn mat4_from_rotation<T:Copy Num NumCast>(theta: Angle<T>, axis: Vec3<T>) -> Mat4<T> {
pub pure fn mat4_from_rotation<T:Copy Num NumCast>(theta: Radians<T>, axis: Vec3<T>) -> Mat4<T> {
mat3_from_rotation(theta, axis).to_mat4()
}

38
src/funs/trig.rs
View file

@ -17,10 +17,10 @@ priv trait Trig<T> {
#[inline(always)] pub pure fn cos<T:Trig<R>, R>(theta: &T) -> R { theta.cos() }
#[inline(always)] pub pure fn tan<T:Trig<R>, R>(theta: &T) -> R { theta.tan() }
priv impl<T:Copy Num NumCast> Angle<T>: Trig<T> {
#[inline(always)] pure fn sin() -> T { cast(f64::sin(cast(self.radians()))) }
#[inline(always)] pure fn cos() -> T { cast(f64::cos(cast(self.radians()))) }
#[inline(always)] pure fn tan() -> T { cast(f64::tan(cast(self.radians()))) }
priv impl<T:Copy Num NumCast> Radians<T>: Trig<T> {
#[inline(always)] pure fn sin() -> T { cast(f64::sin(cast(*self))) }
#[inline(always)] pure fn cos() -> T { cast(f64::cos(cast(*self))) }
#[inline(always)] pure fn tan() -> T { cast(f64::tan(cast(*self))) }
}
///
@ -29,31 +29,31 @@ priv impl<T:Copy Num NumCast> Angle<T>: Trig<T> {
/// http://en.wikipedia.org/wiki/Inverse_trigonometric_functions
///
pub trait InvTrig {
pure fn asin() -> Angle<self>;
pure fn acos() -> Angle<self>;
pure fn atan() -> Angle<self>;
pure fn asin() -> Radians<self>;
pure fn acos() -> Radians<self>;
pure fn atan() -> Radians<self>;
}
#[inline(always)] pub pure fn asin<T:InvTrig>(x: &T) -> Angle<T> { x.asin() }
#[inline(always)] pub pure fn acos<T:InvTrig>(x: &T) -> Angle<T> { x.acos() }
#[inline(always)] pub pure fn atan<T:InvTrig>(x: &T) -> Angle<T> { x.atan() }
#[inline(always)] pub pure fn asin<T:InvTrig>(x: &T) -> Radians<T> { x.asin() }
#[inline(always)] pub pure fn acos<T:InvTrig>(x: &T) -> Radians<T> { x.acos() }
#[inline(always)] pub pure fn atan<T:InvTrig>(x: &T) -> Radians<T> { x.atan() }
pub impl f32: InvTrig {
#[inline(always)] pure fn asin() -> Angle<f32> { radians(f32::asin(self)) }
#[inline(always)] pure fn acos() -> Angle<f32> { radians(f32::acos(self)) }
#[inline(always)] pure fn atan() -> Angle<f32> { radians(f32::atan(self)) }
#[inline(always)] pure fn asin() -> Radians<f32> { Radians(f32::asin(self)) }
#[inline(always)] pure fn acos() -> Radians<f32> { Radians(f32::acos(self)) }
#[inline(always)] pure fn atan() -> Radians<f32> { Radians(f32::atan(self)) }
}
pub impl f64: InvTrig {
#[inline(always)] pure fn asin() -> Angle<f64> { radians(f64::asin(self)) }
#[inline(always)] pure fn acos() -> Angle<f64> { radians(f64::acos(self)) }
#[inline(always)] pure fn atan() -> Angle<f64> { radians(f64::atan(self)) }
#[inline(always)] pure fn asin() -> Radians<f64> { Radians(f64::asin(self)) }
#[inline(always)] pure fn acos() -> Radians<f64> { Radians(f64::acos(self)) }
#[inline(always)] pure fn atan() -> Radians<f64> { Radians(f64::atan(self)) }
}
pub impl float: InvTrig {
#[inline(always)] pure fn asin() -> Angle<float> { radians(f64::asin(cast(self)).to_float()) }
#[inline(always)] pure fn acos() -> Angle<float> { radians(f64::acos(cast(self)).to_float()) }
#[inline(always)] pure fn atan() -> Angle<float> { radians(f64::atan(cast(self)).to_float()) }
#[inline(always)] pure fn asin() -> Radians<float> { Radians(f64::asin(cast(self)).to_float()) }
#[inline(always)] pure fn acos() -> Radians<float> { Radians(f64::acos(cast(self)).to_float()) }
#[inline(always)] pure fn atan() -> Radians<float> { Radians(f64::atan(cast(self)).to_float()) }
}
///

2
src/quat.rs
View file

@ -222,7 +222,7 @@ pub impl<T:Copy Num NumCast Exp Clamp Ord InvTrig> Quat<T>: Quaternion<T> {
}
#[inline(always)]
pub pure fn from_axis_angle(axis: Vec3<T>, theta: Angle<T>) -> Quat<T> {
pub pure fn from_axis_angle(axis: Vec3<T>, theta: Radians<T>) -> Quat<T> {
let half = theta / cast(2);
Quat::from_sv(cos(&half), axis.mul_t(sin(&half)))
}