Remove instances of 'static'
This commit is contained in:
Brendan Zabarauskas
parent
27603dd6bd
commit
2c2b7a71d0
9 changed files with 292 additions and 292 deletions
34
src/mat.rs
34
src/mat.rs
|
|
@ -36,21 +36,21 @@ pub trait Matrix<T,V>: Index<uint, V> + Eq + Neg<Self> {
|
|||
/**
|
||||
* Construct a diagonal matrix with the major diagonal set to `value`
|
||||
*/
|
||||
static fn from_value(value: T) -> Self;
|
||||
fn from_value(value: T) -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
*
|
||||
* The identity matrix
|
||||
*/
|
||||
static fn identity() -> Self;
|
||||
fn identity() -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
*
|
||||
* A matrix with all elements set to zero
|
||||
*/
|
||||
static fn zero() -> Self;
|
||||
fn zero() -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
|
|
@ -183,12 +183,12 @@ pub trait Matrix<T,V>: Index<uint, V> + Eq + Neg<Self> {
|
|||
* A 2 x 2 matrix
|
||||
*/
|
||||
pub trait Matrix2<T,V>: Matrix<T,V> {
|
||||
static fn new(c0r0: T, c0r1: T,
|
||||
fn new(c0r0: T, c0r1: T,
|
||||
c1r0: T, c1r1: T) -> Self;
|
||||
|
||||
static fn from_cols(c0: V, c1: V) -> Self;
|
||||
fn from_cols(c0: V, c1: V) -> Self;
|
||||
|
||||
static fn from_angle(radians: T) -> Self;
|
||||
fn from_angle(radians: T) -> Self;
|
||||
|
||||
fn to_mat3(&self) -> Mat3<T>;
|
||||
|
||||
|
|
@ -199,25 +199,25 @@ pub trait Matrix2<T,V>: Matrix<T,V> {
|
|||
* A 3 x 3 matrix
|
||||
*/
|
||||
pub trait Matrix3<T,V>: Matrix<T,V> {
|
||||
static fn new(c0r0:T, c0r1:T, c0r2:T,
|
||||
fn new(c0r0:T, c0r1:T, c0r2:T,
|
||||
c1r0:T, c1r1:T, c1r2:T,
|
||||
c2r0:T, c2r1:T, c2r2:T) -> Self;
|
||||
|
||||
static fn from_cols(c0: V, c1: V, c2: V) -> Self;
|
||||
fn from_cols(c0: V, c1: V, c2: V) -> Self;
|
||||
|
||||
static fn from_angle_x(radians: T) -> Self;
|
||||
fn from_angle_x(radians: T) -> Self;
|
||||
|
||||
static fn from_angle_y(radians: T) -> Self;
|
||||
fn from_angle_y(radians: T) -> Self;
|
||||
|
||||
static fn from_angle_z(radians: T) -> Self;
|
||||
fn from_angle_z(radians: T) -> Self;
|
||||
|
||||
static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Self;
|
||||
fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Self;
|
||||
|
||||
static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Self;
|
||||
fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Self;
|
||||
|
||||
static fn from_axes(x: V, y: V, z: V) -> Self;
|
||||
fn from_axes(x: V, y: V, z: V) -> Self;
|
||||
|
||||
static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Self;
|
||||
fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Self;
|
||||
|
||||
fn to_mat4(&self) -> Mat4<T>;
|
||||
|
||||
|
|
@ -228,12 +228,12 @@ pub trait Matrix3<T,V>: Matrix<T,V> {
|
|||
* A 4 x 4 matrix
|
||||
*/
|
||||
pub trait Matrix4<T,V>: Matrix<T,V> {
|
||||
static fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
|
||||
fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
|
||||
c1r0: T, c1r1: T, c1r2: T, c1r3: T,
|
||||
c2r0: T, c2r1: T, c2r2: T, c2r3: T,
|
||||
c3r0: T, c3r1: T, c3r2: T, c3r3: T) -> Self;
|
||||
|
||||
static fn from_cols(c0: V, c1: V, c2: V, c3: V) -> Self;
|
||||
fn from_cols(c0: V, c1: V, c2: V, c3: V) -> Self;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
52
src/mat2.rs
52
src/mat2.rs
|
|
@ -73,7 +73,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Mat2<T> {
|
||||
fn from_value(value: T) -> Mat2<T> {
|
||||
Matrix2::new(value, zero(),
|
||||
zero(), value)
|
||||
}
|
||||
|
|
@ -90,7 +90,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn identity() -> Mat2<T> {
|
||||
fn identity() -> Mat2<T> {
|
||||
Matrix2::new( one::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>())
|
||||
}
|
||||
|
|
@ -107,7 +107,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn zero() -> Mat2<T> {
|
||||
fn zero() -> Mat2<T> {
|
||||
Matrix2::new(zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
|
@ -296,7 +296,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn new(c0r0: T, c0r1: T,
|
||||
fn new(c0r0: T, c0r1: T,
|
||||
c1r0: T, c1r1: T) -> Mat2<T> {
|
||||
Matrix2::from_cols(Vector2::new::<T,Vec2<T>>(c0r0, c0r1),
|
||||
Vector2::new::<T,Vec2<T>>(c1r0, c1r1))
|
||||
|
|
@ -320,13 +320,13 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_cols(c0: Vec2<T>,
|
||||
fn from_cols(c0: Vec2<T>,
|
||||
c1: Vec2<T>) -> Mat2<T> {
|
||||
Mat2 { x: c0, y: c1 }
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle(radians: T) -> Mat2<T> {
|
||||
fn from_angle(radians: T) -> Mat2<T> {
|
||||
let cos_theta = cos(radians);
|
||||
let sin_theta = sin(radians);
|
||||
|
||||
|
|
@ -417,37 +417,37 @@ pub type dmat2 = Mat2<f64>; // a 2×2 double-precision floating-point matrix
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl mat2 {
|
||||
#[inline(always)] static fn new(c0r0: f32, c0r1: f32, c1r0: f32, c1r1: f32)
|
||||
#[inline(always)] fn new(c0r0: f32, c0r1: f32, c1r0: f32, c1r1: f32)
|
||||
-> mat2 { Matrix2::new(c0r0, c0r1, c1r0, c1r1) }
|
||||
#[inline(always)] static fn from_cols(c0: vec2, c1: vec2)
|
||||
#[inline(always)] fn from_cols(c0: vec2, c1: vec2)
|
||||
-> mat2 { Matrix2::from_cols(c0, c1) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> mat2 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f32) -> mat2 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> mat2 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> mat2 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> mat2 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> mat2 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn from_angle(radians: f32) -> mat2 { Matrix2::from_angle(radians) }
|
||||
#[inline(always)] fn from_angle(radians: f32) -> mat2 { Matrix2::from_angle(radians) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn rows() -> uint { 2 }
|
||||
#[inline(always)] static fn cols() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<mat2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn rows() -> uint { 2 }
|
||||
#[inline(always)] fn cols() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<mat2>() }
|
||||
}
|
||||
|
||||
impl dmat2 {
|
||||
#[inline(always)] static fn new(c0r0: f64, c0r1: f64, c1r0: f64, c1r1: f64)
|
||||
#[inline(always)] fn new(c0r0: f64, c0r1: f64, c1r0: f64, c1r1: f64)
|
||||
-> dmat2 { Matrix2::new(c0r0, c0r1, c1r0, c1r1) }
|
||||
#[inline(always)] static fn from_cols(c0: dvec2, c1: dvec2)
|
||||
#[inline(always)] fn from_cols(c0: dvec2, c1: dvec2)
|
||||
-> dmat2 { Matrix2::from_cols(c0, c1) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dmat2 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dmat2 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> dmat2 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> dmat2 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> dmat2 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> dmat2 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn from_angle(radians: f64) -> dmat2 { Matrix2::from_angle(radians) }
|
||||
#[inline(always)] fn from_angle(radians: f64) -> dmat2 { Matrix2::from_angle(radians) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn rows() -> uint { 2 }
|
||||
#[inline(always)] static fn cols() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dmat2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn rows() -> uint { 2 }
|
||||
#[inline(always)] fn cols() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dmat2>() }
|
||||
}
|
||||
|
|
|
|||
74
src/mat3.rs
74
src/mat3.rs
|
|
@ -78,7 +78,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Mat3<T> {
|
||||
fn from_value(value: T) -> Mat3<T> {
|
||||
Matrix3::new(value, zero(), zero(),
|
||||
zero(), value, zero(),
|
||||
zero(), zero(), value)
|
||||
|
|
@ -98,7 +98,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn identity() -> Mat3<T> {
|
||||
fn identity() -> Mat3<T> {
|
||||
Matrix3::new( one::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), one::<T>())
|
||||
|
|
@ -118,7 +118,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn zero() -> Mat3<T> {
|
||||
fn zero() -> Mat3<T> {
|
||||
Matrix3::new(zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>())
|
||||
|
|
@ -270,7 +270,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn new(c0r0:T, c0r1:T, c0r2:T,
|
||||
fn new(c0r0:T, c0r1:T, c0r2:T,
|
||||
c1r0:T, c1r1:T, c1r2:T,
|
||||
c2r0:T, c2r1:T, c2r2:T) -> Mat3<T> {
|
||||
Matrix3::from_cols(Vector3::new::<T,Vec3<T>>(c0r0, c0r1, c0r2),
|
||||
|
|
@ -299,7 +299,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_cols(c0: Vec3<T>,
|
||||
fn from_cols(c0: Vec3<T>,
|
||||
c1: Vec3<T>,
|
||||
c2: Vec3<T>) -> Mat3<T> {
|
||||
Mat3 { x: c0, y: c1, z: c2 }
|
||||
|
|
@ -309,7 +309,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* Construct a matrix from an angular rotation around the `x` axis
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_angle_x(radians: T) -> Mat3<T> {
|
||||
fn from_angle_x(radians: T) -> Mat3<T> {
|
||||
// http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
|
||||
let cos_theta = cos(radians);
|
||||
let sin_theta = sin(radians);
|
||||
|
|
@ -323,7 +323,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* Construct a matrix from an angular rotation around the `y` axis
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_angle_y(radians: T) -> Mat3<T> {
|
||||
fn from_angle_y(radians: T) -> Mat3<T> {
|
||||
// http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
|
||||
let cos_theta = cos(radians);
|
||||
let sin_theta = sin(radians);
|
||||
|
|
@ -337,7 +337,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* Construct a matrix from an angular rotation around the `z` axis
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_angle_z(radians: T) -> Mat3<T> {
|
||||
fn from_angle_z(radians: T) -> Mat3<T> {
|
||||
// http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
|
||||
let cos_theta = cos(radians);
|
||||
let sin_theta = sin(radians);
|
||||
|
|
@ -357,7 +357,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* * `theta_z` - the angular rotation around the `z` axis (roll)
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Mat3<T> {
|
||||
fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Mat3<T> {
|
||||
// http://en.wikipedia.org/wiki/Rotation_matrix#General_rotations
|
||||
let cx = cos(radians_x);
|
||||
let sx = sin(radians_x);
|
||||
|
|
@ -375,7 +375,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* Construct a matrix from an axis and an angular rotation
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
|
||||
fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
|
||||
let c = cos(radians);
|
||||
let s = sin(radians);
|
||||
let _1_c = one::<T>() - c;
|
||||
|
|
@ -390,12 +390,12 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Mat3<T> {
|
||||
fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Mat3<T> {
|
||||
Matrix3::from_cols(x, y, z)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Mat3<T> {
|
||||
fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Mat3<T> {
|
||||
let dir_ = dir.normalize();
|
||||
let side = dir_.cross(&up.normalize());
|
||||
let up_ = side.cross(&dir_).normalize();
|
||||
|
|
@ -596,42 +596,42 @@ pub type dmat3 = Mat3<f64>; // a 3×3 double-precision floating-point matrix
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl mat3 {
|
||||
#[inline(always)] static fn new(c0r0: f32, c0r1: f32, c0r2: f32, c1r0: f32, c1r1: f32, c1r2: f32, c2r0: f32, c2r1: f32, c2r2: f32)
|
||||
#[inline(always)] fn new(c0r0: f32, c0r1: f32, c0r2: f32, c1r0: f32, c1r1: f32, c1r2: f32, c2r0: f32, c2r1: f32, c2r2: f32)
|
||||
-> mat3 { Matrix3::new(c0r0, c0r1, c0r2, c1r0, c1r1, c1r2, c2r0, c2r1, c2r2) }
|
||||
#[inline(always)] static fn from_cols(c0: vec3, c1: vec3, c2: vec3)
|
||||
#[inline(always)] fn from_cols(c0: vec3, c1: vec3, c2: vec3)
|
||||
-> mat3 { Matrix3::from_cols(c0, c1, c2) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> mat3 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f32) -> mat3 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> mat3 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> mat3 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> mat3 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> mat3 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn from_angle_x(radians: f32) -> mat3 { Matrix3::from_angle_x(radians) }
|
||||
#[inline(always)] static fn from_angle_y(radians: f32) -> mat3 { Matrix3::from_angle_y(radians) }
|
||||
#[inline(always)] static fn from_angle_z(radians: f32) -> mat3 { Matrix3::from_angle_z(radians) }
|
||||
#[inline(always)] static fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32) -> mat3 { Matrix3::from_angle_xyz(radians_x, radians_y, radians_z) }
|
||||
#[inline(always)] static fn from_angle_axis(radians: f32, axis: &vec3) -> mat3 { Matrix3::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] static fn from_axes(x: vec3, y: vec3, z: vec3) -> mat3 { Matrix3::from_axes(x, y, z) }
|
||||
#[inline(always)] static fn look_at(dir: &vec3, up: &vec3) -> mat3 { Matrix3::look_at(dir, up) }
|
||||
#[inline(always)] fn from_angle_x(radians: f32) -> mat3 { Matrix3::from_angle_x(radians) }
|
||||
#[inline(always)] fn from_angle_y(radians: f32) -> mat3 { Matrix3::from_angle_y(radians) }
|
||||
#[inline(always)] fn from_angle_z(radians: f32) -> mat3 { Matrix3::from_angle_z(radians) }
|
||||
#[inline(always)] fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32) -> mat3 { Matrix3::from_angle_xyz(radians_x, radians_y, radians_z) }
|
||||
#[inline(always)] fn from_angle_axis(radians: f32, axis: &vec3) -> mat3 { Matrix3::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] fn from_axes(x: vec3, y: vec3, z: vec3) -> mat3 { Matrix3::from_axes(x, y, z) }
|
||||
#[inline(always)] fn look_at(dir: &vec3, up: &vec3) -> mat3 { Matrix3::look_at(dir, up) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn rows() -> uint { 3 }
|
||||
#[inline(always)] static fn cols() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<mat3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn rows() -> uint { 3 }
|
||||
#[inline(always)] fn cols() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<mat3>() }
|
||||
}
|
||||
|
||||
|
||||
impl dmat3 {
|
||||
#[inline(always)] static fn new(c0r0: f64, c0r1: f64, c0r2: f64, c1r0: f64, c1r1: f64, c1r2: f64, c2r0: f64, c2r1: f64, c2r2: f64)
|
||||
#[inline(always)] fn new(c0r0: f64, c0r1: f64, c0r2: f64, c1r0: f64, c1r1: f64, c1r2: f64, c2r0: f64, c2r1: f64, c2r2: f64)
|
||||
-> dmat3 { Matrix3::new(c0r0, c0r1, c0r2, c1r0, c1r1, c1r2, c2r0, c2r1, c2r2) }
|
||||
#[inline(always)] static fn from_cols(c0: dvec3, c1: dvec3, c2: dvec3)
|
||||
#[inline(always)] fn from_cols(c0: dvec3, c1: dvec3, c2: dvec3)
|
||||
-> dmat3 { Matrix3::from_cols(c0, c1, c2) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dmat3 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dmat3 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> dmat3 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> dmat3 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> dmat3 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> dmat3 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn rows() -> uint { 3 }
|
||||
#[inline(always)] static fn cols() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dmat3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn rows() -> uint { 3 }
|
||||
#[inline(always)] fn cols() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dmat3>() }
|
||||
}
|
||||
|
|
|
|||
46
src/mat4.rs
46
src/mat4.rs
|
|
@ -78,7 +78,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Mat4<T> {
|
||||
fn from_value(value: T) -> Mat4<T> {
|
||||
Matrix4::new(value, zero(), zero(), zero(),
|
||||
zero(), value, zero(), zero(),
|
||||
zero(), zero(), value, zero(),
|
||||
|
|
@ -101,7 +101,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn identity() -> Mat4<T> {
|
||||
fn identity() -> Mat4<T> {
|
||||
Matrix4::new( one::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), one::<T>(), zero::<T>(),
|
||||
|
|
@ -124,7 +124,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn zero() -> Mat4<T> {
|
||||
fn zero() -> Mat4<T> {
|
||||
Matrix4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
|
|
@ -357,7 +357,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
|
||||
fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
|
||||
c1r0: T, c1r1: T, c1r2: T, c1r3: T,
|
||||
c2r0: T, c2r1: T, c2r2: T, c2r3: T,
|
||||
c3r0: T, c3r1: T, c3r2: T, c3r3: T) -> Mat4<T> {
|
||||
|
|
@ -391,7 +391,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* ~~~
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_cols(c0: Vec4<T>,
|
||||
fn from_cols(c0: Vec4<T>,
|
||||
c1: Vec4<T>,
|
||||
c2: Vec4<T>,
|
||||
c3: Vec4<T>) -> Mat4<T> {
|
||||
|
|
@ -533,33 +533,33 @@ pub type dmat4 = Mat4<f64>; // a 4×4 double-precision floating-point matrix
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl mat4 {
|
||||
#[inline(always)] static fn new(c0r0: f32, c0r1: f32, c0r2: f32, c0r3: f32, c1r0: f32, c1r1: f32, c1r2: f32, c1r3: f32, c2r0: f32, c2r1: f32, c2r2: f32, c2r3: f32, c3r0: f32, c3r1: f32, c3r2: f32, c3r3: f32)
|
||||
#[inline(always)] fn new(c0r0: f32, c0r1: f32, c0r2: f32, c0r3: f32, c1r0: f32, c1r1: f32, c1r2: f32, c1r3: f32, c2r0: f32, c2r1: f32, c2r2: f32, c2r3: f32, c3r0: f32, c3r1: f32, c3r2: f32, c3r3: f32)
|
||||
-> mat4 { Matrix4::new(c0r0, c0r1, c0r2, c0r3, c1r0, c1r1, c1r2, c1r3, c2r0, c2r1, c2r2, c2r3, c3r0, c3r1, c3r2, c3r3) }
|
||||
#[inline(always)] static fn from_cols(c0: vec4, c1: vec4, c2: vec4, c3: vec4)
|
||||
#[inline(always)] fn from_cols(c0: vec4, c1: vec4, c2: vec4, c3: vec4)
|
||||
-> mat4 { Matrix4::from_cols(c0, c1, c2, c3) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> mat4 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f32) -> mat4 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> mat4 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> mat4 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> mat4 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> mat4 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn rows() -> uint { 4 }
|
||||
#[inline(always)] static fn cols() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<mat4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn rows() -> uint { 4 }
|
||||
#[inline(always)] fn cols() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<mat4>() }
|
||||
}
|
||||
|
||||
impl dmat4 {
|
||||
#[inline(always)] static fn new(c0r0: f64, c0r1: f64, c0r2: f64, c0r3: f64, c1r0: f64, c1r1: f64, c1r2: f64, c1r3: f64, c2r0: f64, c2r1: f64, c2r2: f64, c2r3: f64, c3r0: f64, c3r1: f64, c3r2: f64, c3r3: f64)
|
||||
#[inline(always)] fn new(c0r0: f64, c0r1: f64, c0r2: f64, c0r3: f64, c1r0: f64, c1r1: f64, c1r2: f64, c1r3: f64, c2r0: f64, c2r1: f64, c2r2: f64, c2r3: f64, c3r0: f64, c3r1: f64, c3r2: f64, c3r3: f64)
|
||||
-> dmat4 { Matrix4::new(c0r0, c0r1, c0r2, c0r3, c1r0, c1r1, c1r2, c1r3, c2r0, c2r1, c2r2, c2r3, c3r0, c3r1, c3r2, c3r3) }
|
||||
#[inline(always)] static fn from_cols(c0: dvec4, c1: dvec4, c2: dvec4, c3: dvec4)
|
||||
#[inline(always)] fn from_cols(c0: dvec4, c1: dvec4, c2: dvec4, c3: dvec4)
|
||||
-> dmat4 { Matrix4::from_cols(c0, c1, c2, c3) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dmat4 { Matrix::from_value(v) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dmat4 { Matrix::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn identity() -> dmat4 { Matrix::identity() }
|
||||
#[inline(always)] static fn zero() -> dmat4 { Matrix::zero() }
|
||||
#[inline(always)] fn identity() -> dmat4 { Matrix::identity() }
|
||||
#[inline(always)] fn zero() -> dmat4 { Matrix::zero() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn rows() -> uint { 4 }
|
||||
#[inline(always)] static fn cols() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dmat4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn rows() -> uint { 4 }
|
||||
#[inline(always)] fn cols() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dmat4>() }
|
||||
}
|
||||
|
|
|
|||
66
src/quat.rs
66
src/quat.rs
|
|
@ -61,7 +61,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* * `zk` - the third imaginary component
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn new(w: T, xi: T, yj: T, zk: T) -> Quat<T> {
|
||||
fn new(w: T, xi: T, yj: T, zk: T) -> Quat<T> {
|
||||
Quat::from_sv(w, Vector3::new(xi, yj, zk))
|
||||
}
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* * `v` - a vector containing the three imaginary components
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn from_sv(s: T, v: Vec3<T>) -> Quat<T> {
|
||||
fn from_sv(s: T, v: Vec3<T>) -> Quat<T> {
|
||||
Quat { s: s, v: v }
|
||||
}
|
||||
|
||||
|
|
@ -84,7 +84,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* The multiplicative identity, ie: `q = 1 + 0i + 0j + 0i`
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn identity() -> Quat<T> {
|
||||
fn identity() -> Quat<T> {
|
||||
Quat::new(one(), zero(), zero(), zero())
|
||||
}
|
||||
|
||||
|
|
@ -94,30 +94,30 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
* The additive identity, ie: `q = 0 + 0i + 0j + 0i`
|
||||
*/
|
||||
#[inline(always)]
|
||||
static fn zero() -> Quat<T> {
|
||||
fn zero() -> Quat<T> {
|
||||
Quat::new(zero(), zero(), zero(), zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle_x(radians: T) -> Quat<T> {
|
||||
fn from_angle_x(radians: T) -> Quat<T> {
|
||||
let _2 = Number::from(2);
|
||||
Quat::new(cos(radians / _2), sin(radians), zero(), zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle_y(radians: T) -> Quat<T> {
|
||||
fn from_angle_y(radians: T) -> Quat<T> {
|
||||
let _2 = Number::from(2);
|
||||
Quat::new(cos(radians / _2), zero(), sin(radians), zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle_z(radians: T) -> Quat<T> {
|
||||
fn from_angle_z(radians: T) -> Quat<T> {
|
||||
let _2 = Number::from(2);
|
||||
Quat::new(cos(radians / _2), zero(), zero(), sin(radians))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Quat<T> {
|
||||
fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Quat<T> {
|
||||
// http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Conversion
|
||||
let _2 = Number::from(2);
|
||||
let xdiv2 = radians_x / _2;
|
||||
|
|
@ -130,13 +130,13 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Quat<T> {
|
||||
fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Quat<T> {
|
||||
let half = radians / Number::from(2);
|
||||
Quat::from_sv(cos(half), axis.mul_t(sin(half)))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Quat<T> {
|
||||
fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Quat<T> {
|
||||
let m: Mat3<T> = Matrix3::from_axes(x, y, z); m.to_quat()
|
||||
}
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
|
|||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Quat<T> {
|
||||
fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Quat<T> {
|
||||
let m: Mat3<T> = Matrix3::look_at(dir, up); m.to_quat()
|
||||
}
|
||||
|
||||
|
|
@ -431,33 +431,33 @@ pub type dquat = Quat<f64>; /// a double-precision floating-point qu
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl quat {
|
||||
#[inline(always)] static fn new(w: f32, xi: f32, yj: f32, zk: f32) -> quat { Quat::new(w, xi, yj, zk) }
|
||||
#[inline(always)] static fn from_sv(s: f32, v: vec3) -> quat { Quat::from_sv(s, v) }
|
||||
#[inline(always)] static fn identity() -> quat { Quat::identity() }
|
||||
#[inline(always)] static fn zero() -> quat { Quat::zero() }
|
||||
#[inline(always)] fn new(w: f32, xi: f32, yj: f32, zk: f32) -> quat { Quat::new(w, xi, yj, zk) }
|
||||
#[inline(always)] fn from_sv(s: f32, v: vec3) -> quat { Quat::from_sv(s, v) }
|
||||
#[inline(always)] fn identity() -> quat { Quat::identity() }
|
||||
#[inline(always)] fn zero() -> quat { Quat::zero() }
|
||||
|
||||
#[inline(always)] static fn from_angle_x(radians: f32) -> quat { Quat::from_angle_x(radians) }
|
||||
#[inline(always)] static fn from_angle_y(radians: f32) -> quat { Quat::from_angle_y(radians) }
|
||||
#[inline(always)] static fn from_angle_z(radians: f32) -> quat { Quat::from_angle_z(radians) }
|
||||
#[inline(always)] static fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32)
|
||||
#[inline(always)] fn from_angle_x(radians: f32) -> quat { Quat::from_angle_x(radians) }
|
||||
#[inline(always)] fn from_angle_y(radians: f32) -> quat { Quat::from_angle_y(radians) }
|
||||
#[inline(always)] fn from_angle_z(radians: f32) -> quat { Quat::from_angle_z(radians) }
|
||||
#[inline(always)] fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32)
|
||||
-> quat { Quat::from_angle_xyz(radians_x, radians_y, radians_z) }
|
||||
#[inline(always)] static fn from_angle_axis(radians: f32, axis: &vec3) -> quat { Quat::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] static fn from_axes(x: vec3, y: vec3, z: vec3) -> quat { Quat::from_axes(x, y, z) }
|
||||
#[inline(always)] static fn look_at(dir: &vec3, up: &vec3) -> quat { Quat::look_at(dir, up) }
|
||||
#[inline(always)] fn from_angle_axis(radians: f32, axis: &vec3) -> quat { Quat::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] fn from_axes(x: vec3, y: vec3, z: vec3) -> quat { Quat::from_axes(x, y, z) }
|
||||
#[inline(always)] fn look_at(dir: &vec3, up: &vec3) -> quat { Quat::look_at(dir, up) }
|
||||
}
|
||||
|
||||
impl dquat {
|
||||
#[inline(always)] static fn new(w: f64, xi: f64, yj: f64, zk: f64) -> dquat { Quat::new(w, xi, yj, zk) }
|
||||
#[inline(always)] static fn from_sv(s: f64, v: dvec3) -> dquat { Quat::from_sv(s, v) }
|
||||
#[inline(always)] static fn identity() -> dquat { Quat::identity() }
|
||||
#[inline(always)] static fn zero() -> dquat { Quat::zero() }
|
||||
#[inline(always)] fn new(w: f64, xi: f64, yj: f64, zk: f64) -> dquat { Quat::new(w, xi, yj, zk) }
|
||||
#[inline(always)] fn from_sv(s: f64, v: dvec3) -> dquat { Quat::from_sv(s, v) }
|
||||
#[inline(always)] fn identity() -> dquat { Quat::identity() }
|
||||
#[inline(always)] fn zero() -> dquat { Quat::zero() }
|
||||
|
||||
#[inline(always)] static fn from_angle_x(radians: f64) -> dquat { Quat::from_angle_x(radians) }
|
||||
#[inline(always)] static fn from_angle_y(radians: f64) -> dquat { Quat::from_angle_y(radians) }
|
||||
#[inline(always)] static fn from_angle_z(radians: f64) -> dquat { Quat::from_angle_z(radians) }
|
||||
#[inline(always)] static fn from_angle_xyz(radians_x: f64, radians_y: f64, radians_z: f64)
|
||||
#[inline(always)] fn from_angle_x(radians: f64) -> dquat { Quat::from_angle_x(radians) }
|
||||
#[inline(always)] fn from_angle_y(radians: f64) -> dquat { Quat::from_angle_y(radians) }
|
||||
#[inline(always)] fn from_angle_z(radians: f64) -> dquat { Quat::from_angle_z(radians) }
|
||||
#[inline(always)] fn from_angle_xyz(radians_x: f64, radians_y: f64, radians_z: f64)
|
||||
-> dquat { Quat::from_angle_xyz(radians_x, radians_y, radians_z) }
|
||||
#[inline(always)] static fn from_angle_axis(radians: f64, axis: &dvec3) -> dquat { Quat::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] static fn from_axes(x: dvec3, y: dvec3, z: dvec3) -> dquat { Quat::from_axes(x, y, z) }
|
||||
#[inline(always)] static fn look_at(dir: &dvec3, up: &dvec3) -> dquat { Quat::look_at(dir, up) }
|
||||
#[inline(always)] fn from_angle_axis(radians: f64, axis: &dvec3) -> dquat { Quat::from_angle_axis(radians, axis) }
|
||||
#[inline(always)] fn from_axes(x: dvec3, y: dvec3, z: dvec3) -> dquat { Quat::from_axes(x, y, z) }
|
||||
#[inline(always)] fn look_at(dir: &dvec3, up: &dvec3) -> dquat { Quat::look_at(dir, up) }
|
||||
}
|
||||
|
|
|
|||
30
src/vec.rs
30
src/vec.rs
|
|
@ -21,7 +21,7 @@ pub trait Vector<T>: Index<uint, T> + Eq {
|
|||
/**
|
||||
* Construct the vector from a single value, copying it to each component
|
||||
*/
|
||||
static fn from_value(value: T) -> Self;
|
||||
fn from_value(value: T) -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
|
|
@ -47,21 +47,21 @@ pub trait MutableVector<T>: Vector<T> {
|
|||
* A generic 2-dimensional vector
|
||||
*/
|
||||
pub trait Vector2<T>: Vector<T> {
|
||||
static fn new(x: T, y: T) -> Self;
|
||||
fn new(x: T, y: T) -> Self;
|
||||
}
|
||||
|
||||
/**
|
||||
* A generic 3-dimensional vector
|
||||
*/
|
||||
pub trait Vector3<T>: Vector<T> {
|
||||
static fn new(x: T, y: T, z: T) -> Self;
|
||||
fn new(x: T, y: T, z: T) -> Self;
|
||||
}
|
||||
|
||||
/**
|
||||
* A generic 4-dimensional vector
|
||||
*/
|
||||
pub trait Vector4<T>: Vector<T> {
|
||||
static fn new(x: T, y: T, z: T, w: T) -> Self;
|
||||
fn new(x: T, y: T, z: T, w: T) -> Self;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -75,7 +75,7 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
|
|||
*
|
||||
* A vector with each component set to one
|
||||
*/
|
||||
static fn identity() -> Self;
|
||||
fn identity() -> Self;
|
||||
|
||||
/**
|
||||
* The null vector
|
||||
|
|
@ -84,7 +84,7 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
|
|||
*
|
||||
* A vector with each component set to zero
|
||||
*/
|
||||
static fn zero() -> Self;
|
||||
fn zero() -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
|
|
@ -139,8 +139,8 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
|
|||
* A 2-dimensional vector with numeric components
|
||||
*/
|
||||
pub trait NumericVector2<T>: NumericVector<T> {
|
||||
static fn unit_x() -> Self;
|
||||
static fn unit_y() -> Self;
|
||||
fn unit_x() -> Self;
|
||||
fn unit_y() -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
|
|
@ -154,9 +154,9 @@ pub trait NumericVector2<T>: NumericVector<T> {
|
|||
* A 3-dimensional vector with numeric components
|
||||
*/
|
||||
pub trait NumericVector3<T>: NumericVector<T> {
|
||||
static fn unit_x() -> Self;
|
||||
static fn unit_y() -> Self;
|
||||
static fn unit_z() -> Self;
|
||||
fn unit_x() -> Self;
|
||||
fn unit_y() -> Self;
|
||||
fn unit_z() -> Self;
|
||||
|
||||
/**
|
||||
* # Return value
|
||||
|
|
@ -170,10 +170,10 @@ pub trait NumericVector3<T>: NumericVector<T> {
|
|||
* A 4-dimensional vector with numeric components
|
||||
*/
|
||||
pub trait NumericVector4<T>: NumericVector<T> {
|
||||
static fn unit_x() -> Self;
|
||||
static fn unit_y() -> Self;
|
||||
static fn unit_z() -> Self;
|
||||
static fn unit_w() -> Self;
|
||||
fn unit_x() -> Self;
|
||||
fn unit_y() -> Self;
|
||||
fn unit_z() -> Self;
|
||||
fn unit_w() -> Self;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
84
src/vec2.rs
84
src/vec2.rs
|
|
@ -45,7 +45,7 @@ pub struct Vec2<T> { x: T, y: T }
|
|||
|
||||
impl<T:Copy + Eq> Vector<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Vec2<T> {
|
||||
fn from_value(value: T) -> Vec2<T> {
|
||||
Vector2::new(value, value)
|
||||
}
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ impl<T:Copy + Eq> Vector<T> for Vec2<T> {
|
|||
|
||||
impl<T> Vector2<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
static fn new(x: T, y: T ) -> Vec2<T> {
|
||||
fn new(x: T, y: T ) -> Vec2<T> {
|
||||
Vec2 { x: x, y: y }
|
||||
}
|
||||
}
|
||||
|
|
@ -92,12 +92,12 @@ impl<T:Copy> MutableVector<T> for Vec2<T> {
|
|||
|
||||
impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
static fn identity() -> Vec2<T> {
|
||||
fn identity() -> Vec2<T> {
|
||||
Vector2::new(one::<T>(), one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn zero() -> Vec2<T> {
|
||||
fn zero() -> Vec2<T> {
|
||||
Vector2::new(zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
|
|
@ -159,12 +159,12 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
|
|||
|
||||
impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector2<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
static fn unit_x() -> Vec2<T> {
|
||||
fn unit_x() -> Vec2<T> {
|
||||
Vector2::new(one::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_y() -> Vec2<T> {
|
||||
fn unit_y() -> Vec2<T> {
|
||||
Vector2::new(zero::<T>(), one::<T>())
|
||||
}
|
||||
|
||||
|
|
@ -367,63 +367,63 @@ pub type uvec2 = Vec2<u32>; // a two-component unsigned integer vector
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl vec2 {
|
||||
#[inline(always)] static fn new(x: f32, y: f32) -> vec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> vec2 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> vec2 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> vec2 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f32, y: f32) -> vec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] fn from_value(v: f32) -> vec2 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> vec2 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> vec2 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> vec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> vec2 { NumericVector2::unit_y() }
|
||||
#[inline(always)] fn unit_x() -> vec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> vec2 { NumericVector2::unit_y() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<vec2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<vec2>() }
|
||||
}
|
||||
|
||||
impl dvec2 {
|
||||
#[inline(always)] static fn new(x: f64, y: f64) -> dvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dvec2 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> dvec2 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> dvec2 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f64, y: f64) -> dvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dvec2 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> dvec2 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> dvec2 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> dvec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> dvec2 { NumericVector2::unit_y() }
|
||||
#[inline(always)] fn unit_x() -> dvec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> dvec2 { NumericVector2::unit_y() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dvec2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dvec2>() }
|
||||
}
|
||||
|
||||
impl bvec2 {
|
||||
#[inline(always)] static fn new(x: bool, y: bool) -> bvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] static fn from_value(v: bool) -> bvec2 { Vector::from_value(v) }
|
||||
#[inline(always)] fn new(x: bool, y: bool) -> bvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] fn from_value(v: bool) -> bvec2 { Vector::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<bvec2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<bvec2>() }
|
||||
}
|
||||
|
||||
impl ivec2 {
|
||||
#[inline(always)] static fn new(x: i32, y: i32) -> ivec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] static fn from_value(v: i32) -> ivec2 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> ivec2 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> ivec2 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: i32, y: i32) -> ivec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] fn from_value(v: i32) -> ivec2 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> ivec2 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> ivec2 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> ivec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> ivec2 { NumericVector2::unit_y() }
|
||||
#[inline(always)] fn unit_x() -> ivec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> ivec2 { NumericVector2::unit_y() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<ivec2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<ivec2>() }
|
||||
}
|
||||
|
||||
impl uvec2 {
|
||||
#[inline(always)] static fn new(x: u32, y: u32) -> uvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] static fn from_value(v: u32) -> uvec2 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> uvec2 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> uvec2 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: u32, y: u32) -> uvec2 { Vector2::new(x, y) }
|
||||
#[inline(always)] fn from_value(v: u32) -> uvec2 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> uvec2 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> uvec2 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> uvec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> uvec2 { NumericVector2::unit_y() }
|
||||
#[inline(always)] fn unit_x() -> uvec2 { NumericVector2::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> uvec2 { NumericVector2::unit_y() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 2 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<uvec2>() }
|
||||
#[inline(always)] fn dim() -> uint { 2 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<uvec2>() }
|
||||
}
|
||||
|
||||
// Type aliases named in a more 'Rustic' style
|
||||
|
|
|
|||
94
src/vec3.rs
94
src/vec3.rs
|
|
@ -47,7 +47,7 @@ pub struct Vec3<T> { x: T, y: T, z: T }
|
|||
|
||||
impl<T:Copy + Eq> Vector<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Vec3<T> {
|
||||
fn from_value(value: T) -> Vec3<T> {
|
||||
Vector3::new(value, value, value)
|
||||
}
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ impl<T:Copy + Eq> Vector<T> for Vec3<T> {
|
|||
|
||||
impl<T> Vector3<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
static fn new(x: T, y: T, z: T) -> Vec3<T> {
|
||||
fn new(x: T, y: T, z: T) -> Vec3<T> {
|
||||
Vec3 { x: x, y: y, z: z }
|
||||
}
|
||||
}
|
||||
|
|
@ -95,12 +95,12 @@ impl<T:Copy> MutableVector<T> for Vec3<T> {
|
|||
|
||||
impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
static fn identity() -> Vec3<T> {
|
||||
fn identity() -> Vec3<T> {
|
||||
Vector3::new(one::<T>(), one::<T>(), one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn zero() -> Vec3<T> {
|
||||
fn zero() -> Vec3<T> {
|
||||
Vector3::new(zero::<T>(), zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
|
|
@ -170,17 +170,17 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
|
|||
|
||||
impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector3<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
static fn unit_x() -> Vec3<T> {
|
||||
fn unit_x() -> Vec3<T> {
|
||||
Vector3::new(one::<T>(), zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_y() -> Vec3<T> {
|
||||
fn unit_y() -> Vec3<T> {
|
||||
Vector3::new(zero::<T>(), one::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_z() -> Vec3<T> {
|
||||
fn unit_z() -> Vec3<T> {
|
||||
Vector3::new(zero::<T>(), zero::<T>(), one::<T>())
|
||||
}
|
||||
|
||||
|
|
@ -406,65 +406,65 @@ pub type uvec3 = Vec3<u32>; // a three-component unsigned integer vector
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl vec3 {
|
||||
#[inline(always)] static fn new(x: f32, y: f32, z: f32) -> vec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> vec3 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> vec3 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> vec3 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f32, y: f32, z: f32) -> vec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] fn from_value(v: f32) -> vec3 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> vec3 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> vec3 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> vec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> vec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> vec3 { NumericVector3::unit_z() }
|
||||
#[inline(always)] fn unit_x() -> vec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> vec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> vec3 { NumericVector3::unit_z() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<vec3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<vec3>() }
|
||||
}
|
||||
|
||||
impl dvec3 {
|
||||
#[inline(always)] static fn new(x: f64, y: f64, z: f64) -> dvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dvec3 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> dvec3 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> dvec3 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f64, y: f64, z: f64) -> dvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dvec3 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> dvec3 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> dvec3 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> dvec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> dvec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> dvec3 { NumericVector3::unit_z() }
|
||||
#[inline(always)] fn unit_x() -> dvec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> dvec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> dvec3 { NumericVector3::unit_z() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dvec3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dvec3>() }
|
||||
}
|
||||
|
||||
impl bvec3 {
|
||||
#[inline(always)] static fn new(x: bool, y: bool, z: bool) -> bvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] static fn from_value(v: bool) -> bvec3 { Vector::from_value(v) }
|
||||
#[inline(always)] fn new(x: bool, y: bool, z: bool) -> bvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] fn from_value(v: bool) -> bvec3 { Vector::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<bvec3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<bvec3>() }
|
||||
}
|
||||
|
||||
impl ivec3 {
|
||||
#[inline(always)] static fn new(x: i32, y: i32, z: i32) -> ivec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] static fn from_value(v: i32) -> ivec3 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> ivec3 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> ivec3 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: i32, y: i32, z: i32) -> ivec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] fn from_value(v: i32) -> ivec3 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> ivec3 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> ivec3 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> ivec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> ivec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> ivec3 { NumericVector3::unit_z() }
|
||||
#[inline(always)] fn unit_x() -> ivec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> ivec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> ivec3 { NumericVector3::unit_z() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<ivec3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<ivec3>() }
|
||||
}
|
||||
|
||||
impl uvec3 {
|
||||
#[inline(always)] static fn new(x: u32, y: u32, z: u32) -> uvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] static fn from_value(v: u32) -> uvec3 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> uvec3 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> uvec3 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: u32, y: u32, z: u32) -> uvec3 { Vector3::new(x, y, z) }
|
||||
#[inline(always)] fn from_value(v: u32) -> uvec3 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> uvec3 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> uvec3 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> uvec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> uvec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> uvec3 { NumericVector3::unit_z() }
|
||||
#[inline(always)] fn unit_x() -> uvec3 { NumericVector3::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> uvec3 { NumericVector3::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> uvec3 { NumericVector3::unit_z() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 3 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<uvec3>() }
|
||||
#[inline(always)] fn dim() -> uint { 3 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<uvec3>() }
|
||||
}
|
||||
|
|
|
|||
104
src/vec4.rs
104
src/vec4.rs
|
|
@ -45,7 +45,7 @@ pub struct Vec4<T> { x: T, y: T, z: T, w: T }
|
|||
|
||||
impl<T:Copy + Eq> Vector<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
static fn from_value(value: T) -> Vec4<T> {
|
||||
fn from_value(value: T) -> Vec4<T> {
|
||||
Vector4::new(value, value, value, value)
|
||||
}
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ impl<T:Copy + Eq> Vector<T> for Vec4<T> {
|
|||
|
||||
impl<T> Vector4<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
static fn new(x: T, y: T, z: T, w: T) -> Vec4<T> {
|
||||
fn new(x: T, y: T, z: T, w: T) -> Vec4<T> {
|
||||
Vec4 { x: x, y: y, z: z, w: w }
|
||||
}
|
||||
}
|
||||
|
|
@ -94,12 +94,12 @@ impl<T:Copy> MutableVector<T> for Vec4<T> {
|
|||
|
||||
impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
static fn identity() -> Vec4<T> {
|
||||
fn identity() -> Vec4<T> {
|
||||
Vector4::new(one::<T>(), one::<T>(), one::<T>(), one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn zero() -> Vec4<T> {
|
||||
fn zero() -> Vec4<T> {
|
||||
Vector4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
|
|
@ -177,22 +177,22 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
|
|||
|
||||
impl<T:Copy + Number> NumericVector4<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
static fn unit_x() -> Vec4<T> {
|
||||
fn unit_x() -> Vec4<T> {
|
||||
Vector4::new(one::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_y() -> Vec4<T> {
|
||||
fn unit_y() -> Vec4<T> {
|
||||
Vector4::new(zero::<T>(), one::<T>(), zero::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_z() -> Vec4<T> {
|
||||
fn unit_z() -> Vec4<T> {
|
||||
Vector4::new(zero::<T>(), zero::<T>(), one::<T>(), zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
static fn unit_w() -> Vec4<T> {
|
||||
fn unit_w() -> Vec4<T> {
|
||||
Vector4::new(zero::<T>(), zero::<T>(), zero::<T>(), one::<T>())
|
||||
}
|
||||
}
|
||||
|
|
@ -411,70 +411,70 @@ pub type uvec4 = Vec4<u32>; // a four-component unsigned integer vector
|
|||
// Static method wrappers for GLSL-style types
|
||||
|
||||
impl vec4 {
|
||||
#[inline(always)] static fn new(x: f32, y: f32, z: f32, w: f32) -> vec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] static fn from_value(v: f32) -> vec4 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> vec4 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> vec4 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f32, y: f32, z: f32, w: f32) -> vec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] fn from_value(v: f32) -> vec4 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> vec4 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> vec4 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> vec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> vec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> vec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] static fn unit_w() -> vec4 { NumericVector4::unit_w() }
|
||||
#[inline(always)] fn unit_x() -> vec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> vec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> vec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] fn unit_w() -> vec4 { NumericVector4::unit_w() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<vec4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<vec4>() }
|
||||
}
|
||||
|
||||
impl dvec4 {
|
||||
#[inline(always)] static fn new(x: f64, y: f64, z: f64, w: f64) -> dvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] static fn from_value(v: f64) -> dvec4 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> dvec4 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> dvec4 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: f64, y: f64, z: f64, w: f64) -> dvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] fn from_value(v: f64) -> dvec4 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> dvec4 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> dvec4 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> dvec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> dvec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> dvec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] static fn unit_w() -> dvec4 { NumericVector4::unit_w() }
|
||||
#[inline(always)] fn unit_x() -> dvec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> dvec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> dvec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] fn unit_w() -> dvec4 { NumericVector4::unit_w() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<dvec4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<dvec4>() }
|
||||
}
|
||||
|
||||
|
||||
impl bvec4 {
|
||||
#[inline(always)] static fn new(x: bool, y: bool, z: bool, w: bool) -> bvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] static fn from_value(v: bool) -> bvec4 { Vector::from_value(v) }
|
||||
#[inline(always)] fn new(x: bool, y: bool, z: bool, w: bool) -> bvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] fn from_value(v: bool) -> bvec4 { Vector::from_value(v) }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<bvec4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<bvec4>() }
|
||||
}
|
||||
|
||||
impl ivec4 {
|
||||
#[inline(always)] static fn new(x: i32, y: i32, z: i32, w: i32) -> ivec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] static fn from_value(v: i32) -> ivec4 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> ivec4 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> ivec4 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: i32, y: i32, z: i32, w: i32) -> ivec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] fn from_value(v: i32) -> ivec4 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> ivec4 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> ivec4 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> ivec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> ivec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> ivec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] static fn unit_w() -> ivec4 { NumericVector4::unit_w() }
|
||||
#[inline(always)] fn unit_x() -> ivec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> ivec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> ivec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] fn unit_w() -> ivec4 { NumericVector4::unit_w() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<ivec4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<ivec4>() }
|
||||
}
|
||||
|
||||
impl uvec4 {
|
||||
#[inline(always)] static fn new(x: u32, y: u32, z: u32, w: u32) -> uvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] static fn from_value(v: u32) -> uvec4 { Vector::from_value(v) }
|
||||
#[inline(always)] static fn identity() -> uvec4 { NumericVector::identity() }
|
||||
#[inline(always)] static fn zero() -> uvec4 { NumericVector::zero() }
|
||||
#[inline(always)] fn new(x: u32, y: u32, z: u32, w: u32) -> uvec4 { Vector4::new(x, y, z, w) }
|
||||
#[inline(always)] fn from_value(v: u32) -> uvec4 { Vector::from_value(v) }
|
||||
#[inline(always)] fn identity() -> uvec4 { NumericVector::identity() }
|
||||
#[inline(always)] fn zero() -> uvec4 { NumericVector::zero() }
|
||||
|
||||
#[inline(always)] static fn unit_x() -> uvec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] static fn unit_y() -> uvec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] static fn unit_z() -> uvec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] static fn unit_w() -> uvec4 { NumericVector4::unit_w() }
|
||||
#[inline(always)] fn unit_x() -> uvec4 { NumericVector4::unit_x() }
|
||||
#[inline(always)] fn unit_y() -> uvec4 { NumericVector4::unit_y() }
|
||||
#[inline(always)] fn unit_z() -> uvec4 { NumericVector4::unit_z() }
|
||||
#[inline(always)] fn unit_w() -> uvec4 { NumericVector4::unit_w() }
|
||||
|
||||
#[inline(always)] static fn dim() -> uint { 4 }
|
||||
#[inline(always)] static fn size_of() -> uint { size_of::<uvec4>() }
|
||||
#[inline(always)] fn dim() -> uint { 4 }
|
||||
#[inline(always)] fn size_of() -> uint { size_of::<uvec4>() }
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue