See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  3D Math Code
  Submitted by



It's just some base library for 3D-Math, but I think, it's not bad. Give it a try. It's not *fully* tested, because I hacked the last files together this morning... but I think, it's very easy to use.

I have included operator overloads for the C++ hardcore freaks, but also the same set as methods ;-)

The Matrix and Quaternion classes return themself after most functions... So people can do:

Matrix4 mat;
mat.SetIdentity().Translate(..).Scale().Rotate(...); and so on.



Hakuna Matata,
Sascha 'EvilOne' Salevsky.

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Mathematics.cpp] - (12,321 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#include "Mathematics.h"

// ------------------------------------------------------------ // Vector2 // ------------------------------------------------------------ ostream& operator<<(ostream& os, Vector2& v) { os << "(" << setprecision(4) << v.x << ", " << v.y << ")"; return os; }

// ------------------------------------------------------------ // Vector3 // ------------------------------------------------------------ ostream& operator<<(ostream& os, Vector3& v) { os << "(" << setprecision(4) << v.x << ", " << v.y << ", " << v.z << ")"; return os; }

// ------------------------------------------------------------ // Plane // ------------------------------------------------------------ ostream& operator<<(ostream& os, Plane& p) { os << "(" << setprecision(4) << p.a << ", " << p.b << ", " << p.c << ", " << p.d << ")"; return os; }

// ------------------------------------------------------------ // Matrix3 // ------------------------------------------------------------ float Matrix3::Identity_Matrix[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f };

ostream& operator<<(ostream& os, Matrix3 &m) { os << setprecision(4); os << "(" << m.M[0] << ", " << m.M[1] << ", " << m.M[2] << ", " << endl << " " << m.M[3] << ", " << m.M[4] << ", " << m.M[5] << ", " << endl << " " << m.M[6] << ", " << m.M[7] << ", " << m.M[8] << ")"; return os; }

// ------------------------------------------------------------ // Matrix4 // ------------------------------------------------------------ float Matrix4::Identity_Matrix[] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f };

float Matrix4::Orientation_Switch_Matrix[] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f };

float Matrix4::Perspective_Matrix[] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f };

void Matrix4::Assign(const Quaternion& other) { float xx = other.x * other.x; float xy = other.x * other.y; float xz = other.x * other.z; float xw = other.x * other.w;

float yy = other.y * other.y; float yz = other.y * other.z; float yw = other.y * other.w;

float zz = other.z * other.z; float zw = other.z * other.w;

M[0] = 1.0f - 2.0f * (yy + zz); M[1] = 2.0f * (xy - zw); M[2] = 2.0f * (xz + yw);

M[4] = 2.0f * (xy + zw); M[5] = 1.0f - 2.0f * (xx + zz); M[6] = 2.0f * (yz - xw);

M[8] = 2.0f * (xz - yw); M[9] = 2.0f * (yz + xw); M[10] = 1.0f - 2.0f * (xx + yy);

M[3] = M[7] = M[11] = M[12] = M[13] = M[14] = 0.0f; M[15] = 1.0f; }

Matrix4& Matrix4::SetRotate(float rx, float ry, float rz) { float a = CosD(rx); float b = SinD(rx); float c = CosD(ry); float d = SinD(ry); float e = CosD(rz); float f = SinD(rz); float ad = a * d; float bd = b * d;

M[0] = c * e; M[1] = -c * f; M[2] = -d;

M[4] = -bd * e + a * f; M[5] = bd * f + a * e; M[6] = -b * c;

M[8] = ad * e + b * f; M[9] = -ad * f + b * e; M[10] = a * c;

M[3] = M[7] = M[11] = M[12] = M[13] = M[14] = 0.0f; M[15] = 1.0f; return *this; }

Matrix4& Matrix4::SetRotate(float angle, float x, float y, float z) { float xx, yy, zz, xy, yz, zx, xs, ys, zs, c_complement; float s = SinD(angle); float c = SinD(angle); float magnitude = (float)sqrt(x * x + y * y + z * z); float *data = M; if(magnitude == 0.0f) { SetIdentity(); return *this; } x /= magnitude; y /= magnitude; z /= magnitude; xx = x * x; yy = y * y; zz = z * z; xy = x * y; yz = y * z; zx = z * x; xs = x * s; ys = y * s; zs = z * s; c_complement = 1.0F - c; data[0] = (c_complement * xx) + c; data[4] = (c_complement * xy) - zs; data[8] = (c_complement * zx) + ys; data[12] = 0.0F; data[1] = (c_complement * xy) + zs; data[5] = (c_complement * yy) + c; data[9] = (c_complement * yz) - xs; data[13] = 0.0F; data[2] = (c_complement * zx) - ys; data[6] = (c_complement * yz) + xs; data[10] = (c_complement * zz) + c; data[14] = 0.0F; data[3] = 0.0F; data[7] = 0.0F; data[11] = 0.0F; data[15] = 1.0F; return *this; }

Matrix4& Matrix4::Transpose() { Transpose(*this); return *this; }

Matrix4& Matrix4::Transpose(const Matrix4& other) { for(int i = 0; i < 4; i++) { for(int j = 0; j < 4; j++) M[i * 4 + j] = other.M[j * 4 + i]; } return *this; }

Matrix4& Matrix4::Adjoint() { Matrix4 tmp; tmp.Assign(*this); Adjoint(tmp); return *this; }

Matrix4& Matrix4::Adjoint(const Matrix4& other) { float a1, a2, a3, a4, b1, b2, b3, b4; float c1, c2, c3, c4, d1, d2, d3, d4; const float *in = other.M; float *out = M;

a1 = (in [(( 0 ) << 2) + ( 0 )]) ; b1 = (in [(( 0 ) << 2) + ( 1 )]) ; c1 = (in [(( 0 ) << 2) + ( 2 )]) ; d1 = (in [(( 0 ) << 2) + ( 3 )]) ; a2 = (in [(( 1 ) << 2) + ( 0 )]) ; b2 = (in [(( 1 ) << 2) + ( 1 )]) ; c2 = (in [(( 1 ) << 2) + ( 2 )]) ; d2 = (in [(( 1 ) << 2) + ( 3 )]) ; a3 = (in [(( 2 ) << 2) + ( 0 )]) ; b3 = (in [(( 2 ) << 2) + ( 1 )]) ; c3 = (in [(( 2 ) << 2) + ( 2 )]) ; d3 = (in [(( 2 ) << 2) + ( 3 )]) ; a4 = (in [(( 3 ) << 2) + ( 0 )]) ; b4 = (in [(( 3 ) << 2) + ( 1 )]) ; c4 = (in [(( 3 ) << 2) + ( 2 )]) ; d4 = (in [(( 3 ) << 2) + ( 3 )]) ;

out[(( 0 ) << 2) + ( 0 )] = Det3x3( b2, b3, b4, c2, c3, c4, d2, d3, d4); out[(( 1 ) << 2) + ( 0 )] = - Det3x3( a2, a3, a4, c2, c3, c4, d2, d3, d4); out[(( 2 ) << 2) + ( 0 )] = Det3x3( a2, a3, a4, b2, b3, b4, d2, d3, d4); out[(( 3 ) << 2) + ( 0 )] = - Det3x3( a2, a3, a4, b2, b3, b4, c2, c3, c4);

out[(( 0 ) << 2) + ( 1 )] = - Det3x3( b1, b3, b4, c1, c3, c4, d1, d3, d4); out[(( 1 ) << 2) + ( 1 )] = Det3x3( a1, a3, a4, c1, c3, c4, d1, d3, d4); out[(( 2 ) << 2) + ( 1 )] = - Det3x3( a1, a3, a4, b1, b3, b4, d1, d3, d4); out[(( 3 ) << 2) + ( 1 )] = Det3x3( a1, a3, a4, b1, b3, b4, c1, c3, c4);

out[(( 0 ) << 2) + ( 2 )] = Det3x3( b1, b2, b4, c1, c2, c4, d1, d2, d4); out[(( 1 ) << 2) + ( 2 )] = - Det3x3( a1, a2, a4, c1, c2, c4, d1, d2, d4); out[(( 2 ) << 2) + ( 2 )] = Det3x3( a1, a2, a4, b1, b2, b4, d1, d2, d4); out[(( 3 ) << 2) + ( 2 )] = - Det3x3( a1, a2, a4, b1, b2, b4, c1, c2, c4);

out[(( 0 ) << 2) + ( 3 )] = - Det3x3( b1, b2, b3, c1, c2, c3, d1, d2, d3); out[(( 1 ) << 2) + ( 3 )] = Det3x3( a1, a2, a3, c1, c2, c3, d1, d2, d3); out[(( 2 ) << 2) + ( 3 )] = - Det3x3( a1, a2, a3, b1, b2, b3, d1, d2, d3); out[(( 3 ) << 2) + ( 3 )] = Det3x3( a1, a2, a3, b1, b2, b3, c1, c2, c3); return *this; }

Matrix4& Matrix4::Invert() { Matrix4 tmp; tmp.Assign(*this); Invert(tmp); return *this; }

Matrix4& Matrix4::Invert(const Matrix4& other) { int i; Adjoint(other); float d = other.Det();

for (i = 0; i < 16; i++) M[i] = M[i] / d; return *this; }

float Matrix4::Det() const { float a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4; a1 = (M [(( 0 ) << 2) + ( 0 )]) ; b1 = (M [(( 0 ) << 2) + ( 1 )]) ; c1 = (M [(( 0 ) << 2) + ( 2 )]) ; d1 = (M [(( 0 ) << 2) + ( 3 )]) ;

a2 = (M [(( 1 ) << 2) + ( 0 )]) ; b2 = (M [(( 1 ) << 2) + ( 1 )]) ; c2 = (M [(( 1 ) << 2) + ( 2 )]) ; d2 = (M [(( 1 ) << 2) + ( 3 )]) ;

a3 = (M [(( 2 ) << 2) + ( 0 )]) ; b3 = (M [(( 2 ) << 2) + ( 1 )]) ; c3 = (M [(( 2 ) << 2) + ( 2 )]) ; d3 = (M [(( 2 ) << 2) + ( 3 )]) ;

a4 = (M [(( 3 ) << 2) + ( 0 )]) ; b4 = (M [(( 3 ) << 2) + ( 1 )]) ; c4 = (M [(( 3 ) << 2) + ( 2 )]) ; d4 = (M [(( 3 ) << 2) + ( 3 )]) ;

return a1 * Det3x3( b2, b3, b4, c2, c3, c4, d2, d3, d4) - b1 * Det3x3( a2, a3, a4, c2, c3, c4, d2, d3, d4) + c1 * Det3x3( a2, a3, a4, b2, b3, b4, d2, d3, d4) - d1 * Det3x3( a2, a3, a4, b2, b3, b4, c2, c3, c4); }

Matrix4& Matrix4::SetProjection(float fov, float aspect, float znear, float zfar) { float top = znear * TanD(fov); float bottom = -top; float left = bottom * aspect; float right = top * aspect; float x = (2.0f * znear) / (right - left); float y = (2.0f * znear) / (top - bottom); float a = (right + left) / (right - left); float b = (top + bottom) / (top - bottom); float c = -(zfar + znear) / (zfar - znear); float d = -(2.0f * zfar * znear) / (zfar - znear); M[0] = x; M[1] = 0.0f; M[2] = 0.0f; M[3] = 0.0f; M[4] = 0.0f; M[5] = y; M[6] = 0.0f; M[7] = 0.0f; M[8] = a; M[9] = b; M[10] = c; M[11] = -1.0f; M[12] = 0.0f; M[13] = 0.0f; M[14] = d; M[15] = 0.0f; return *this; }

Matrix4& Matrix4::SetOthogonal(float znear, float zfar) { float x, y, z; float tx, ty, tz; float small = 0.0f; x = 2.0f / (1.0f + small); y = 2.0f / (1.0f + small); z = -2.0f / (zfar - znear); tx = -(1.0f - small) / (1.0f + small); ty = -(1.0f - small) / (1.0f + small); tz = -(zfar + znear) / (zfar - znear); M[0] = x; M[4] = 0.0f; M[8] = 0.0f; M[12] = tx; M[1] = 0.0f; M[5] = y; M[9] = 0.0f; M[13] = ty; M[2] = 0.0f; M[6] = 0.0f; M[10] = z; M[14] = tz; M[3] = 0.0f; M[7] = 0.0f; M[11] = 0.0f; M[15] = 1.0f; return *this; }

float Matrix4::Det2x2(float a, float b, float c, float d) { return a * d - b * c; } float Matrix4::Det3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3) { return a1 * Det2x2(b2, b3, c2, c3) - b1 * Det2x2(a2, a3, c2, c3) + c1 * Det2x2(a2, a3, b2, b3); }

ostream& operator<<(ostream& os, Matrix4 &m) { os << setprecision(4); os << "(" << m.M[0] << ", " << m.M[1] << ", " << m.M[2] << ", " << m.M[3] << ", " << endl << " " << m.M[4] << ", " << m.M[5] << ", " << m.M[6] << ", " << m.M[7] << ", " << endl << " " << m.M[8] << ", " << m.M[9] << ", " << m.M[10] << ", " << m.M[11] << ", " << endl << " " << m.M[12] << ", " << m.M[13] << ", " << m.M[14] << ", " << m.M[15] << ")"; return os; }

// ------------------------------------------------------------ // Quaternion // ------------------------------------------------------------ void Quaternion::Slerp(const Quaternion& q0, const Quaternion& q1, float t) { float cosom = q0.x * q1.x + q0.y * q1.y + q0.z * q1.z + q0.w * q1.w; float tmp0, tmp1, tmp2, tmp3; if (cosom < 0.0f) { cosom = -cosom; tmp0 = -q1.x; tmp1 = -q1.y; tmp2 = -q1.z; tmp3 = -q1.w; } else { tmp0 = q1.x; tmp1 = q1.y; tmp2 = q1.z; tmp3 = q1.w; }

/* calc coeffs */ float scale0, scale1;

if ((1.0 - cosom) > 0.0000001f) { // standard case (slerp) float omega = (float) acos (cosom); float sinom = (float) sin (omega); scale0 = (float) sin ((1.0 - t) * omega) / sinom; scale1 = (float) sin (t * omega) / sinom; } else { /* just lerp */ scale0 = 1.0f - t; scale1 = t; }

x = scale0 * q0.x + scale1 * tmp0; y = scale0 * q0.y + scale1 * tmp1; z = scale0 * q0.z + scale1 * tmp2; w = scale0 * q0.w + scale1 * tmp3; }

void Quaternion::Lerp(const Quaternion& q0, const Quaternion& q1, float t) { float cosom = q0.x * q1.x + q0.y * q1.y + q0.z * q1.z + q0.w * q1.w; float tmp0, tmp1, tmp2, tmp3; if (cosom < 0.0f) { cosom = -cosom; tmp0 = -q1.x; tmp1 = -q1.y; tmp2 = -q1.z; tmp3 = -q1.w; } else { tmp0 = q1.x; tmp1 = q1.y; tmp2 = q1.z; tmp3 = q1.w; }

/* just lerp */ float scale0 = 1.0f - t; float scale1 = t;

x = scale0 * q0.x + scale1 * tmp0; y = scale0 * q0.y + scale1 * tmp1; z = scale0 * q0.z + scale1 * tmp2; w = scale0 * q0.w + scale1 * tmp3; }

ostream& operator<<(ostream& os, Quaternion& v) { os << "(" << setprecision(4) << v.x << ", " << v.y << ", " << v.z << ", " << v.w << ")"; return os; }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Mathematics.h] - (16,426 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------
//
// Erm, all angles are in degree(like in OGL), I hate this
// fuckin' radians...
//
// Hmmm, some optimizations can be done, mostly in Matrix4,
// but for the first version I want working code, not 100%
// optimal one, tuning comes later...
//
// Currently some camera-stuff is missing in Matrix4, by
// the way, this comes later ... at the time I need it ;-)
// I think an higher level camera class may be better?!?
//
// should I include defines like #define FTYPE float
// and use this abstract type, so that it can also be used
// with doubles?????
//
// Hmmmmm, I think about making this all a template-library...
//
//
// Hakuna Matata, EvilOne
// Bite me... hehe
// ------------------------------------------------------------

#ifndef _mathematics_h_
#define _mathematics_h_

#include <math.h> #include <stdlib.h> #include <iostream.h> #include <iomanip.h>

// ------------------------------------------------------------ // constants // ------------------------------------------------------------ // PI & Co. const float M_PI = 3.14159265358979323846f; const float M_DEG_TO_RAD = 0.01745329251994329547f; const float M_RAD_TO_DEG = 57.29577951308232286465f; const float M_PI_DIV_2 = 1.570796326794896558f; const float M_PI_DIV_4 = 0.785398163397448279f;

// tolerance values const float M_LOW_TOLERANCE = 0.000001f; const float M_TOLERANCE = 0.000010f; const float M_HIGH_TOLERANCE = 0.000100f;

// ------------------------------------------------------------ // basic functions // ------------------------------------------------------------ inline float Clamp(float f, float min, float max) { return min > f ? min : (max > f ? f : max); }

inline float Lerp(float f, float from, float to) { return from + (to - from) * f; }

inline float Min(float f1, float f2) { return f1 < f2 ? f1 : f2; }

inline float Max(float f1, float f2) { return f1 > f2 ? f1 : f2; }

inline float SinD(float f) { return (float)sin(f * M_DEG_TO_RAD); }

inline float CosD(float f) { return (float)cos(f * M_DEG_TO_RAD); }

inline float TanD(float f) { return (float)tan(f * M_DEG_TO_RAD); }

inline float AtanD(float f) { return (float)atan(f * M_DEG_TO_RAD); }

inline float Degree(float f) { return f * M_DEG_TO_RAD; }

inline float Radians(float f) { return f * M_RAD_TO_DEG; }

inline bool IsZeroL(float f) { return fabs(f) > M_LOW_TOLERANCE; }

inline bool IsZero(float f) { return fabs(f) > M_TOLERANCE; }

inline bool IsZeroH(float f) { return fabs(f) > M_HIGH_TOLERANCE; }

inline float Rand(float max) { return (float(rand()) / float(RAND_MAX)) * max; }

inline float Rand(float min, float max) { return Rand(max - min) + min; }

// ------------------------------------------------------------ // Linear algebra classes // ------------------------------------------------------------ class Vector2; class Matrix3; class Vector3; class Plane; class Matrix4; class Quaternion;

// ------------------------------------------------------------ // Vector2 // ------------------------------------------------------------ class Vector2 { public:

// Members float x, y;

public:

// Constructors Vector2(); Vector2(const float* other); Vector2(float _x, float _y); Vector2(const Vector2& other);

// Assign Vector2& operator=(const Vector2& other); void Assign(float _x, float _y); void Assign(const Vector2& other); void Assign(float* other);

// Swap void Swap(Vector2& other);

// Casting operator float*(); operator const float*() const;

// Math // this += other void Add(const Vector2& other); // this = v1 + v2 void Add(const Vector2& v1, const Vector2& v2); // this -= other void Sub(const Vector2& other); // this = v1 - v2 void Sub(const Vector2& v1, const Vector2& v2); // this *= f void Mul(float f); // this = other * f void Mul(const Vector2& other, float f); // this /= f void Div(float f); // this = other / f void Div(const Vector2& other, float f); // this = -this void Invert(); // this = -other void Invert(const Vector2& other);

// Linear combination // this += other * s void Combine(const Vector2& other, float s); // this = this * s + other * t void Combine(float s, const Vector2& other, float t); // this = v1 * s + v2 * t void Combine(const Vector2& v1, float s, const Vector2& v2, float t);

// operators Vector2& operator+=(const Vector2& other); Vector2& operator-=(const Vector2& other); Vector2& operator*=(float f); Vector2& operator/=(float f); Vector2& operator+=(float f); Vector2& operator-=(float f); Vector2& operator-(); Vector2 operator+(const Vector2& other) const; Vector2 operator-(const Vector2& other) const; Vector2 operator*(float f) const; Vector2 operator/(float f) const; Vector2 operator+(float f) const; Vector2 operator-(float f) const;

// Linear Algebra float Length() const; float LengthSqr() const; float Distance(const Vector2& other) const; float DistanceSqr(const Vector2& other) const; void Normalize(); void Normalize(const Vector2& other);

void Rotate(float angle); void Rotate(Vector2 other, float angle);

// Others void Clamp(float min, float max); // this = v1 + (v2 - v1) * s void Lerp(const Vector2& v1, const Vector2& v2, float s);

// Actions with Matrix3 void Transform(const Matrix3& mat, const Vector2& other); void Transform(const Matrix3& mat);

// friend operators friend ostream& operator<<(ostream& os, Vector2& v); };

// ------------------------------------------------------------ // Matrix3 // ------------------------------------------------------------ class Matrix3 { public:

// members union { float M[9]; float m[3][3]; };

static float Identity_Matrix[];

public:

// Constructors Matrix3(); Matrix3(const float* other); Matrix3(const Matrix3& other);

// Assignment Matrix3& operator=(const Matrix3& other); void Assign(const float* other); void Assign(const Matrix3& other);

// Casting operator float*(); operator const float*() const;

// Simple methods Matrix3& SetIdentity(); Matrix3& SetZero();

// this *= other Matrix3& Mul(const Matrix3& other); // this = m1 * m2 Matrix3& Mul(const Matrix3& m1, const Matrix3& m2); // this *= f Matrix3& Mul(float f); // this = other * f Matrix3& Mul(const Matrix3& other, float f); // this /= f Matrix3& Div(float f); // this = other / f Matrix3& Div(const Matrix3& other, float f);

// Operators Matrix3& operator*=(const Matrix3& other); Matrix3 operator*(const Matrix3& other) const;

// Transformation methods Matrix3& Translate(float tx, float ty); Matrix3& SetTranslate(float tx, float ty); Matrix3& Rotate(float r); Matrix3& SetRotate(float r); Matrix3& Scale(float sx, float sy); Matrix3& SetScale(float sx, float sy);

// friends friend ostream& operator<<(ostream& os, Matrix3 &m); };

// ------------------------------------------------------------ // Vector3 // ------------------------------------------------------------ class Vector3 { public:

// Member variables float x, y, z;

public:

// Constructors Vector3(); Vector3(float _x, float _y, float _z); Vector3(Vector3& other); Vector3(const float* other);

// assignemt Vector3& operator=(const Vector3& other); void Assign(float _x, float _y, float _z); void Assign(const Vector3& other); void Assign(float* other);

// Swap void Swap(Vector3& other);

// Casting operator float*(); operator const float*() const;

// Math // this += other void Add(const Vector3& other); // this = v1 + v2 void Add(const Vector3& v1, const Vector3& v2); // this -= other void Sub(const Vector3& other); // this = v1 - v2 void Sub(const Vector3& v1, const Vector3& v2); // this *= f void Mul(float f); // this = other * f void Mul(const Vector3& other, float f); // this /= f void Div(float f); // this = other / f void Div(const Vector3& other, float f); // this = -this void Invert(); // this = -other void Invert(const Vector3& other);

// Linear combination // this += other * s void Combine(const Vector3& other, float s); // this = this * s + other * t void Combine(float s, const Vector3& other, float t); // this = v1 * s + v2 * t void Combine(const Vector3& v1, float s, const Vector3& v2, float t);

// EvilOne's beloved overloads Vector3& operator+=(const Vector3& other); Vector3& operator-=(const Vector3& other); Vector3& operator*=(float f); Vector3& operator/=(float f); Vector3& operator+=(float f); Vector3& operator-=(float f); Vector3& operator-(); Vector3 operator+(const Vector3& other) const; Vector3 operator-(const Vector3& other) const; Vector3 operator*(float f) const; Vector3 operator/(float f) const; Vector3 operator+(float f) const; Vector3 operator-(float f) const;

// Linear Algebra float Dot(const Vector3& v) const; // this = v1 x v2 void Cross(const Vector3& v); void Cross(const Vector3& v1, const Vector3& v2); float Length() const; float LengthSqr() const; float Distance(const Vector3& other) const; float DistanceSqr(const Vector3& other) const; void Normalize(); void Normalize(const Vector3& other);

// Other usefull funtions void Clamp(float min, float max); // this = v1 + (v2 - v1) * s void Lerp(const Vector3& v1, const Vector3& v2, float s);

// Operations with a plane void Intersect(const Vector3& start, float s, const Vector3& end, float e); void Intersect(const Plane& p, const Vector3& start, const Vector3& end); void Reflect(const Plane& p, const Vector3& v);

// Operations with Matrix void Transform(const Matrix4& mat, const Vector3& other); void Transform(const Matrix4& mat); void TransformTranspose(const Matrix4& mat, const Vector3& other); void TransformTranspose(const Matrix4& mat);

// friend operators friend ostream& operator<<(ostream& os, Vector3& v); };

// ------------------------------------------------------------ // Plane // ------------------------------------------------------------ class Plane { public:

// members union { struct { float a, b, c, d; };

struct { Vector3 n; float d; }; };

public:

// Constructors Plane(); Plane(const Vector3& _n, float _d); Plane(float _a, float _b, float _c, float _d); Plane(float* other); Plane(const Plane& other);

// Assignment Plane& operator=(const Plane& other); void Assign(const Vector3& _n, float _d); void Assign(float _a, float _b, float _c, float _d); void Assign(float* other); void Assign(const Plane& other);

// Functions float Distance(const Vector3& v) const;

// Interaction with matrix void Transform(const Matrix4 &mat); void Transform(const Matrix4 &mat, const Plane& other);

// friend operators friend ostream& operator<<(ostream& os, Plane& p); };

// ------------------------------------------------------------ // Matrix4 // ------------------------------------------------------------ class Matrix4 { public:

// members union { float M[16]; float m[4][4]; };

static float Identity_Matrix[]; static float Orientation_Switch_Matrix[]; static float Perspective_Matrix[];

public:

// Constructors Matrix4(); Matrix4(const float* other); Matrix4(const Matrix4& other); Matrix4(const Quaternion& other);

// Assignment Matrix4& operator=(const Matrix4& other); Matrix4& operator=(const Quaternion& other); void Assign(const Quaternion& other); void Assign(const float* other); void Assign(const Matrix4& other);

// Casting operator float*(); operator const float*() const;

// Simple methods Matrix4& SetIdentity(); Matrix4& SetZero(); Matrix4& SetPerspective(); Matrix4& SetSwitchOrientation();

// this *= other Matrix4& Mul(const Matrix4& other); // this = m1 * m2 Matrix4& Mul(const Matrix4& m1, const Matrix4& m2); // this *= f Matrix4& Mul(float f); // this = other * f Matrix4& Mul(const Matrix4& other, float f); // this /= f Matrix4& Div(float f); // this = other / f Matrix4& Div(const Matrix4& other, float f);

// Operators Matrix4& operator*=(const Matrix4& other); Matrix4 operator*(const Matrix4& other) const;

// Transformation methods Matrix4& SetTranslate(float tx, float ty, float tz); Matrix4& Translate(float tx, float ty, float tz); Matrix4& SetScale(float sx, float sy, float sz); Matrix4& Scale(float sx, float sy, float sz);

// rotation around three euler-angles Matrix4& SetRotate(const Vector3& r); Matrix4& SetRotate(float rx, float ry, float rz); Matrix4& Rotate(const Vector3& r); Matrix4& Rotate(float rx, float ry, float rz);

// rotation euler-angle around axis Matrix4& SetRotate(float angle, const Vector3& r); Matrix4& SetRotate(float angle, float x, float y, float z); Matrix4& Rotate(float angle, const Vector3& r); Matrix4& Rotate(float angle, float x, float y, float z);

// Invert/Transpose Matrix4& Adjoint(); Matrix4& Adjoint(const Matrix4& other);

Matrix4& Transpose(); Matrix4& Transpose(const Matrix4& other);

Matrix4& Invert(); Matrix4& Invert(const Matrix4& other);

float Det() const;

// Perpsective Matrix4& SetProjection(float fov, float aspect, float znear, float zfar); Matrix4& SetOthogonal(float znear, float zfar);

// static static float Det2x2(float a, float b, float c, float d); static float Det3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3);

// friends friend ostream& operator<<(ostream& os, Matrix4 &m); };

// ------------------------------------------------------------ // Quaternion // ------------------------------------------------------------ class Quaternion { public:

// Members float x, y, z, w;

public:

// Constructors Quaternion(); Quaternion(const Quaternion& other); Quaternion(const float* other); Quaternion(float _x, float _y, float _z, float _w);

// Assignment Quaternion& operator=(const Quaternion& other); void Assign(const Quaternion& other); void Assign(const float* other); void Assign(float _x, float _y, float _z, float _w);

// Simple math void Invert(); void Invert(const Quaternion& other); Quaternion& operator-();

Quaternion& Mul(const Quaternion& other); Quaternion& Mul(const Quaternion& q1, const Quaternion& q2); Quaternion operator*(const Quaternion& other) const; Quaternion& operator*=(const Quaternion& other);

float Length() const; float LengthSqr() const;

void Normalize(); void Normalize(const Quaternion& other);

// Rotation around euler-angle and axis Quaternion& SetRotate(float angle, const Vector3& v); Quaternion& Rotate(float angle, const Vector3& v); Quaternion& SetRotate(float angle, float _x, float _y, float _z); Quaternion& Rotate(float angle, float _x, float _y, float _z);

// rotation around three euler-angles Quaternion& SetRotate(const Vector3& v); Quaternion& Rotate(const Vector3& v); Quaternion& SetRotate(float rx, float ry, float rz); Quaternion& Rotate(float rx, float ry, float rz);

// Interpolation void Lerp(const Quaternion& q0, const Quaternion& q1, float t); void Slerp(const Quaternion& q0, const Quaternion& q1, float t);

// friend operators friend ostream& operator<<(ostream& os, Quaternion& v); };

// ------------------------------------------------------------ // Include implementations // ------------------------------------------------------------ #include "Vector2.h" #include "Matrix3.h" #include "Vector3.h" #include "Plane.h" #include "Matrix4.h" #include "Quaternion.h"

#endif

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Matrix3.h] - (3,761 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

// Constructors

inline Matrix3::Matrix3()
{}

inline Matrix3::Matrix3(const float* other) { for(int i = 0; i < 9; i++) M[i] = other[i]; }

inline Matrix3::Matrix3(const Matrix3& other) { for(int i = 0; i < 9; i++) M[i] = other.M[i]; }

// Assignment inline Matrix3& Matrix3::operator=(const Matrix3& other) { for(int i = 0; i < 9; i++) M[i] = other.M[i]; return *this; }

inline void Matrix3::Assign(const Matrix3& other) { for(int i = 0; i < 9; i++) M[i] = other.M[i]; }

inline void Matrix3::Assign(const float* other) { for(int i = 0; i < 9; i++) M[i] = other[i]; }

// Casting inline Matrix3::operator const float*() const { return M; }

inline Matrix3::operator float*() { return M; }

// Simple Methods inline Matrix3& Matrix3::SetIdentity() { for(int i = 0; i < 9; i++) M[i] = Matrix3::Identity_Matrix[i]; return *this; }

inline Matrix3& Matrix3::SetZero() { for(int i = 0; i < 9; i++) M[i] = 0.0f; return *this; }

inline Matrix3& Matrix3::Mul(const Matrix3& other) { Matrix3 tmp; tmp.Assign(*this); Mul(tmp, other); return *this; }

inline Matrix3& Matrix3::Mul(const Matrix3& m1, const Matrix3& m2) { const float *b = m1.M; const float *a = m2.M; float *prod = M;

for(int i = 0; i < 3; i++) { float a0 = a[i]; float a1 = a[i + 3]; float a2 = a[i + 6]; prod[i] = a0 * b[0] + a1 * b[1] + a2 * b[2]; prod[i + 3] = a0 * b[3] + a1 * b[4] + a2 * b[5]; prod[i + 6] = a0 * b[6] + a1 * b[7] + a2 * b[8]; } return *this; }

inline Matrix3& Matrix3::Mul(float f) { for(int i = 0; i < 9; i++) M[i] *=f; return *this; }

inline Matrix3& Matrix3::Mul(const Matrix3& other, float f) { const float* m = other.M; for(int i = 0; i < 9; i++) M[i] = m[i] * f; return *this; }

inline Matrix3& Matrix3::Div(float f) { f = 1.0f / f; for(int i = 0; i < 9; i++) M[i] *=f; return *this; }

inline Matrix3& Matrix3::Div(const Matrix3& other, float f) { f = 1.0f / f; const float* m = other.M; for(int i = 0; i < 9; i++) M[i] = m[i] * f; return *this; }

// Operators inline Matrix3& Matrix3::operator*=(const Matrix3& other) { Matrix3 tmp; tmp.Assign(*this); Mul(tmp, other); return *this; }

inline Matrix3 Matrix3::operator*(const Matrix3& other) const { Matrix3 tmp; tmp.Mul(*this, other); return tmp; }

// Transformations inline Matrix3& Matrix3::Translate(float tx, float ty) { M[6] = M[0] * tx + M[3] * ty + M[6]; M[7] = M[1] * tx + M[4] * ty + M[7]; M[8] = M[2] * tx + M[5] * ty + M[8]; return *this; }

inline Matrix3& Matrix3::SetTranslate(float tx, float ty) { SetIdentity(); M[6] = tx; M[7] = ty; return *this; }

inline Matrix3& Matrix3::Scale(float sx, float sy) { M[0] *= sx; M[3] *= sy; M[1] *= sx; M[4] *= sy; M[2] *= sx; M[5] *= sy; return *this; }

inline Matrix3& Matrix3::SetScale(float sx, float sy) { M[0] = sx; M[4] = sy; M[8] = 1.0f; M[1] = M[2] = M[3] = M[5] = M[6] = M[7] = 0.0f; return *this; }

inline Matrix3& Matrix3::Rotate(float r) { float c = CosD(r), s = SinD(r); Matrix3 tmp; tmp.SetIdentity(); tmp.M[0] = c; tmp.M[1] = -s; tmp.M[3] = s; tmp.M[4] = c; Mul(tmp); return *this; }

inline Matrix3& Matrix3::SetRotate(float r) { float c = CosD(r), s = SinD(r); Matrix3 tmp; SetIdentity(); M[0] = c; M[1] = -s; M[3] = s; M[4] = c; return *this; }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Matrix4.h] - (4,934 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#ifndef _mathematics_h_
#error "Dont include Matrix4 directly!!! Use Mathematics.h instead."
#endif

// Constructors inline Matrix4::Matrix4() {}

inline Matrix4::Matrix4(const Matrix4& other) { for(int i = 0; i < 16; i++) M[i] = other.M[i]; }

inline Matrix4::Matrix4(const float* other) { for(int i = 0; i < 16; i++) M[i] = other[i]; }

inline Matrix4::Matrix4(const Quaternion& other) { Assign(other); }

// Assignment inline Matrix4& Matrix4::operator=(const Matrix4& other) { for(int i = 0; i < 16; i++) M[i] = other.M[i]; return *this; }

inline void Matrix4::Assign(const Matrix4& other) { for(int i = 0; i < 16; i++) M[i] = other.M[i]; }

inline void Matrix4::Assign(const float* other) { for(int i = 0; i < 16; i++) M[i] = other[i]; }

inline Matrix4& Matrix4::operator=(const Quaternion& other) { Assign(other); return *this; }

// Casting inline Matrix4::operator const float*() const { return M; }

inline Matrix4::operator float*() { return M; }

// Simple methods inline Matrix4& Matrix4::SetIdentity() { for(int i = 0; i < 16; i++) M[i] = Matrix4::Identity_Matrix[i]; return *this; }

inline Matrix4& Matrix4::SetZero() { for(int i = 0; i < 16; i++) M[i] = 0.0f; return *this; }

inline Matrix4& Matrix4::SetSwitchOrientation() { for(int i = 0; i < 16; i++) M[i] = Matrix4::Orientation_Switch_Matrix[i]; return *this; }

inline Matrix4& Matrix4::SetPerspective() { for(int i = 0; i < 16; i++) M[i] = Matrix4::Perspective_Matrix[i]; return *this; }

inline Matrix4& Matrix4::Mul(const Matrix4& other) { Matrix4 tmp; tmp.Assign(*this); Mul(tmp, other); return *this; }

inline Matrix4& Matrix4::Mul(const Matrix4& m1, const Matrix4& m2) { const float *b = m1.M; const float *a = m2.M; float *prod = M;

for(int i = 0; i < 4; i++) { float a0 = a[i]; float a1 = a[i + 4]; float a2 = a[i + 8]; float a3 = a[i + 12]; prod[i] = a0 * b[0] + a1 * b[1] + a2 * b[2] + a3 * b[3]; prod[i + 4] = a0 * b[4] + a1 * b[5] + a2 * b[6] + a3 * b[7]; prod[i + 8] = a0 * b[8] + a1 * b[9] + a2 * b[10] + a3 * b[11]; prod[i + 12] = a0 * b[12] + a1 * b[13] + a2 * b[14] + a3 * b[15]; } return *this; }

inline Matrix4& Matrix4::Mul(float f) { for(int i = 0; i < 16; i++) M[i] *=f; return *this; }

inline Matrix4& Matrix4::Mul(const Matrix4& other, float f) { const float* m = other.M; for(int i = 0; i < 16; i++) M[i] = m[i] * f; return *this; }

inline Matrix4& Matrix4::Div(float f) { f = 1.0f / f; for(int i = 0; i < 16; i++) M[i] *=f; return *this; }

inline Matrix4& Matrix4::Div(const Matrix4& other, float f) { f = 1.0f / f; const float* m = other.M; for(int i = 0; i < 16; i++) M[i] = m[i] * f; return *this; }

// Operators inline Matrix4& Matrix4::operator*=(const Matrix4& other) { Matrix4 tmp; tmp.Assign(*this); Mul(tmp, other); return *this; }

inline Matrix4 Matrix4::operator*(const Matrix4& other) const { Matrix4 tmp; tmp.Mul(*this, other); return tmp; }

// Transformation inline Matrix4& Matrix4::Translate(float tx, float ty, float tz) { M[12] = M[0] * tx + M[4] * ty + M[8] * tz + M[12]; M[13] = M[1] * tx + M[5] * ty + M[9] * tz + M[13]; M[14] = M[2] * tx + M[6] * ty + M[10] * tz + M[14]; M[15] = M[3] * tx + M[7] * ty + M[11] * tz + M[15]; return *this; }

inline Matrix4& Matrix4::SetTranslate(float tx, float ty, float tz) { SetIdentity(); return Translate(tx, ty, tz); }

inline Matrix4& Matrix4::Scale(float sx, float sy, float sz) { M[0] *= sx; M[4] *= sy; M[8] *= sz; M[1] *= sx; M[5] *= sy; M[9] *= sz; M[2] *= sx; M[6] *= sy; M[10] *= sz; M[3] *= sx; M[7] *= sy; M[11] *= sz; return *this; }

inline Matrix4& Matrix4::SetScale(float sx, float sy, float sz) { SetIdentity(); return Scale(sx, sy, sz); }

inline Matrix4& Matrix4::Rotate(float rx, float ry, float rz) { Matrix4 tmp; tmp.SetRotate(rx, ry, rz); Mul(tmp); return *this; }

inline Matrix4& Matrix4::Rotate(float angle, float x, float y, float z) { Matrix4 tmp; tmp.SetRotate(angle, x, y, z); Mul(tmp); return *this; }

inline Matrix4& Matrix4::SetRotate(const Vector3& r) { return SetRotate(r.x, r.y, r.z); }

inline Matrix4& Matrix4::Rotate(const Vector3& r) { return Rotate(r.x, r.y, r.z); }

inline Matrix4& Matrix4::SetRotate(float angle, const Vector3& r) { return SetRotate(angle, r.x, r.y, r.z); }

inline Matrix4& Matrix4::Rotate(float angle, const Vector3& r) { return Rotate(angle, r.x, r.y, r.z); }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Plane.h] - (2,376 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#ifndef _mathematics_h_
#error "Dont include Plane directly!!! Use Mathematics.h instead."
#endif

inline Plane::Plane() {}

// copy by hand avoids call to Vector3::operator=(...) inline Plane::Plane(const Vector3& _n, float _d) { a = _n.x; b = _n.y; c = _n.z; d = _d; }

inline Plane::Plane(float _a, float _b, float _c, float _d) { a = _a; b = _b; c = _c; d = _d; }

inline Plane::Plane(float* other) { a = other[0]; b = other[1]; c = other[2]; d = other[3]; }

inline Plane::Plane(const Plane& other) { a = other.a; b = other.b; c = other.c; d = other.d; }

// Assignment inline Plane& Plane::operator=(const Plane& other) { a = other.a; b = other.b; c = other.c; d = other.d; return *this; }

inline void Plane::Assign(const Vector3& _n, float _d) { a = _n.x; b = _n.y; c = _n.z; d = _d; }

inline void Plane::Assign(float _a, float _b, float _c, float _d) { a = _a; b = _b; c = _c; d = _d; }

inline void Plane::Assign(float* other) { a = other[0]; b = other[1]; c = other[2]; d = other[3]; }

inline void Plane::Assign(const Plane& other) { a = other.a; b = other.b; c = other.c; d = other.d; }

// Functions inline float Plane::Distance(const Vector3& v) const { return n.Dot(v) - d; }

inline void Plane::Transform(const Matrix4& mat) { const float* m = mat.M; float fx = a; float fy = b; float fz = c; float fw = d; a = m[0] * fx + m[4] * fy + m[8] * fz + m[12] * fw; b = m[1] * fx + m[5] * fy + m[9] * fz + m[13] * fw; c = m[2] * fx + m[6] * fy + m[10] * fz + m[14] * fw; d = m[3] * fx + m[7] * fy + m[11] * fz + m[15] * fw; }

inline void Plane::Transform(const Matrix4& mat, const Plane& other) { const float* m = mat.M; float fx = other.a; float fy = other.b; float fz = other.c; float fw = other.d; a = m[0] * fx + m[4] * fy + m[8] * fz + m[12] * fw; b = m[1] * fx + m[5] * fy + m[9] * fz + m[13] * fw; c = m[2] * fx + m[6] * fy + m[10] * fz + m[14] * fw; d = m[3] * fx + m[7] * fy + m[11] * fz + m[15] * fw; }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Quaternion.h] - (4,190 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#ifndef _mathematics_h_
#error "Dont include Quaternion directly!!! Use Mathematics.h instead."
#endif

// Constructors inline Quaternion::Quaternion() {}

inline Quaternion::Quaternion(const Quaternion& other) { x = other.x; y = other.y; z = other.z; w = other.w; }

inline Quaternion::Quaternion(const float* other) { x = other[0]; y = other[1]; z = other[2]; w = other[3]; }

inline Quaternion::Quaternion(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }

// Assignment inline Quaternion& Quaternion::operator=(const Quaternion& other) { x = other.x; y = other.y; z = other.z; w = other.w; return *this; }

inline void Quaternion::Assign(const Quaternion& other) { x = other.x; y = other.y; z = other.z; w = other.w; }

inline void Quaternion::Assign(const float* other) { x = other[0]; y = other[1]; z = other[2]; w = other[3]; }

inline void Quaternion::Assign(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }

// Simple math inline void Quaternion::Invert() { x = -x; y = -y; z = -z; }

inline void Quaternion::Invert(const Quaternion& other) { x = -other.x; y = -other.y; z = -other.z; w = other.w; }

inline Quaternion& Quaternion::operator-() { x = -x; y = -y; z = -z; return *this; }

inline float Quaternion::Length() const { return (float)sqrt(w*w + x*x + y*y + z*z); }

inline float Quaternion::LengthSqr() const { return w*w + x*x + y*y + z*z; }

inline void Quaternion::Normalize() { float f = 1.0f / (w*w + x*x + y*y + z*z); x *= f; y *= f; z *= f; w *= f; }

inline void Quaternion::Normalize(const Quaternion& other) { float f = 1.0f / other.Length(); x = other.x * f; y = other.y * f; z = other.z * f; w = other.w * f; }

inline Quaternion& Quaternion::Mul(const Quaternion& other) { Mul(*this, other); return *this; }

inline Quaternion& Quaternion::Mul(const Quaternion& q1, const Quaternion& q2) { const Vector3 v1 = &q1.x; const Vector3 v2 = &q2.x;

float scalar = q1.w * q2.w - v1.Dot(v2);

Vector3 va; va.Cross(v1, v2); Vector3 vb; vb.Mul(v1, q2.w); Vector3 vc; vc.Mul(v2, q1.w); va.Add(vb); va.Add(vc);

x = va.x; y = va.y; z = va.z; w = scalar;

Normalize(); return *this; }

inline Quaternion Quaternion::operator*(const Quaternion& other) const { Quaternion tmp; tmp.Mul(*this, other); return tmp; }

inline Quaternion& Quaternion::operator*=(const Quaternion& other) { Mul(*this, other); return *this; }

// Rotation inline Quaternion& Quaternion::SetRotate(float angle, const Vector3& v) { return SetRotate(angle, v.x, v.y, v.z); }

inline Quaternion& Quaternion::Rotate(float angle, const Vector3& v) { return Rotate(angle, v.x, v.y, v.z); }

inline Quaternion& Quaternion::SetRotate(const Vector3& v) { return SetRotate(v.x, v.y, v.z); }

inline Quaternion& Quaternion::Rotate(const Vector3& v) { return Rotate(v.x, v.y, v.z); }

inline Quaternion& Quaternion::SetRotate(float angle, float _x, float _y, float _z) { float s = SinD(angle / 2.0f); float c = CosD(angle / 2.0f);

x = _x * s; y = _y * s; z = _z * s; w = c; Normalize(); return *this; }

inline Quaternion& Quaternion::Rotate(float angle, float _x, float _y, float _z) { Quaternion tmp; tmp.SetRotate(angle, _x, _y, _z); Mul(*this, tmp); return *this; }

inline Quaternion& Quaternion::SetRotate(float rx, float ry, float rz) { Quaternion qy, qz; SetRotate(rx, 1.0f, 0.0f, 0.0f); qy.SetRotate(ry, 0.0f, 1.0f, 0.0f); qz.SetRotate(rz, 0.0f, 0.0f, 1.0f); Mul(*this, qy); Mul(*this, qz); return *this; }

inline Quaternion& Quaternion::Rotate(float rx, float ry, float rz) { Quaternion tmp; tmp.SetRotate(rx, ry, rz); Mul(*this, tmp); return *this; }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Vector2.h] - (5,669 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#ifndef _mathematics_h_
#error "Dont include Vector2 directly!!! Use Mathematics.h instead."
#endif

// Constructors inline Vector2::Vector2() {}

inline Vector2::Vector2(const float* other) { x = other[0]; y = other[1]; }

inline Vector2::Vector2(float _x, float _y) { x = _x; y = _y; }

inline Vector2::Vector2(const Vector2& other) { x = other.x; y = other.y; }

// Assign inline Vector2& Vector2::operator=(const Vector2& other) { x = other.x; y = other.y; return *this; }

inline void Vector2::Assign(float _x, float _y) { x = _x; y = _y; }

inline void Vector2::Assign(const Vector2& other) { x = other.x; y = other.y; }

inline void Vector2::Assign(float* other) { x = other[0]; y = other[1]; }

// Swap inline void Vector2::Swap(Vector2& other) { Vector2 tmp = *this; Assign(other); other.Assign(tmp); }

// Casting inline Vector2::operator float*() { return &x; }

inline Vector2::operator const float*() const { return &x; }

// Math inline void Vector2::Add(const Vector2& other) { x += other.x; y += other.y; }

inline void Vector2::Add(const Vector2& v1, const Vector2& v2) { x = v1.x + v2.x; y = v1.y + v2.y; }

inline void Vector2::Sub(const Vector2& other) { x -= other.x; y -= other.y; }

inline void Vector2::Sub(const Vector2& v1, const Vector2& v2) { x = v1.x - v2.x; y = v1.y - v2.y; }

inline void Vector2::Mul(float f) { x *= f; y *= f; }

inline void Vector2::Mul(const Vector2& other, float f) { x = other.x * f; y = other.y * f; }

inline void Vector2::Div(float f) { f = 1.0f / f; x *= f; y *= f; }

inline void Vector2::Div(const Vector2& other, float f) { f = 1.0f / f; x = other.x * f; y = other.y * f; }

inline void Vector2::Invert() { x = -x; x = -y; }

inline void Vector2::Invert(const Vector2& other) { x = -other.x; x = -other.y; }

// Linear combination inline void Vector2::Combine(const Vector2& other, float s) { x += other.x * s; y += other.y * s; }

inline void Vector2::Combine(float s, const Vector2& other, float t) { x = x * s + other.x * t; y = y * s + other.y * t; }

inline void Vector2::Combine(const Vector2& v1, float s, const Vector2& v2, float t) { x = v1.x * s + v2.x * t; y = v1.y * s + v2.y * t; }

// operators inline Vector2& Vector2::operator+=(const Vector2& other) { x += other.x; y += other.y; return *this; }

inline Vector2& Vector2::operator-=(const Vector2& other) { x -= other.x; y -= other.y; return *this; }

inline Vector2& Vector2::operator*=(float f) { x *= f; y *= f; return *this; }

inline Vector2& Vector2::operator-=(float f) { x -= f; y -= f; return *this; }

inline Vector2& Vector2::operator+=(float f) { x += f; y += f; return *this; }

inline Vector2& Vector2::operator/=(float f) { f = 1.0f / f; x *= f; y *= f; return *this; }

inline Vector2& Vector2::operator-() { x = -x; y = -y; return *this; }

inline Vector2 Vector2::operator+(const Vector2& other) const { return Vector2(x + other.x, y + other.y); }

inline Vector2 Vector2::operator-(const Vector2& other) const { return Vector2(x - other.x, y - other.y); }

inline Vector2 Vector2::operator+(float f) const { return Vector2(x + f, y + f); }

inline Vector2 Vector2::operator-(float f) const { return Vector2(x - f, y - f); }

inline Vector2 Vector2::operator*(float f) const { return Vector2(x * f, y * f); }

inline Vector2 Vector2::operator/(float f) const { f = 1.0f / f; return Vector2(x * f, y * f); }

// Linear algebra inline float Vector2::Length() const { return (float)sqrt(x * x + y * y); }

inline float Vector2::LengthSqr() const { return x * x + y * y; }

inline float Vector2::Distance(const Vector2& other) const { Vector2 tmp = other - *this; return tmp.Length(); }

inline float Vector2::DistanceSqr(const Vector2& other) const { Vector2 tmp = other - *this; return tmp.LengthSqr(); }

inline void Vector2::Normalize() { float f = 1.0f / Length(); x = x * f; y = y * f; }

inline void Vector2::Normalize(const Vector2& other) { float f = 1.0f / other.Length(); x = other.x * f; y = other.y * f; }

inline void Vector2::Rotate(float angle) { float _x = x; x = _x * CosD(angle) + y * SinD(angle); y = -_x * SinD(angle) + y * CosD(angle); }

inline void Vector2::Rotate(Vector2 other, float angle) { float _x = other.x; float _y = other.y;

x = _x * CosD(angle) + _y * SinD(angle); y = -_x * SinD(angle) + _y * CosD(angle); }

// Others inline void Vector2::Clamp(float min, float max) { x = ::Clamp(x, min, max); y = ::Clamp(y, min, max); }

inline void Vector2::Lerp(const Vector2& v1, const Vector2& v2, float s) { x = ::Lerp(s, v1.x, v2.x); y = ::Lerp(s, v1.y, v2.y); }

inline void Vector2::Transform(const Matrix3& mat, const Vector2& other) { const float* m = mat.M; float fx = other.x; float fy = other.y; x = m[0] * fx + m[3] * fy + m[6]; // w assumed to be 1.0F y = m[1] * fx + m[4] * fy + m[7]; }

inline void Vector2::Transform(const Matrix3& mat) { const float* m = mat.M; float fx = x; float fy = y; x = m[0] * fx + m[3] * fy + m[6]; // w assumed to be 1.0F y = m[1] * fx + m[4] * fy + m[7]; }

Currently browsing [mathcode.zip] (12,899 bytes) - [math/Vector3.h] - (7,946 bytes)

// ------------------------------------------------------------
// Machinery project - math library
// ------------------------------------------------------------
// (c) 2000 by Sascha 'EvilOne' Salevsky
// E-mail: Sascha.Salevsky@Ibykus.de
// ------------------------------------------------------------

#ifndef _mathematics_h_
#error "Dont include Vector3 directly!!! Use Mathematics.h instead."
#endif

// Constructors inline Vector3::Vector3() {}

inline Vector3::Vector3(float _x, float _y, float _z) { x = _x; y = _y; z = _z; }

inline Vector3::Vector3(Vector3& other) { x = other.x; y = other.y; z = other.z; }

inline Vector3::Vector3(const float* other) { x = other[0]; y = other[1]; z = other[2]; }

// assignemt inline Vector3& Vector3::operator=(const Vector3& other) { x = other.x; y = other.y; z = other.z; return *this; }

inline void Vector3::Assign(float _x, float _y, float _z) { x = _x; y = _y; z = _z; }

inline void Vector3::Assign(const Vector3& other) { x = other.x; y = other.y; z = other.z; }

inline void Vector3::Assign(float* other) { x = other[0]; y = other[1]; z = other[2]; }

// Swap inline void Vector3::Swap(Vector3& other) { float _x = x, _y = y, _z = z; x = other.x; y = other.y; z = other.z; other.x = _x; other.y = _y; other.z = _z; }

// Casting inline Vector3::operator float*() { return &x; }

inline Vector3::operator const float*() const { return &x; }

// base functions inline void Vector3::Add(const Vector3& other) { x += other.x; y += other.y; z += other.z; }

inline void Vector3::Add(const Vector3& v1, const Vector3& v2) { x = v1.x + v2.x; y = v1.y + v2.y; z = v1.z + v2.z; }

inline void Vector3::Sub(const Vector3& other) { x -= other.x; y -= other.y; z -= other.z; }

inline void Vector3::Sub(const Vector3& v1, const Vector3& v2) { x = v1.x - v2.x; y = v1.y - v2.y; z = v1.z - v2.z; }

inline void Vector3::Mul(float f) { x *= f; y *= f; z *= f; }

inline void Vector3::Mul(const Vector3& other, float f) { x = other.x * f; y = other.y * f; z = other.z * f; }

inline void Vector3::Div(float f) { f = 1.0f / f; x *= f; y *= f; z *= f; }

inline void Vector3::Div(const Vector3& other, float f) { f = 1.0f / f; x = other.x * f; y = other.y * f; z = other.z * f; }

inline void Vector3::Invert() { x = -x; x = -y; z = -z; }

inline void Vector3::Invert(const Vector3& other) { x = -other.x; x = -other.y; z = -other.z; }

// Linear combination inline void Vector3::Combine(const Vector3& other, float s) { x += other.x * s; y += other.y * s; z += other.z * s; }

inline void Vector3::Combine(float s, const Vector3& other, float t) { x = x * s + other.x * t; y = y * s + other.y * t; z = z * s + other.z * t; }

inline void Vector3::Combine(const Vector3& v1, float s, const Vector3& v2, float t) { x = v1.x * s + v2.x * t; y = v1.y * s + v2.y * t; z = v1.z * s + v2.z * t; }

// EvilOne's beloved overloads inline Vector3& Vector3::operator+=(const Vector3& other) { x += other.x; y += other.y; z += other.z; return *this; }

inline Vector3& Vector3::operator-=(const Vector3& other) { x -= other.x; y -= other.y; z -= other.z; return *this; }

inline Vector3& Vector3::operator*=(float f) { x *= f; y *= f; z *= f; return *this; }

inline Vector3& Vector3::operator-=(float f) { x -= f; y -= f; z -= f; return *this; }

inline Vector3& Vector3::operator+=(float f) { x += f; y += f; z += f; return *this; }

inline Vector3& Vector3::operator/=(float f) { f = 1.0f / f; x *= f; y *= f; z *= f; return *this; }

inline Vector3& Vector3::operator-() { x = -x; y = -y; z = -z; return *this; }

inline Vector3 Vector3::operator+(const Vector3& other) const { return Vector3(x + other.x, y + other.y, z + other.z); }

inline Vector3 Vector3::operator-(const Vector3& other) const { return Vector3(x - other.x, y - other.y, z - other.z); }

inline Vector3 Vector3::operator+(float f) const { return Vector3(x + f, y + f, z + f); }

inline Vector3 Vector3::operator-(float f) const { return Vector3(x - f, y - f, z - f); }

inline Vector3 Vector3::operator*(float f) const { return Vector3(x * f, y * f, z * f); }

inline Vector3 Vector3::operator/(float f) const { f = 1.0f / f; return Vector3(x * f, y * f, z * f); }

// Linear Algebra inline float Vector3::Dot(const Vector3& v) const { return x * v.x + y * v.y + z * v.z; }

inline void Vector3::Cross(const Vector3& v) { float _x = y * v.z - z * v.y; float _y = z * v.x - x * v.z; float _z = x * v.y - y * v.x; x = _x; y = _y; z = _z; }

inline void Vector3::Cross(const Vector3& v1, const Vector3& v2) { float _x = v1.y * v2.z - v1.z * v2.y; float _y = v1.z * v2.x - v1.x * v2.z; float _z = v1.x * v2.y - v1.y * v2.x; x = _x; y = _y; z = _z; }

inline float Vector3::Length() const { return (float)sqrt(x * x + y * y + z * z); }

inline float Vector3::LengthSqr() const { return x * x + y * y + z * z; }

inline float Vector3::Distance(const Vector3& other) const { Vector3 tmp = other - *this; return tmp.Length(); }

inline float Vector3::DistanceSqr(const Vector3& other) const { Vector3 tmp = other - *this; return tmp.LengthSqr(); }

inline void Vector3::Normalize() { float f = 1.0f / Length(); x = x * f; y = y * f; z = z * f; }

inline void Vector3::Normalize(const Vector3& other) { float f = 1.0f / other.Length(); x = other.x * f; y = other.y * f; z = other.z * f; }

// Other usefull funtions inline void Vector3::Clamp(float min, float max) { x = ::Clamp(x, min, max); y = ::Clamp(y, min, max); z = ::Clamp(z, min, max); }

inline void Vector3::Lerp(const Vector3& v1, const Vector3& v2, float s) { x = ::Lerp(s, v1.x, v2.x); y = ::Lerp(s, v1.y, v2.y); z = ::Lerp(s, v1.z, v2.z); }

// Operations with a plane inline void Vector3::Intersect(const Vector3& start, float s, const Vector3& end, float e) { float ws = s / (e - s); float we = e / (e - s); x = start.x * ws + end.x * we; y = start.y * ws + end.y * we; z = start.z * ws + end.z * we; }

inline void Vector3::Intersect(const Plane& p, const Vector3& start, const Vector3& end) { float s = p.Distance(start); float e = p.Distance(end); Intersect(start, s, end, e); }

inline void Vector3::Reflect(const Plane& p, const Vector3& v) { Vector3 tmp = p.n * 2 * v.Dot(p.n) - v; x = tmp.x; y = tmp.y; z = tmp.z; }

// Operations with a matrix inline void Vector3::Transform(const Matrix4& mat) { const float* m = mat.M; float fx = x; float fy = y; float fz = z; x = m[0] * fx + m[4] * fy + m[8] * fz + m[12]; // w assumed to be 1.0F y = m[1] * fx + m[5] * fy + m[9] * fz + m[13]; z = m[2] * fx + m[6] * fy + m[10] * fz + m[14]; }

inline void Vector3::Transform(const Matrix4& mat, const Vector3& other) { const float* m = mat.M; float fx = other.x; float fy = other.y; float fz = other.z; x = m[0] * fx + m[4] * fy + m[8] * fz + m[12]; // w assumed to be 1.0F y = m[1] * fx + m[5] * fy + m[9] * fz + m[13]; z = m[2] * fx + m[6] * fy + m[10] * fz + m[14]; }

inline void Vector3::TransformTranspose(const Matrix4& mat) { const float* m = mat.M; float fx = x; float fy = y; float fz = z; x = m[0] * fx + m[1] * fy + m[2] * fz + m[3]; // w assumed to be 1.0F y = m[4] * fx + m[5] * fy + m[6] * fz + m[7]; z = m[8] * fx + m[9] * fy + m[10] * fz + m[11]; }

inline void Vector3::TransformTranspose(const Matrix4& mat, const Vector3& other) { const float* m = mat.M; float fx = other.x; float fy = other.y; float fz = other.z; x = m[0] * fx + m[1] * fy + m[2] * fz + m[3]; // w assumed to be 1.0F y = m[4] * fx + m[5] * fy + m[6] * fz + m[7]; z = m[8] * fx + m[9] * fy + m[10] * fz + m[11]; }


The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.