leetnightshade/math.beta
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updated readme, and updated main so you don't need to run the test program on the commandline.

Browse source
This commit is contained in:
Brian 2014-02-20 12:52:11 -07:00
parent db0ac63215
commit 44608cf2c8
5 changed files with 240 additions and 229 deletions
Download patch file Download diff file Expand all files Collapse all files

8
README.md
View file

@ -5,8 +5,12 @@ C++ GameDev related math helpers. These helpers will be designed for ease of us
Requirements Requirements
----------- -----------
Aside from a C++ compiler, there are no external dependencies outside of the stdlib. However, for running unit tests this uses [igloo](https://github.com/joakimkarlsson/igloo), already referenced as an external. Aside from a C++ compiler, there are no external dependencies outside of the stdlib. However, for running unit tests I use [igloo](https://github.com/joakimkarlsson/igloo), which is already referenced, and you'll need premake4.
Cloning Cloning
----------- -----------
Since there's an external for testing, don't forget `--recursive`: `git clone --recursive https://github.com/leetNightshade/math.beta.git`. Since there's an external for testing, don't forget `--recursive`: `git clone --recursive https://github.com/leetNightshade/math.beta.git`.
Testing
-----------
You'll need premake4. On the commandline `premake4 --help` to see what project types are available for your platform, and pick the project type you want to use. For example, on Windows I'll use `premake4 vs2010`. From there build your project. When it's done building, run the program directly; for convenience you don't need to run it from the commandline.

12
include/Debug.h
View file

@ -1,6 +1,6 @@
#ifndef __DEBUG_H__ #ifndef __DEBUG_H__
#define __DEBUG_H__ #define __DEBUG_H__
// TODO: add assert macros and maybe some simple logging functionality // TODO: add assert macros and maybe some simple logging functionality
#endif //__DEBUG_H__ #endif //__DEBUG_H__

30
include/math/MathDefs.h
View file

@ -1,15 +1,15 @@
/* __ __ ___ _____ ____ /* __ __ ___ _____ ____
* \ \ / / / _ \ | __ \ | | * \ \ / / / _ \ | __ \ | |
* \ \/\/ / / / \ \ | | / / | __| * \ \/\/ / / / \ \ | | / / | __|
* \_/\_/ /_/ \_\ |_| \_\ |_| * \_/\_/ /_/ \_\ |_| \_\ |_|
* Take it to the next Level * Take it to the next Level
* *
* 2009 Brian Ernst. * 2009 Brian Ernst.
* See ReadMe.md for more license info. * See ReadMe.md for more license info.
*/ */
#ifndef __MATHDEFS_H__ #ifndef __MATHDEFS_H__
#define __MATHDEFS_H__ #define __MATHDEFS_H__
typedef float Scalar; typedef float Scalar;
#endif #endif

410
include/math/Vector3.h
View file

@ -1,205 +1,205 @@
/* __ __ ___ _____ ____ /* __ __ ___ _____ ____
* \ \ / / / _ \ | __ \ | | * \ \ / / / _ \ | __ \ | |
* \ \/\/ / / / \ \ | | / / | __| * \ \/\/ / / / \ \ | | / / | __|
* \_/\_/ /_/ \_\ |_| \_\ |_| * \_/\_/ /_/ \_\ |_| \_\ |_|
* Take it to the next Level * Take it to the next Level
* *
* 2009 Brian Ernst. * 2009 Brian Ernst.
* See ReadMe.md for more license info. * See ReadMe.md for more license info.
*/ */
#ifndef __VECTOR3_H__ #ifndef __VECTOR3_H__
#define __VECTOR3_H__ #define __VECTOR3_H__
# include "Debug.h" # include "Debug.h"
# include "math/MathDefs.h" # include "math/MathDefs.h"
template< typename BaseType > template< typename BaseType >
class TVector3 class TVector3
{ {
public: public:
BaseType X, Y, Z; BaseType X, Y, Z;
TVector3( void ); TVector3( void );
TVector3( const TVector3& ); TVector3( const TVector3& );
TVector3( BaseType x, BaseType y, BaseType z ); TVector3( BaseType x, BaseType y, BaseType z );
virtual ~TVector3( void ) { } virtual ~TVector3( void ) { }
TVector3& operator=( const TVector3& ); TVector3& operator=( const TVector3& );
// TODO: Implement and use epsilon comparison // TODO: Implement and use epsilon comparison
bool operator==( const TVector3& ) const; bool operator==( const TVector3& ) const;
bool operator!=( const TVector3& ) const; bool operator!=( const TVector3& ) const;
TVector3 operator*( BaseType ) const; TVector3 operator*( BaseType ) const;
TVector3 operator/( BaseType ) const; TVector3 operator/( BaseType ) const;
TVector3 operator*( const TVector3& ) const; TVector3 operator*( const TVector3& ) const;
TVector3 operator/( const TVector3& ) const; TVector3 operator/( const TVector3& ) const;
TVector3 operator+( const TVector3& ) const; TVector3 operator+( const TVector3& ) const;
TVector3 operator-( const TVector3& ) const; TVector3 operator-( const TVector3& ) const;
TVector3& operator*=( BaseType ); TVector3& operator*=( BaseType );
TVector3& operator/=( BaseType ); TVector3& operator/=( BaseType );
TVector3& operator*=( const TVector3& ); TVector3& operator*=( const TVector3& );
TVector3& operator/=( const TVector3& ); TVector3& operator/=( const TVector3& );
TVector3& operator+=( const TVector3& ); TVector3& operator+=( const TVector3& );
TVector3& operator-=( const TVector3& ); TVector3& operator-=( const TVector3& );
// TODO: Add other helper functions // TODO: Add other helper functions
bool IsZero( void ) const; bool IsZero( void ) const;
}; };
typedef TVector3< Scalar > Vec3f; typedef TVector3< Scalar > Vec3f;
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >::TVector3( void ) inline TVector3< BaseType >::TVector3( void )
{ {
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >::TVector3( const TVector3& vect ) inline TVector3< BaseType >::TVector3( const TVector3& vect )
: X( vect.X ) : X( vect.X )
, Y( vect.Y ) , Y( vect.Y )
, Z( vect.Z ) , Z( vect.Z )
{ {
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >::TVector3( BaseType x, BaseType y, BaseType z ) inline TVector3< BaseType >::TVector3( BaseType x, BaseType y, BaseType z )
: X( x ) : X( x )
, Y( y ) , Y( y )
, Z( z ) , Z( z )
{ {
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator=( const TVector3& vect ) inline TVector3< BaseType >& TVector3< BaseType >::operator=( const TVector3& vect )
{ {
#ifdef _DEBUG #ifdef _DEBUG
if ( this == &vect ) if ( this == &vect )
{ {
return *this; return *this;
} }
#endif #endif
X = vect.X; X = vect.X;
Y = vect.Y; Y = vect.Y;
Z = vect.Z; Z = vect.Z;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline bool TVector3< BaseType >::operator==( const TVector3& vect ) const inline bool TVector3< BaseType >::operator==( const TVector3& vect ) const
{ {
return X == vect.X && Y == vect.Y && Z == vect.Z; return X == vect.X && Y == vect.Y && Z == vect.Z;
} }
template< typename BaseType > template< typename BaseType >
inline bool TVector3< BaseType >::operator!=( const TVector3& vect ) const inline bool TVector3< BaseType >::operator!=( const TVector3& vect ) const
{ {
return X != vect.X || Y != vect.Y || Z != vect.Z; return X != vect.X || Y != vect.Y || Z != vect.Z;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator*( BaseType val ) const inline TVector3< BaseType > TVector3< BaseType >::operator*( BaseType val ) const
{ {
return TVector3< BaseType >( X * val, Y * val, Z * val ); return TVector3< BaseType >( X * val, Y * val, Z * val );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator/( BaseType val ) const inline TVector3< BaseType > TVector3< BaseType >::operator/( BaseType val ) const
{ {
return TVector3< BaseType >( X / val, Y / val, Z / val ); return TVector3< BaseType >( X / val, Y / val, Z / val );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator*( const TVector3& vect ) const inline TVector3< BaseType > TVector3< BaseType >::operator*( const TVector3& vect ) const
{ {
return TVector3< BaseType >( X * vect.X, Y * vect.Y, Z * vect.Z ); return TVector3< BaseType >( X * vect.X, Y * vect.Y, Z * vect.Z );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator/( const TVector3& vect ) const inline TVector3< BaseType > TVector3< BaseType >::operator/( const TVector3& vect ) const
{ {
return TVector3< BaseType >( X / vect.X, Y / vect.Y, Z / vect.Z ); return TVector3< BaseType >( X / vect.X, Y / vect.Y, Z / vect.Z );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator+( const TVector3& vect ) const inline TVector3< BaseType > TVector3< BaseType >::operator+( const TVector3& vect ) const
{ {
return TVector3< BaseType >( X + vect.X, Y + vect.Y, Z + vect.Z ); return TVector3< BaseType >( X + vect.X, Y + vect.Y, Z + vect.Z );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType > TVector3< BaseType >::operator-( const TVector3& vect ) const inline TVector3< BaseType > TVector3< BaseType >::operator-( const TVector3& vect ) const
{ {
return TVector3< BaseType >( X - vect.X, Y - vect.Y, Z - vect.Z ); return TVector3< BaseType >( X - vect.X, Y - vect.Y, Z - vect.Z );
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator*=( BaseType val ) inline TVector3< BaseType >& TVector3< BaseType >::operator*=( BaseType val )
{ {
X *= val; X *= val;
Y *= val; Y *= val;
Z *= val; Z *= val;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator/=( BaseType val ) inline TVector3< BaseType >& TVector3< BaseType >::operator/=( BaseType val )
{ {
X /= val; X /= val;
Y /= val; Y /= val;
Z /= val; Z /= val;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator*=( const TVector3& vect ) inline TVector3< BaseType >& TVector3< BaseType >::operator*=( const TVector3& vect )
{ {
X *= vect.X; X *= vect.X;
Y *= vect.Y; Y *= vect.Y;
Z *= vect.Z; Z *= vect.Z;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator/=( const TVector3& vect ) inline TVector3< BaseType >& TVector3< BaseType >::operator/=( const TVector3& vect )
{ {
X /= vect.X; X /= vect.X;
Y /= vect.Y; Y /= vect.Y;
Z /= vect.Z; Z /= vect.Z;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator+=( const TVector3& vect ) inline TVector3< BaseType >& TVector3< BaseType >::operator+=( const TVector3& vect )
{ {
X += vect.X; X += vect.X;
Y += vect.Y; Y += vect.Y;
Z += vect.Z; Z += vect.Z;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline TVector3< BaseType >& TVector3< BaseType >::operator-=( const TVector3& vect ) inline TVector3< BaseType >& TVector3< BaseType >::operator-=( const TVector3& vect )
{ {
X -= vect.X; X -= vect.X;
Y -= vect.Y; Y -= vect.Y;
Z -= vect.Z; Z -= vect.Z;
return *this; return *this;
} }
template< typename BaseType > template< typename BaseType >
inline bool TVector3< BaseType >::IsZero( void ) const inline bool TVector3< BaseType >::IsZero( void ) const
{ {
// TODO: Use epsilon // TODO: Use epsilon
return X == 0 && Y == 0 && Z == 0; return X == 0 && Y == 0 && Z == 0;
} }
#endif #endif

9
tests/main.cpp
View file

@ -1,3 +1,6 @@
#include <iostream>
#include <limits>
#include <igloo/igloo_alt.h> #include <igloo/igloo_alt.h>
using namespace igloo; using namespace igloo;
@ -8,6 +11,10 @@ using namespace igloo;
int main( int argc, const char* argv[ ] ) int main( int argc, const char* argv[ ] )
{ {
const int returnValue = TestRunner::RunAllTests( argc, const_cast< char** >( argv ) );
return TestRunner::RunAllTests( argc, const_cast< char** >( argv ) ); std::cout << std::endl << "Press ENTER to continue" << std::endl;
std::cin.ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
return returnValue;
} }