A few additions to the math lib

shaders/ms_mp_dn.glsl

@@ -1,4 +1,4 @@
-#define _HAS_DIFFUSE_MAP_
-#define _HAS_NORMAL_MAP_
+#define _DIFFUSE_MAPPING_
+#define _NORMAL_MAPPING_
 
 #pragma anki include "shaders/ms_mp_generic.glsl"

shaders/ms_mp_dne.glsl

@@ -1,5 +1,5 @@
-#define _HAS_DIFFUSE_MAP_
-#define _HAS_NORMAL_MAP_
+#define _DIFFUSE_MAPPING_
+#define _NORMAL_MAPPING_
 #define _ENVIRONMENT_MAPPING_
 
 #pragma anki include "shaders/ms_mp_generic.glsl"

shaders/ms_mp_dnsk.glsl

@@ -1,6 +1,6 @@
-#define _HAS_DIFFUSE_MAP_
-#define _HAS_NORMAL_MAP_
-#define _HAS_SPECULAR_MAP_
+#define _DIFFUSE_MAPPING_
+#define _NORMAL_MAPPING_
+#define _SPECULAR_MAPPING_
 #define _HARDWARE_SKINNING_
 
 #pragma anki include "shaders/ms_mp_generic.glsl"

shaders/ms_mp_generic.glsl

@@ -1,11 +1,11 @@
-#if defined( _HAS_DIFFUSE_MAP_ ) || defined( _HAS_NORMAL_MAP_ ) || defined( _HAS_SPECULAR_MAP_ )
+#if defined( _DIFFUSE_MAPPING_ ) || defined( _NORMAL_MAPPING_ ) || defined( _SPECULAR_MAPPING_ )
 	#define NEEDS_TEX_MAPPING 1
 #else
 	#define NEEDS_TEX_MAPPING 0
 #endif
 
 
-#if defined( _HAS_NORMAL_MAP_ ) || defined( _PARALLAX_MAPPING_ )
+#if defined( _NORMAL_MAPPING_ ) || defined( _PARALLAX_MAPPING_ )
 	#define NEEDS_TANGENT 1
 #else
 	#define NEEDS_TANGENT 0
@@ -174,7 +174,7 @@ void main()
 	// Get the color from the diffuse map and discard if grass                                                                          =
 	//===================================================================================================================================
 	vec3 _diff_color;
-	#if defined( _HAS_DIFFUSE_MAP_ )
+	#if defined( _DIFFUSE_MAPPING_ )
 
 		#if defined( _GRASS_LIKE_ )
 			vec4 _diff_color4 = texture2D( diffuse_map, _super_tex_coords );
@@ -194,7 +194,7 @@ void main()
 	// Normal Calculations                                                                                                              =
 	// Either use a normap map and make some calculations or use the vertex normal                                                      =
 	//===================================================================================================================================
-	#if defined( _HAS_NORMAL_MAP_ )
+	#if defined( _NORMAL_MAPPING_ )
 		vec3 _n = normalize( normal_v2f );
 		vec3 _t = normalize( tangent_v2f );
 		vec3 _b = cross(_n, _t) * w_v2f;
@@ -233,7 +233,7 @@ void main()
 	//===================================================================================================================================
 
 	// has specular map
-	#if defined( _HAS_SPECULAR_MAP_ )
+	#if defined( _SPECULAR_MAPPING_ )
 		vec4 _specular = vec4(texture2D( specular_map, _super_tex_coords ).rgb * gl_FrontMaterial.specular.rgb, gl_FrontMaterial.shininess);
 	// no specular map
 	#else

src/math/axisang.inl.h

@@ -4,22 +4,22 @@ namespace m {
 
 
 // constructor []
-M_INLINE axisang_t::axisang_t()
+inline axisang_t::axisang_t()
 	: ang(0.0), axis()
 {}
 
 // constructor [axisang_t]
-M_INLINE axisang_t::axisang_t( const axisang_t& b )
+inline axisang_t::axisang_t( const axisang_t& b )
 	: ang(b.ang), axis(b.axis)
 {}
 
 // constructor [float, axis]
-M_INLINE axisang_t::axisang_t( float rad, const vec3_t& axis_ )
+inline axisang_t::axisang_t( float rad, const vec3_t& axis_ )
 	: ang(rad), axis(axis_)
 {}
 
 // constructor [quat]
-M_INLINE axisang_t::axisang_t( const quat_t& q )
+inline axisang_t::axisang_t( const quat_t& q )
 {
 	ang = 2.0*acos( q.w );
 	float length = Sqrt( 1.0 - q.w*q.w );
@@ -33,7 +33,7 @@ M_INLINE axisang_t::axisang_t( const quat_t& q )
 }
 
 // constructor [mat3]
-M_INLINE axisang_t::axisang_t( const mat3_t& m3 )
+inline axisang_t::axisang_t( const mat3_t& m3 )
 {
 	if( (fabs(m3(0,1)-m3(1,0))< EPSILON)  && (fabs(m3(0,2)-m3(2,0))< EPSILON)  && (fabs(m3(1,2)-m3(2,1))< EPSILON) )
 	{

src/math/euler.inl.h

@@ -5,63 +5,63 @@ namespace m {
 
 
 // accessors
-M_INLINE float& euler_t::operator []( uint i )
+inline float& euler_t::operator []( uint i )
 {
 	return (&x)[i];
 }
 
-M_INLINE float euler_t::operator []( uint i) const
+inline float euler_t::operator []( uint i) const
 {
 	return (&x)[i];
 }
 
-M_INLINE float& euler_t::bank()
+inline float& euler_t::bank()
 {
 	return x;
 }
 
-M_INLINE float euler_t::bank() const
+inline float euler_t::bank() const
 {
 	return x;
 }
 
-M_INLINE float& euler_t::heading()
+inline float& euler_t::heading()
 {
 	return y;
 }
 
-M_INLINE float euler_t::heading() const
+inline float euler_t::heading() const
 {
 	return y;
 }
 
-M_INLINE float& euler_t::attitude()
+inline float& euler_t::attitude()
 {
 	return z;
 }
 
-M_INLINE float euler_t::attitude() const
+inline float euler_t::attitude() const
 {
 	return z;
 }
 
 // constructor []
-M_INLINE euler_t::euler_t()
+inline euler_t::euler_t()
 	: x(0.0), y(0.0), z(0.0)
 {}
 
 // constructor [float, float, float]
-M_INLINE euler_t::euler_t( float x_, float y_, float z_ )
+inline euler_t::euler_t( float x_, float y_, float z_ )
 	: x(x_), y(y_), z(z_)
 {}
 
 // constructor [euler]
-M_INLINE euler_t::euler_t( const euler_t& b )
+inline euler_t::euler_t( const euler_t& b )
 	: x(b.x), y(b.y), z(b.z)
 {}
 
 // constructor [quat]
-M_INLINE euler_t::euler_t( const quat_t& q )
+inline euler_t::euler_t( const quat_t& q )
 {
 	float test = q.x*q.y + q.z*q.w;
 	if( test > 0.499 )
@@ -88,7 +88,7 @@ M_INLINE euler_t::euler_t( const quat_t& q )
 }
 
 // constructor [mat3]
-M_INLINE euler_t::euler_t( const mat3_t& m3 )
+inline euler_t::euler_t( const mat3_t& m3 )
 {
 	float cx, sx;
 	float cy, sy;

src/math/m_dflt_header.h

@@ -7,8 +7,3 @@
 #include "mat3.h"
 #include "mat4.h"
 #include "m_misc.h"
-
-
-#ifndef M_INLINE
-	#define M_INLINE inline
-#endif

src/math/m_misc.inl.h

@@ -6,7 +6,7 @@ namespace m {
 
 // MathSanityChecks
 // test if the compiler keeps the correct sizes for the classes
-M_INLINE void MathSanityChecks()
+inline void MathSanityChecks()
 {
 	const int fs = sizeof(float); // float size
 	if( sizeof(vec2_t)!=fs*2 || sizeof(vec3_t)!=fs*3 || sizeof(vec4_t)!=fs*4 || sizeof(quat_t)!=fs*4 || sizeof(euler_t)!=fs*3 ||
@@ -16,7 +16,7 @@ M_INLINE void MathSanityChecks()
 
 
 // 1/sqrt(f)
-M_INLINE float InvSqrt( float f )
+inline float InvSqrt( float f )
 {
 #if defined( _DEBUG_ )
 	return 1.0/sqrtf(f);
@@ -51,7 +51,7 @@ M_INLINE float InvSqrt( float f )
 // PolynomialSinQuadrant
 // used in SinCos
 #if !defined(_DEBUG_)
-M_INLINE static float PolynomialSinQuadrant(float a)
+inline static float PolynomialSinQuadrant(float a)
 {
 	return a * ( 1.0 + a * a * (-0.16666 + a * a * (0.0083143 - a * a * 0.00018542)));
 }
@@ -59,7 +59,7 @@ M_INLINE static float PolynomialSinQuadrant(float a)
 
 
 // Sine and Cosine
-M_INLINE void SinCos( float a, float& sina, float& cosa )
+inline void SinCos( float a, float& sina, float& cosa )
 {
 #ifdef _DEBUG_
 	sina = sin(a);
@@ -111,19 +111,19 @@ M_INLINE void SinCos( float a, float& sina, float& cosa )
 //=====================================================================================================================================
 // Small funcs                                                                                                                        =
 //=====================================================================================================================================
-M_INLINE float Sqrt( float f ) { return 1/InvSqrt(f); }
-M_INLINE float ToRad( float degrees ) { return degrees*(PI/180.0); }
-M_INLINE float ToDegrees( float rad ) { return rad*(180.0/PI); }
-M_INLINE float Sin( float rad ) { return sin(rad); }
-M_INLINE float Cos( float rad ) { return cos(rad); }
-M_INLINE bool  IsZero( float f ) { return ( fabs(f) < EPSILON ); }
-M_INLINE float Max( float a, float b ) { return (a>b) ? a : b; }
-M_INLINE float Min( float a, float b ) { return (a<b) ? a : b; }
+inline float Sqrt( float f ) { return 1/InvSqrt(f); }
+inline float ToRad( float degrees ) { return degrees*(PI/180.0); }
+inline float ToDegrees( float rad ) { return rad*(180.0/PI); }
+inline float Sin( float rad ) { return sin(rad); }
+inline float Cos( float rad ) { return cos(rad); }
+inline bool  IsZero( float f ) { return ( fabs(f) < EPSILON ); }
+inline float Max( float a, float b ) { return (a>b) ? a : b; }
+inline float Min( float a, float b ) { return (a<b) ? a : b; }
 
 
 //  CombineTransformations
 //  mat4(t0,r0,s0)*mat4(t1,r1,s1) == mat4(tf,rf,sf)
-M_INLINE void CombineTransformations( const vec3_t& t0, const mat3_t& r0, float s0,
+inline void CombineTransformations( const vec3_t& t0, const mat3_t& r0, float s0,
                                       const vec3_t& t1, const mat3_t& r1, float s1,
                                       vec3_t& tf, mat3_t& rf, float& sf )
 {
@@ -133,7 +133,7 @@ M_INLINE void CombineTransformations( const vec3_t& t0, const mat3_t& r0, float
 }
 
 //  CombineTransformations as the above but without scale
-M_INLINE void CombineTransformations( const vec3_t& t0, const mat3_t& r0, const vec3_t& t1, const mat3_t& r1, vec3_t& tf, mat3_t& rf)
+inline void CombineTransformations( const vec3_t& t0, const mat3_t& r0, const vec3_t& t1, const mat3_t& r1, vec3_t& tf, mat3_t& rf)
 {
 	tf = t1.GetTransformed( t0, r0 );
 	rf = r0 * r1;

src/math/mat3.h

@@ -83,6 +83,13 @@ class mat3_t
 };
 
 
+// other operators
+extern mat3_t operator +( float f, const mat3_t& m3 );
+extern mat3_t operator -( float f, const mat3_t& m3 );
+extern mat3_t operator *( float f, const mat3_t& m3 );
+extern mat3_t operator /( float f, const mat3_t& m3 );
+
+
 } // end namespace
 
 

src/math/mat3.inl.h

@@ -7,35 +7,35 @@
 namespace m {
 
 // accessors
-M_INLINE float& mat3_t::operator ()( const uint i, const uint j )
+inline float& mat3_t::operator ()( const uint i, const uint j )
 {
 	return arr2[i][j];
 }
 
-M_INLINE const float& mat3_t::operator ()( const uint i, const uint j ) const
+inline const float& mat3_t::operator ()( const uint i, const uint j ) const
 {
 	return arr2[i][j]; 
 }
 
-M_INLINE float& mat3_t::operator []( const uint i)
+inline float& mat3_t::operator []( const uint i)
 {
 	return arr1[i];
 }
 
-M_INLINE const float& mat3_t::operator []( const uint i) const
+inline const float& mat3_t::operator []( const uint i) const
 {
 	return arr1[i];
 }
 
 // constructor [float[]]
-M_INLINE mat3_t::mat3_t( float arr [] )
+inline mat3_t::mat3_t( float arr [] )
 {
 	for( int i=0; i<9; i++ )
 		ME[i] = arr[i];
 }
 
 // constructor [float...........float]
-M_INLINE mat3_t::mat3_t( float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22 )
+inline mat3_t::mat3_t( float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22 )
 {
 	ME(0,0) = m00;
 	ME(0,1) = m01;
@@ -49,14 +49,14 @@ M_INLINE mat3_t::mat3_t( float m00, float m01, float m02, float m10, float m11,
 }
 
 // constructor [mat3]
-M_INLINE mat3_t::mat3_t( const mat3_t& b )
+inline mat3_t::mat3_t( const mat3_t& b )
 {
 	for( int i=0; i<9; i++ )
 		ME[i] = b[i];
 }
 
 // constructor [quat]
-M_INLINE mat3_t::mat3_t( const quat_t& q )
+inline mat3_t::mat3_t( const quat_t& q )
 {
 	DEBUG_ERR( !IsZero( 1.0f - q.Length()) ); // Not normalized quat
 
@@ -89,7 +89,7 @@ M_INLINE mat3_t::mat3_t( const quat_t& q )
 }
 
 // constructor [euler]
-M_INLINE mat3_t::mat3_t( const euler_t& e )
+inline mat3_t::mat3_t( const euler_t& e )
 {
 	float ch, sh, ca, sa, cb, sb;
   SinCos( e.heading(), sh, ch );
@@ -108,7 +108,7 @@ M_INLINE mat3_t::mat3_t( const euler_t& e )
 }
 
 // constructor [axisang]
-M_INLINE mat3_t::mat3_t( const axisang_t& axisang )
+inline mat3_t::mat3_t( const axisang_t& axisang )
 {
 	DEBUG_ERR( !IsZero( 1.0-axisang.axis.Length() ) ); // Not normalized axis
 
@@ -135,14 +135,14 @@ M_INLINE mat3_t::mat3_t( const axisang_t& axisang )
 }
 
 // constructor [float]
-M_INLINE mat3_t::mat3_t( float f )
+inline mat3_t::mat3_t( float f )
 {
 	for( int i=0; i<9; i++ )
 			ME[i] = f;
 }
 
 // 3x3 + 3x3
-M_INLINE mat3_t mat3_t::operator +( const mat3_t& b ) const
+inline mat3_t mat3_t::operator +( const mat3_t& b ) const
 {
 	mat3_t c;
 	for( int i=0; i<9; i++ )
@@ -151,7 +151,7 @@ M_INLINE mat3_t mat3_t::operator +( const mat3_t& b ) const
 }
 
 // 3x3 + 3x3 (self)
-M_INLINE mat3_t& mat3_t::operator +=( const mat3_t& b )
+inline mat3_t& mat3_t::operator +=( const mat3_t& b )
 {
 	for( int i=0; i<9; i++ )
 		ME[i] += b[i];
@@ -159,7 +159,7 @@ M_INLINE mat3_t& mat3_t::operator +=( const mat3_t& b )
 }
 
 // 3x3 - 3x3
-M_INLINE mat3_t mat3_t::operator -( const mat3_t& b ) const
+inline mat3_t mat3_t::operator -( const mat3_t& b ) const
 {
 	mat3_t c;
 	for( int i=0; i<9; i++ )
@@ -168,7 +168,7 @@ M_INLINE mat3_t mat3_t::operator -( const mat3_t& b ) const
 }
 
 // 3x3 - 3x3 (self)
-M_INLINE mat3_t& mat3_t::operator -=( const mat3_t& b )
+inline mat3_t& mat3_t::operator -=( const mat3_t& b )
 {
 	for( int i=0; i<9; i++ )
 		ME[i] -= b[i];
@@ -176,7 +176,7 @@ M_INLINE mat3_t& mat3_t::operator -=( const mat3_t& b )
 }
 
 // 3x3 * 3x3
-M_INLINE mat3_t mat3_t::operator *( const mat3_t& b ) const
+inline mat3_t mat3_t::operator *( const mat3_t& b ) const
 {
 	mat3_t c;
 	c(0, 0) = ME(0, 0)*b(0, 0) + ME(0, 1)*b(1, 0) + ME(0, 2)*b(2, 0);
@@ -192,14 +192,61 @@ M_INLINE mat3_t mat3_t::operator *( const mat3_t& b ) const
 }
 
 // 3x3 * 3x3 (self)
-M_INLINE mat3_t& mat3_t::operator *=( const mat3_t& b )
+inline mat3_t& mat3_t::operator *=( const mat3_t& b )
 {
 	ME = ME * b;
 	return ME;
 }
 
+// 3x3 + float
+inline mat3_t mat3_t::operator +( float f ) const
+{
+	mat3_t c;
+	for( uint i=0; i<9; i++ )
+		c[i] = ME[i] + f;
+	return c;
+}
+
+// float + 3x3
+inline mat3_t operator +( float f, const mat3_t& m3 )
+{
+	return m3+f;
+}
+
+// 3x3 += float
+inline mat3_t mat3_t::operator +=( float f ) const
+{
+	for( uint i=0; i<9; i++ )
+		ME[i] += f;
+}
+
+// 3x3 - float
+inline mat3_t mat3_t::operator -( float f ) const
+{
+	mat3_t c;
+	for( uint i=0; i<9; i++ )
+		c[i] = ME[i] - f;
+	return c;
+}
+
+// float - 3x3
+inline mat3_t operator -( float f, const mat3_t& m3 )
+{
+	mat3_t out;
+	for( uint i=0; i<9; i++ )
+		out[i] = f - m3[i];
+	return out;
+}
+
+// 3x3 -= float
+inline mat3_t mat3_t::operator -=( float f ) const
+{
+	for( uint i=0; i<9; i++ )
+		ME[i] -= f;
+}
+
 // 3x3 * float
-M_INLINE mat3_t mat3_t::operator *( float f ) const
+inline mat3_t mat3_t::operator *( float f ) const
 {
 	mat3_t c;
 	for( uint i=0; i<9; i++ )
@@ -207,16 +254,51 @@ M_INLINE mat3_t mat3_t::operator *( float f ) const
 	return c;
 }
 
+// float * 3x3
+inline mat3_t operator *( float f, const mat3_t& m3 )
+{
+	mat3_t out;
+	for( uint i=0; i<9; i++ )
+		out[i] = f * m3[i];
+	return out;
+}
+
 // 3x3 * float (self)
-M_INLINE mat3_t& mat3_t::operator *=( float f )
+inline mat3_t& mat3_t::operator *=( float f )
 {
 	for( uint i=0; i<9; i++ )
 		ME[i] *= f;
 	return ME;
 }
 
+// 3x3 / float
+inline mat3_t mat3_t::operator /( float f ) const
+{
+	mat3_t c;
+	for( uint i=0; i<9; i++ )
+		c[i] = ME[i] / f;
+	return c;
+}
+
+// float / 3x3
+inline mat3_t operator /( float f, const mat3_t& m3 )
+{
+	mat3_t out;
+	for( uint i=0; i<9; i++ )
+		out[i] = f / m3[i];
+	return out;
+}
+
+// 3x3 / float (self)
+inline mat3_t& mat3_t::operator /=( float f )
+{
+	for( uint i=0; i<9; i++ )
+		ME[i] /= f;
+	return ME;
+}
+
 // 3x3 * vec3 (cross products with rows)
-M_INLINE vec3_t mat3_t::operator *( const vec3_t& b ) const
+inline vec3_t mat3_t::operator *( const vec3_t& b ) const
 {
 	return vec3_t(
 		ME(0, 0)*b.x + ME(0, 1)*b.y + ME(0, 2)*b.z,
@@ -226,7 +308,7 @@ M_INLINE vec3_t mat3_t::operator *( const vec3_t& b ) const
 }
 
 // ==
-M_INLINE bool mat3_t::operator ==( const mat3_t& b ) const
+inline bool mat3_t::operator ==( const mat3_t& b ) const
 {
 	for( int i=0; i<9; i++ )
 		if( !IsZero( ME[i]-b[i] ) ) return false;
@@ -234,7 +316,7 @@ M_INLINE bool mat3_t::operator ==( const mat3_t& b ) const
 }
 
 // !=
-M_INLINE bool mat3_t::operator !=( const mat3_t& b ) const
+inline bool mat3_t::operator !=( const mat3_t& b ) const
 {
 	for( int i=0; i<9; i++ )
 		if( !IsZero( ME[i]-b[i] ) ) return true;
@@ -242,7 +324,7 @@ M_INLINE bool mat3_t::operator !=( const mat3_t& b ) const
 }
 
 // SetRows
-M_INLINE void mat3_t::SetRows( const vec3_t& a, const vec3_t& b, const vec3_t& c )
+inline void mat3_t::SetRows( const vec3_t& a, const vec3_t& b, const vec3_t& c )
 {
 	ME(0,0) = a.x;
 	ME(0,1) = a.y;
@@ -256,7 +338,7 @@ M_INLINE void mat3_t::SetRows( const vec3_t& a, const vec3_t& b, const vec3_t& c
 }
 
 // SetColumns
-M_INLINE void mat3_t::SetColumns( const vec3_t& a, const vec3_t& b, const vec3_t& c )
+inline void mat3_t::SetColumns( const vec3_t& a, const vec3_t& b, const vec3_t& c )
 {
 	ME(0,0) = a.x;
 	ME(1,0) = a.y;
@@ -270,7 +352,7 @@ M_INLINE void mat3_t::SetColumns( const vec3_t& a, const vec3_t& b, const vec3_t
 }
 
 // GetRows
-M_INLINE void mat3_t::GetRows( vec3_t& a, vec3_t& b, vec3_t& c ) const
+inline void mat3_t::GetRows( vec3_t& a, vec3_t& b, vec3_t& c ) const
 {
 	a.x = ME(0,0);
 	a.y = ME(0,1);
@@ -284,7 +366,7 @@ M_INLINE void mat3_t::GetRows( vec3_t& a, vec3_t& b, vec3_t& c ) const
 }
 
 // GetColumns
-M_INLINE void mat3_t::GetColumns( vec3_t& a, vec3_t& b, vec3_t& c ) const
+inline void mat3_t::GetColumns( vec3_t& a, vec3_t& b, vec3_t& c ) const
 {
 	a.x = ME(0,0);
 	a.y = ME(1,0);
@@ -298,7 +380,7 @@ M_INLINE void mat3_t::GetColumns( vec3_t& a, vec3_t& b, vec3_t& c ) const
 }
 
 // SetRow
-M_INLINE void mat3_t::SetRow( const uint i, const vec3_t& v )
+inline void mat3_t::SetRow( const uint i, const vec3_t& v )
 {
 	ME(i,0)=v.x;
 	ME(i,1)=v.y;
@@ -306,13 +388,13 @@ M_INLINE void mat3_t::SetRow( const uint i, const vec3_t& v )
 }
 
 // GetRow
-M_INLINE vec3_t mat3_t::GetRow( const uint i ) const
+inline vec3_t mat3_t::GetRow( const uint i ) const
 {
 	return vec3_t( ME(i,0), ME(i,1), ME(i,2) );
 }
 
 // SetColumn
-M_INLINE void mat3_t::SetColumn( const uint i, const vec3_t& v )
+inline void mat3_t::SetColumn( const uint i, const vec3_t& v )
 {
 	ME(0,i)=v.x;
 	ME(1,i)=v.y;
@@ -320,13 +402,13 @@ M_INLINE void mat3_t::SetColumn( const uint i, const vec3_t& v )
 }
 
 // GetColumn
-M_INLINE vec3_t mat3_t::GetColumn( const uint i ) const
+inline vec3_t mat3_t::GetColumn( const uint i ) const
 {
 	return vec3_t( ME(0,i), ME(1,i), ME(2,i) );
 }
 
 // SetRotationX
-M_INLINE void mat3_t::SetRotationX( float rad )
+inline void mat3_t::SetRotationX( float rad )
 {
 	float sintheta, costheta;
 	SinCos( rad, sintheta, costheta );
@@ -343,7 +425,7 @@ M_INLINE void mat3_t::SetRotationX( float rad )
 }
 
 // SetRotationY
-M_INLINE void mat3_t::SetRotationY( float rad )
+inline void mat3_t::SetRotationY( float rad )
 {
 	float sintheta, costheta;
 	SinCos( rad, sintheta, costheta );
@@ -360,7 +442,7 @@ M_INLINE void mat3_t::SetRotationY( float rad )
 }
 
 // LoadRotationZ
-M_INLINE void mat3_t::SetRotationZ( float rad )
+inline void mat3_t::SetRotationZ( float rad )
 {
 	float sintheta, costheta;
 	SinCos( rad, sintheta, costheta );
@@ -381,7 +463,7 @@ M_INLINE void mat3_t::SetRotationZ( float rad )
 If we analize the mat3 we can extract the 3 unit vectors rotated by the mat3. The 3 rotated vectors are in mat's colomns.
 This means that: mat3.colomn[0] == i*mat3. RotateXAxis() rotates rad angle not from i vector (aka x axis) but
 from the vector from colomn 0*/
-M_INLINE void mat3_t::RotateXAxis( float rad )
+inline void mat3_t::RotateXAxis( float rad )
 {
 	float sina, cosa;
 	SinCos( rad, sina, cosa );
@@ -416,7 +498,7 @@ M_INLINE void mat3_t::RotateXAxis( float rad )
 }
 
 // RotateYAxis
-M_INLINE void mat3_t::RotateYAxis( float rad )
+inline void mat3_t::RotateYAxis( float rad )
 {
 	float sina, cosa;
 	SinCos( rad, sina, cosa );
@@ -451,7 +533,7 @@ M_INLINE void mat3_t::RotateYAxis( float rad )
 
 
 // RotateZAxis
-M_INLINE void mat3_t::RotateZAxis( float rad )
+inline void mat3_t::RotateZAxis( float rad )
 {
 	float sina, cosa;
 	SinCos( rad, sina, cosa );
@@ -485,7 +567,7 @@ M_INLINE void mat3_t::RotateZAxis( float rad )
 }
 
 // Transpose
-M_INLINE void mat3_t::Transpose()
+inline void mat3_t::Transpose()
 {
 	float temp = ME(0,1);
 	ME(0,1) = ME(1,0);
@@ -499,7 +581,7 @@ M_INLINE void mat3_t::Transpose()
 }
 
 // Transposed
-M_INLINE mat3_t mat3_t::GetTransposed() const
+inline mat3_t mat3_t::GetTransposed() const
 {
 	mat3_t m3;
 	m3[0] = ME[0];
@@ -515,7 +597,7 @@ M_INLINE mat3_t mat3_t::GetTransposed() const
 }
 
 // Reorthogonalize
-M_INLINE void mat3_t::Reorthogonalize()
+inline void mat3_t::Reorthogonalize()
 {
 	// method 1: standard orthogonalization method
 	/*mat3_t correction_m3 =
@@ -541,7 +623,7 @@ M_INLINE void mat3_t::Reorthogonalize()
 }
 
 // Print
-M_INLINE void mat3_t::Print() const
+inline void mat3_t::Print() const
 {
 	for( int i=0; i<3; i++ )
 	{
@@ -553,7 +635,7 @@ M_INLINE void mat3_t::Print() const
 }
 
 // Determinant
-M_INLINE float mat3_t::Det() const
+inline float mat3_t::Det() const
 {
 	/* accurate method:
 	return ME(0, 0)*ME(1, 1)*ME(2, 2) + ME(0, 1)*ME(1, 2)*ME(2, 0) + ME(0, 2)*ME(1, 0)*ME(2, 1)
@@ -563,9 +645,9 @@ M_INLINE float mat3_t::Det() const
 	ME(0, 2)*( ME(0, 1)*ME(2, 1) - ME(1, 1)*ME(2, 0) );
 }
 
-// Invert
+// GetInverse
 // using Gramer's method ( Inv(A) = ( 1/Det(A) ) * Adj(A)  )
-M_INLINE mat3_t mat3_t::GetInverse() const
+inline mat3_t mat3_t::GetInverse() const
 {
 	mat3_t result;
 
@@ -596,20 +678,20 @@ M_INLINE mat3_t mat3_t::GetInverse() const
 
 // Invert
 // see above
-M_INLINE void mat3_t::Invert()
+inline void mat3_t::Invert()
 {
 	ME = GetInverse();
 }
 
 // GetZero
-M_INLINE const mat3_t& mat3_t::GetZero()
+inline const mat3_t& mat3_t::GetZero()
 {
 	static mat3_t zero( 0.0 );
 	return zero;
 }
 
 // GetIdentity
-M_INLINE const mat3_t& mat3_t::GetIdentity()
+inline const mat3_t& mat3_t::GetIdentity()
 {
 	static mat3_t ident( 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 );
 	return ident;

src/math/mat4.h

@@ -82,6 +82,13 @@ class mat4_t
 };
 
 
+// other operators
+extern mat4_t operator +( float f, const mat4_t& m4 );
+extern mat4_t operator -( float f, const mat4_t& m4 );
+extern mat4_t operator *( float f, const mat4_t& m4 );
+extern mat4_t operator /( float f, const mat4_t& m4 );
+
+
 } // end namespace
 
 

src/math/mat4.inl.h

@@ -7,42 +7,42 @@
 namespace m {
 
 // accessors
-M_INLINE float& mat4_t::operator ()( const uint i, const uint j )
+inline float& mat4_t::operator ()( const uint i, const uint j )
 {
 	return arr2[i][j];
 }
 
-M_INLINE const float& mat4_t::operator ()( const uint i, const uint j ) const
+inline const float& mat4_t::operator ()( const uint i, const uint j ) const
 {
 	return arr2[i][j];
 }
 
-M_INLINE float& mat4_t::operator []( const uint i) 
+inline float& mat4_t::operator []( const uint i) 
 { 
 	return arr1[i]; 
 }
 
-M_INLINE const float& mat4_t::operator []( const uint i) const 
+inline const float& mat4_t::operator []( const uint i) const 
 { 
 	return arr1[i]; 
 }
 
 // constructor [mat4]
-M_INLINE mat4_t::mat4_t( const mat4_t& b )
+inline mat4_t::mat4_t( const mat4_t& b )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] = b[i];
 }
 
 // constructor [float[]]
-M_INLINE mat4_t::mat4_t( const float arr_ [] )
+inline mat4_t::mat4_t( const float arr_ [] )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] = arr_[i];
 }
 
 // constructor [float..........]
-M_INLINE mat4_t::mat4_t( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 )
+inline mat4_t::mat4_t( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 )
 {
 	ME(0,0) = m00;
 	ME(0,1) = m01;
@@ -63,7 +63,7 @@ M_INLINE mat4_t::mat4_t( float m00, float m01, float m02, float m03, float m10,
 }
 
 // constructor [mat3]
-M_INLINE mat4_t::mat4_t( const mat3_t& m3 )
+inline mat4_t::mat4_t( const mat3_t& m3 )
 {
 	ME(0,0) = m3(0,0);
 	ME(0,1) = m3(0,1);
@@ -79,7 +79,7 @@ M_INLINE mat4_t::mat4_t( const mat3_t& m3 )
 }
 
 // constructor [vec3]
-M_INLINE mat4_t::mat4_t( const vec3_t& v )
+inline mat4_t::mat4_t( const vec3_t& v )
 {
 	ME(0, 0) = 1.0;
 	ME(0, 1) = 0.0;
@@ -100,7 +100,7 @@ M_INLINE mat4_t::mat4_t( const vec3_t& v )
 }
 
 // constructor [vec4]
-M_INLINE mat4_t::mat4_t( const vec4_t& v )
+inline mat4_t::mat4_t( const vec4_t& v )
 {
 	ME(0, 0) = 1.0;
 	ME(0, 1) = 0.0;
@@ -121,7 +121,7 @@ M_INLINE mat4_t::mat4_t( const vec4_t& v )
 }
 
 // constructor [vec3, mat3]
-M_INLINE mat4_t::mat4_t( const vec3_t& transl, const mat3_t& rot )
+inline mat4_t::mat4_t( const vec3_t& transl, const mat3_t& rot )
 {
 	SetRotationPart(rot);
 	SetTranslationPart(transl);
@@ -130,7 +130,7 @@ M_INLINE mat4_t::mat4_t( const vec3_t& transl, const mat3_t& rot )
 }
 
 // constructor [vec3, mat3, float]
-M_INLINE mat4_t::mat4_t( const vec3_t& translate, const mat3_t& rotate, float scale )
+inline mat4_t::mat4_t( const vec3_t& translate, const mat3_t& rotate, float scale )
 {
 	if( !IsZero( scale-1.0 ) )
 		SetRotationPart( rotate*scale );
@@ -144,14 +144,14 @@ M_INLINE mat4_t::mat4_t( const vec3_t& translate, const mat3_t& rotate, float sc
 }
 
 // constructor [float]
-M_INLINE mat4_t::mat4_t( float f )
+inline mat4_t::mat4_t( float f )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] = f;
 }
 
 // 4x4 + 4x4
-M_INLINE mat4_t mat4_t::operator +( const mat4_t& b ) const
+inline mat4_t mat4_t::operator +( const mat4_t& b ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -160,7 +160,7 @@ M_INLINE mat4_t mat4_t::operator +( const mat4_t& b ) const
 }
 
 // 4x4 + 4x4 (self)
-M_INLINE mat4_t& mat4_t::operator +=( const mat4_t& b )
+inline mat4_t& mat4_t::operator +=( const mat4_t& b )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] += b[i];
@@ -168,7 +168,7 @@ M_INLINE mat4_t& mat4_t::operator +=( const mat4_t& b )
 }
 
 // 4x4 - 4x4
-M_INLINE mat4_t mat4_t::operator -( const mat4_t& b ) const
+inline mat4_t mat4_t::operator -( const mat4_t& b ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -177,7 +177,7 @@ M_INLINE mat4_t mat4_t::operator -( const mat4_t& b ) const
 }
 
 // 4x4 - 4x4 (self)
-M_INLINE mat4_t& mat4_t::operator -=( const mat4_t& b )
+inline mat4_t& mat4_t::operator -=( const mat4_t& b )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] -= b[i];
@@ -185,7 +185,7 @@ M_INLINE mat4_t& mat4_t::operator -=( const mat4_t& b )
 }
 
 // 4x4 * 4x4
-M_INLINE mat4_t mat4_t::operator *( const mat4_t& b ) const
+inline mat4_t mat4_t::operator *( const mat4_t& b ) const
 {
 	mat4_t c;
 	c(0,0) = ME(0,0)*b(0,0) + ME(0,1)*b(1,0) + ME(0,2)*b(2,0) + ME(0,3)*b(3,0);
@@ -208,14 +208,14 @@ M_INLINE mat4_t mat4_t::operator *( const mat4_t& b ) const
 }
 
 // 4x4 * 4x4 (self)
-M_INLINE mat4_t& mat4_t::operator *=( const mat4_t& b )
+inline mat4_t& mat4_t::operator *=( const mat4_t& b )
 {
 	ME = ME * b;
 	return ME;
 }
 
 // ==
-M_INLINE bool mat4_t::operator ==( const mat4_t& b ) const
+inline bool mat4_t::operator ==( const mat4_t& b ) const
 {
 	for( int i=0; i<16; i++ )
 		if( !IsZero( ME[i]-b[i] ) ) return false;
@@ -223,7 +223,7 @@ M_INLINE bool mat4_t::operator ==( const mat4_t& b ) const
 }
 
 // !=
-M_INLINE bool mat4_t::operator !=( const mat4_t& b ) const
+inline bool mat4_t::operator !=( const mat4_t& b ) const
 {
 	for( int i=0; i<16; i++ )
 		if( !IsZero( ME[i]-b[i] ) ) return true;
@@ -231,7 +231,7 @@ M_INLINE bool mat4_t::operator !=( const mat4_t& b ) const
 }
 
 // 4x4 * vec4
-M_INLINE vec4_t mat4_t::operator *( const vec4_t& b ) const
+inline vec4_t mat4_t::operator *( const vec4_t& b ) const
 {
 	return vec4_t(
 		ME(0,0)*b.x + ME(0,1)*b.y + ME(0,2)*b.z + ME(0,3)*b.w,
@@ -242,7 +242,7 @@ M_INLINE vec4_t mat4_t::operator *( const vec4_t& b ) const
 }
 
 // 4x4 + float
-M_INLINE mat4_t mat4_t::operator +( float f ) const
+inline mat4_t mat4_t::operator +( float f ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -250,8 +250,14 @@ M_INLINE mat4_t mat4_t::operator +( float f ) const
 	return c;
 }
 
+// float + 4x4
+inline mat4_t operator +( float f, const mat4_t& m4 )
+{
+	return m4+f;
+}
+
 // 4x4 + float (self)
-M_INLINE mat4_t& mat4_t::operator +=( float f )
+inline mat4_t& mat4_t::operator +=( float f )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] += f;
@@ -259,7 +265,7 @@ M_INLINE mat4_t& mat4_t::operator +=( float f )
 }
 
 // 4x4 - float
-M_INLINE mat4_t mat4_t::operator -( float f ) const
+inline mat4_t mat4_t::operator -( float f ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -267,16 +273,25 @@ M_INLINE mat4_t mat4_t::operator -( float f ) const
 	return c;
 }
 
+// float - 4x4
+inline mat4_t operator -( float f, const mat4_t& m4 )
+{
+	mat4_t out;
+	for( int i=0; i<16; i++ )
+		out[i] = f- m3[i];
+	return out;
+}
+
 // 4x4 - float (self)
-M_INLINE mat4_t& mat4_t::operator -=( float f )
+inline mat4_t& mat4_t::operator -=( float f )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] -= f;
 	return ME;
 }
 
-// 4x4 * scalar
-M_INLINE mat4_t mat4_t::operator *( float f ) const
+// 4x4 * float
+inline mat4_t mat4_t::operator *( float f ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -284,16 +299,22 @@ M_INLINE mat4_t mat4_t::operator *( float f ) const
 	return c;
 }
 
-// 4x4 * scalar (self)
-M_INLINE mat4_t& mat4_t::operator *=( float f )
+// float * 4x4
+inline mat4_t operator *( float f, const mat4_t& m4 )
+{
+	return m4*f;
+}
+
+// 4x4 *= float
+inline mat4_t& mat4_t::operator *=( float f )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] *= f;
 	return ME;
 }
 
-// 4x4 / scalar
-M_INLINE mat4_t mat4_t::operator /( float f ) const
+// 4x4 / float
+inline mat4_t mat4_t::operator /( float f ) const
 {
 	mat4_t c;
 	for( int i=0; i<16; i++ )
@@ -301,8 +322,17 @@ M_INLINE mat4_t mat4_t::operator /( float f ) const
 	return c;
 }
 
-// 4x4 / scalar (self)
-M_INLINE mat4_t& mat4_t::operator /=( float f )
+// float / 4x4
+inline mat4_t operator /( float f, const mat4_t& m4 )
+{
+	mat4_t out;
+	for( uint i=0; i<9; i++ )
+		out = f / m4[i];
+	return out;
+}
+
+// 4x4 /= float
+inline mat4_t& mat4_t::operator /=( float f )
 {
 	for( int i=0; i<16; i++ )
 		ME[i] /= f;
@@ -310,7 +340,7 @@ M_INLINE mat4_t& mat4_t::operator /=( float f )
 }
 
 // SetRows
-M_INLINE void mat4_t::SetRows( const vec4_t& a, const vec4_t& b, const vec4_t& c, const vec4_t& d )
+inline void mat4_t::SetRows( const vec4_t& a, const vec4_t& b, const vec4_t& c, const vec4_t& d )
 {
 	ME(0,0) = a.x;
 	ME(0,1) = a.y;
@@ -331,7 +361,7 @@ M_INLINE void mat4_t::SetRows( const vec4_t& a, const vec4_t& b, const vec4_t& c
 }
 
 // SetRow
-M_INLINE void mat4_t::SetRow( uint i, const vec4_t& v )
+inline void mat4_t::SetRow( uint i, const vec4_t& v )
 {
 	DEBUG_ERR( i > 3 );
 	ME(i,0) = v.x;
@@ -341,7 +371,7 @@ M_INLINE void mat4_t::SetRow( uint i, const vec4_t& v )
 }
 
 // SetColumns
-M_INLINE void mat4_t::SetColumns( const vec4_t& a, const vec4_t& b, const vec4_t& c, const vec4_t& d )
+inline void mat4_t::SetColumns( const vec4_t& a, const vec4_t& b, const vec4_t& c, const vec4_t& d )
 {
 	ME(0,0) = a.x;
 	ME(1,0) = a.y;
@@ -362,7 +392,7 @@ M_INLINE void mat4_t::SetColumns( const vec4_t& a, const vec4_t& b, const vec4_t
 }
 
 // SetColumn
-M_INLINE void mat4_t::SetColumn( uint i, const vec4_t& v )
+inline void mat4_t::SetColumn( uint i, const vec4_t& v )
 {
 	DEBUG_ERR( i > 3 );
 	ME(0,i) = v.x;
@@ -372,7 +402,7 @@ M_INLINE void mat4_t::SetColumn( uint i, const vec4_t& v )
 }
 
 // Transpose
-M_INLINE void mat4_t::Transpose()
+inline void mat4_t::Transpose()
 {
 	float tmp = ME(0,1);
 	ME(0,1) = ME(1,0);
@@ -396,7 +426,7 @@ M_INLINE void mat4_t::Transpose()
 
 // GetTransposed
 // return the transposed
-M_INLINE mat4_t mat4_t::GetTransposed() const
+inline mat4_t mat4_t::GetTransposed() const
 {
 	mat4_t m4;
 	m4[0] = ME[0];
@@ -419,7 +449,7 @@ M_INLINE mat4_t mat4_t::GetTransposed() const
 }
 
 // SetRotationPart
-M_INLINE void mat4_t::SetRotationPart( const mat3_t& m3 )
+inline void mat4_t::SetRotationPart( const mat3_t& m3 )
 {
 	ME(0,0) = m3(0,0);
 	ME(0,1) = m3(0,1);
@@ -433,7 +463,7 @@ M_INLINE void mat4_t::SetRotationPart( const mat3_t& m3 )
 }
 
 // GetRotationPart
-M_INLINE mat3_t mat4_t::GetRotationPart() const
+inline mat3_t mat4_t::GetRotationPart() const
 {
 	mat3_t m3;
 	m3(0,0) = ME(0,0);
@@ -449,7 +479,7 @@ M_INLINE mat3_t mat4_t::GetRotationPart() const
 }
 
 // SetTranslationPart
-M_INLINE void mat4_t::SetTranslationPart( const vec4_t& v )
+inline void mat4_t::SetTranslationPart( const vec4_t& v )
 {
 	ME(0, 3) = v.x;
 	ME(1, 3) = v.y;
@@ -458,7 +488,7 @@ M_INLINE void mat4_t::SetTranslationPart( const vec4_t& v )
 }
 
 // SetTranslationPart
-M_INLINE void mat4_t::SetTranslationPart( const vec3_t& v )
+inline void mat4_t::SetTranslationPart( const vec3_t& v )
 {
 	ME(0, 3) = v.x;
 	ME(1, 3) = v.y;
@@ -466,27 +496,27 @@ M_INLINE void mat4_t::SetTranslationPart( const vec3_t& v )
 }
 
 // GetTranslationPart
-M_INLINE vec3_t mat4_t::GetTranslationPart() const
+inline vec3_t mat4_t::GetTranslationPart() const
 {
 	return vec3_t( ME(0, 3), ME(1, 3), ME(2, 3) );
 }
 
 // GetIdentity
-M_INLINE const mat4_t& mat4_t::GetIdentity()
+inline const mat4_t& mat4_t::GetIdentity()
 {
 	static mat4_t ident( 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 );
 	return ident;
 }
 
 // GetZero
-M_INLINE const mat4_t& mat4_t::GetZero()
+inline const mat4_t& mat4_t::GetZero()
 {
 	static mat4_t zero( 0.0 );
 	return zero;
 }
 
 // Print
-M_INLINE void mat4_t::Print() const
+inline void mat4_t::Print() const
 {
 	cout << fixed;
 	for( int i=0; i<4; i++ )
@@ -504,7 +534,7 @@ M_INLINE void mat4_t::Print() const
 }
 
 // Determinant
-M_INLINE float mat4_t::Det() const
+inline float mat4_t::Det() const
 {
 	return
 	ME(0, 3)*ME(1, 2)*ME(2, 1)*ME(3, 0) - ME(0, 2)*ME(1, 3)*ME(2, 1)*ME(3, 0) -
@@ -522,13 +552,13 @@ M_INLINE float mat4_t::Det() const
 }
 
 // Invert
-M_INLINE void mat4_t::Invert()
+inline void mat4_t::Invert()
 {
 	ME = GetInverse();
 }
 
 // Inverted
-M_INLINE mat4_t mat4_t::GetInverse() const
+inline mat4_t mat4_t::GetInverse() const
 {
 	float tmp[12];
 	float det;
@@ -608,7 +638,7 @@ M_INLINE mat4_t mat4_t::GetInverse() const
 
 
 // GetInverseTransformation
-M_INLINE mat4_t mat4_t::GetInverseTransformation() const
+inline mat4_t mat4_t::GetInverseTransformation() const
 {
 	mat3_t inverted_rot = (GetRotationPart()).GetTransposed();
 	vec3_t inverted_tsl = GetTranslationPart();
@@ -617,13 +647,13 @@ M_INLINE mat4_t mat4_t::GetInverseTransformation() const
 }
 
 // Lerp
-M_INLINE mat4_t mat4_t::Lerp( const mat4_t& b, float t ) const
+inline mat4_t mat4_t::Lerp( const mat4_t& b, float t ) const
 {
 	return (ME*(1.0-t))+(b*t);
 }
 
 // CombineTransformations
-M_INLINE mat4_t mat4_t::CombineTransformations( const mat4_t& m0, const mat4_t& m1 )
+inline mat4_t mat4_t::CombineTransformations( const mat4_t& m0, const mat4_t& m1 )
 {
 	/* the clean code is:
 	mat3_t rot = m0.GetRotationPart() * m1.GetRotationPart();  // combine the rotations

src/math/quat.inl.h

@@ -7,42 +7,42 @@ namespace m {
 
 
 // constructor []
-M_INLINE quat_t::quat_t()
+inline quat_t::quat_t()
 	: x(0.0), y(0.0), z(0.0), w(1.0)
 {}
 
 // constructor [float]
-M_INLINE quat_t::quat_t( float f )
+inline quat_t::quat_t( float f )
 	: x(f), y(f), z(f), w(f)
 {}
 
 // constructor [float, float, float, float]
-M_INLINE quat_t::quat_t( float x_, float y_, float z_, float w_ )
+inline quat_t::quat_t( float x_, float y_, float z_, float w_ )
 	: x(x_), y(y_), z(z_), w(w_)
 {}
 
 // constructor [vec2, float, float]
-M_INLINE quat_t::quat_t( const vec2_t& v2, float z_, float w_ )
+inline quat_t::quat_t( const vec2_t& v2, float z_, float w_ )
 	: x(v2.x), y(v2.y), z(z_), w(w_)
 {}
 
 // constructor [vec3, float]
-M_INLINE quat_t::quat_t( const vec3_t& v3, float w_ )
+inline quat_t::quat_t( const vec3_t& v3, float w_ )
 	: x(v3.x), y(v3.y), z(v3.z), w(w_)
 {}
 
 // constructor [vec4]
-M_INLINE quat_t::quat_t( const vec4_t& v4 )
+inline quat_t::quat_t( const vec4_t& v4 )
 	: x(v4.x), y(v4.y), z(v4.z), w(v4.w)
 {}
 
 // constructor [quat]
-M_INLINE quat_t::quat_t( const quat_t& b )
+inline quat_t::quat_t( const quat_t& b )
 	: x(b.x), y(b.y), z(b.z), w(b.w)
 {}
 
 // constructor [mat3]
-M_INLINE quat_t::quat_t( const mat3_t& m3 )
+inline quat_t::quat_t( const mat3_t& m3 )
 {
 	float trace = m3(0, 0) + m3(1, 1) + m3(2, 2) + 1.0;
 	if( trace > EPSILON )
@@ -83,7 +83,7 @@ M_INLINE quat_t::quat_t( const mat3_t& m3 )
 }
 
 // constructor [euler]
-M_INLINE quat_t::quat_t( const euler_t& eu )
+inline quat_t::quat_t( const euler_t& eu )
 {
 	float cx, sx;
 	SinCos( eu.heading()*0.5, sx, cx );
@@ -103,7 +103,7 @@ M_INLINE quat_t::quat_t( const euler_t& eu )
 }
 
 // constructor [euler]
-M_INLINE quat_t::quat_t( const axisang_t& axisang )
+inline quat_t::quat_t( const axisang_t& axisang )
 {
 	float lengthsq = axisang.axis.LengthSquared();
 	if( IsZero( lengthsq ) )
@@ -126,7 +126,7 @@ M_INLINE quat_t::quat_t( const axisang_t& axisang )
 }
 
 // *
-M_INLINE quat_t quat_t::operator *( const quat_t& b ) const
+inline quat_t quat_t::operator *( const quat_t& b ) const
 {
 	return quat_t(
 		 x * b.w + y * b.z - z * b.y + w * b.x,
@@ -137,26 +137,26 @@ M_INLINE quat_t quat_t::operator *( const quat_t& b ) const
 }
 
 // *=
-M_INLINE quat_t& quat_t::operator *=( const quat_t& b )
+inline quat_t& quat_t::operator *=( const quat_t& b )
 {
 	ME = ME * b;
 	return ME;
 }
 
 // ==
-M_INLINE bool quat_t::operator ==( const quat_t& b ) const
+inline bool quat_t::operator ==( const quat_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) && IsZero(z-b.z) && IsZero(w-b.w) ) ? true : false;
 }
 
 // !=
-M_INLINE bool quat_t::operator !=( const quat_t& b ) const
+inline bool quat_t::operator !=( const quat_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) && IsZero(z-b.z) && IsZero(w-b.w) ) ? false : true;
 }
 
 // Conjugate
-M_INLINE void quat_t::Conjugate()
+inline void quat_t::Conjugate()
 {
 	x = -x;
 	y = -y;
@@ -164,31 +164,31 @@ M_INLINE void quat_t::Conjugate()
 }
 
 // Conjugated
-M_INLINE quat_t quat_t::Conjugated() const
+inline quat_t quat_t::Conjugated() const
 {
 	return quat_t( -x, -y, -z, w );
 }
 
 // Normalized
-M_INLINE quat_t quat_t::GetNormalized() const
+inline quat_t quat_t::GetNormalized() const
 {
 	return quat_t( vec4_t(ME).GetNormalized() );
 }
 
 // Normalize
-M_INLINE void quat_t::Normalize()
+inline void quat_t::Normalize()
 {
 	ME = GetNormalized();
 }
 
 // Length
-M_INLINE float quat_t::Length() const
+inline float quat_t::Length() const
 {
 	return Sqrt( w*w + x*x + y*y + z*z );
 }
 
 // Invert
-M_INLINE void quat_t::Invert()
+inline void quat_t::Invert()
 {
 	float norm = w*w + x*x + y*y + z*z;
 
@@ -199,13 +199,13 @@ M_INLINE void quat_t::Invert()
 }
 
 // Print
-M_INLINE void quat_t::Print() const
+inline void quat_t::Print() const
 {
 	cout << fixed << "(w,x,y,z) = " << w << ' ' << x << ' ' << y << ' ' << z  << '\n' << endl;
 }
 
 // CalcFromVecVec
-M_INLINE void quat_t::CalcFrom2Vec3( const vec3_t& from, const vec3_t& to )
+inline void quat_t::CalcFrom2Vec3( const vec3_t& from, const vec3_t& to )
 {
 	vec3_t axis( from.Cross(to) );
 	ME = quat_t( axis.x, axis.y, axis.z, from.Dot(to) );
@@ -223,25 +223,25 @@ M_INLINE void quat_t::CalcFrom2Vec3( const vec3_t& from, const vec3_t& to )
 }
 
 // Rotated
-M_INLINE quat_t quat_t::GetRotated( const quat_t& b ) const
+inline quat_t quat_t::GetRotated( const quat_t& b ) const
 {
 	return ME * b;
 }
 
 // Rotate
-M_INLINE void quat_t::Rotate( const quat_t& b )
+inline void quat_t::Rotate( const quat_t& b )
 {
 	ME = GetRotated( b );
 }
 
 // Dot
-M_INLINE float quat_t::Dot( const quat_t& b ) const
+inline float quat_t::Dot( const quat_t& b ) const
 {
 	return w*b.w + x*b.x + y*b.y + z*b.z;
 }
 
 // SLERP
-M_INLINE quat_t quat_t::Slerp( const quat_t& q1_, float t ) const
+inline quat_t quat_t::Slerp( const quat_t& q1_, float t ) const
 {
 	const quat_t& q0 = ME;
 	quat_t q1( q1_ );

src/math/vec2.h

@@ -59,6 +59,13 @@ class vec2_t
 };
 
 
+// other operators
+extern vec2_t operator +( float f, const vec2_t& v2 );
+extern vec2_t operator -( float f, const vec2_t& v2 );
+extern vec2_t operator *( float f, const vec2_t& v2 );
+extern vec2_t operator /( float f, const vec2_t& v2 );
+
+
 } // end namespace
 
 

src/math/vec2.inl.h

@@ -6,50 +6,50 @@
 namespace m {
 
 // accessors
-M_INLINE float& vec2_t::operator []( uint i )
+inline float& vec2_t::operator []( uint i )
 {
 	return (&x)[i];
 }
 
-M_INLINE float vec2_t::operator []( uint i ) const
+inline float vec2_t::operator []( uint i ) const
 {
 	return (&x)[i];
 }
 
 // constructor []
-M_INLINE vec2_t::vec2_t()
+inline vec2_t::vec2_t()
 	: x(0.0), y(0.0)
 {}
 
 // constructor [float, float]
-M_INLINE vec2_t::vec2_t( float x_, float y_ )
+inline vec2_t::vec2_t( float x_, float y_ )
 	: x(x_), y(y_)
 {}
 
 // constructor [float]
-M_INLINE vec2_t::vec2_t( float f ): x(f), y(f)
+inline vec2_t::vec2_t( float f ): x(f), y(f)
 {}
 
 // constructor [vec2]
-M_INLINE vec2_t::vec2_t( const vec2_t& b ): x(b.x), y(b.y)
+inline vec2_t::vec2_t( const vec2_t& b ): x(b.x), y(b.y)
 {}
 
 // constructor [vec3]
-M_INLINE vec2_t::vec2_t( const vec3_t& v3 ): x(v3.x), y(v3.y)
+inline vec2_t::vec2_t( const vec3_t& v3 ): x(v3.x), y(v3.y)
 {}
 
 // constructor [vec4]
-M_INLINE vec2_t::vec2_t( const vec4_t& v4 ): x(v4.x), y(v4.y)
+inline vec2_t::vec2_t( const vec4_t& v4 ): x(v4.x), y(v4.y)
 {}
 
 // +
-M_INLINE vec2_t vec2_t::operator +( const vec2_t& b ) const
+inline vec2_t vec2_t::operator +( const vec2_t& b ) const
 {
 	return vec2_t( x+b.x, y+b.y );
 }
 
 // +=
-M_INLINE vec2_t& vec2_t::operator +=( const vec2_t& b )
+inline vec2_t& vec2_t::operator +=( const vec2_t& b )
 {
 	x += b.x;
 	y += b.y;
@@ -57,13 +57,13 @@ M_INLINE vec2_t& vec2_t::operator +=( const vec2_t& b )
 }
 
 // -
-M_INLINE vec2_t vec2_t::operator -( const vec2_t& b ) const
+inline vec2_t vec2_t::operator -( const vec2_t& b ) const
 {
 	return vec2_t( x-b.x, y-b.y );
 }
 
 // -=
-M_INLINE vec2_t& vec2_t::operator -=( const vec2_t& b )
+inline vec2_t& vec2_t::operator -=( const vec2_t& b )
 {
 	x -= b.x;
 	y -= b.y;
@@ -71,13 +71,13 @@ M_INLINE vec2_t& vec2_t::operator -=( const vec2_t& b )
 }
 
 // *
-M_INLINE vec2_t vec2_t::operator *( const vec2_t& b ) const
+inline vec2_t vec2_t::operator *( const vec2_t& b ) const
 {
 	return vec2_t( x*b.x, y*b.y );
 }
 
 // *=
-M_INLINE vec2_t& vec2_t::operator *=( const vec2_t& b )
+inline vec2_t& vec2_t::operator *=( const vec2_t& b )
 {
 	x *= b.x;
 	y *= b.y;
@@ -85,13 +85,13 @@ M_INLINE vec2_t& vec2_t::operator *=( const vec2_t& b )
 }
 
 // /
-M_INLINE vec2_t vec2_t::operator /( const vec2_t& b ) const
+inline vec2_t vec2_t::operator /( const vec2_t& b ) const
 {
 	return vec2_t( x/b.x, y/b.y );
 }
 
 // /=
-M_INLINE vec2_t& vec2_t::operator /=( const vec2_t& b )
+inline vec2_t& vec2_t::operator /=( const vec2_t& b )
 {
 	x /= b.x;
 	y /= b.y;
@@ -99,119 +99,143 @@ M_INLINE vec2_t& vec2_t::operator /=( const vec2_t& b )
 }
 
 // negative
-M_INLINE vec2_t vec2_t::operator -() const
+inline vec2_t vec2_t::operator -() const
 {
 	return vec2_t( -x, -y );
 }
 
 // ==
-M_INLINE bool vec2_t::operator ==( const vec2_t& b ) const
+inline bool vec2_t::operator ==( const vec2_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) ) ? true : false;
 }
 
 // !=
-M_INLINE bool vec2_t::operator !=( const vec2_t& b ) const
+inline bool vec2_t::operator !=( const vec2_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) ) ? false : true;
 }
 
 // vec2 + float
-M_INLINE vec2_t vec2_t::operator +( float f ) const
+inline vec2_t vec2_t::operator +( float f ) const
 {
 	return ME + vec2_t(f);
 }
 
+// float + vec2
+inline vec2_t operator +( float f, const vec2_t& v2 )
+{
+	return v2+f;
+}
+
 // vec2 += float
-M_INLINE vec2_t& vec2_t::operator +=( float f )
+inline vec2_t& vec2_t::operator +=( float f )
 {
 	ME += vec2_t(f);
 	return ME;
 }
 
 // vec2 - float
-M_INLINE vec2_t vec2_t::operator -( float f ) const
+inline vec2_t vec2_t::operator -( float f ) const
 {
 	return ME - vec2_t(f);
 }
 
+// float - vec2
+inline vec2_t operator -( float f, const vec2_t& v2 )
+{
+	return vec2_t( f-v2.x, f-v2.y );
+}
+
 // vec2 -= float
-M_INLINE vec2_t& vec2_t::operator -=( float f )
+inline vec2_t& vec2_t::operator -=( float f )
 {
 	ME -= vec2_t(f);
 	return ME;
 }
 
 // vec2 * float
-M_INLINE vec2_t vec2_t::operator *( float f ) const
+inline vec2_t vec2_t::operator *( float f ) const
 {
 	return ME * vec2_t(f);
 }
 
+// float * vec2
+inline vec2_t operator *( float f, const vec2_t& v2 )
+{
+	return v2*f;
+}
+
 // vec2 *= float
-M_INLINE vec2_t& vec2_t::operator *=( float f )
+inline vec2_t& vec2_t::operator *=( float f )
 {
 	ME *= vec2_t(f);
 	return ME;
 }
 
 // vec2 / float
-M_INLINE vec2_t vec2_t::operator /( float f ) const
+inline vec2_t vec2_t::operator /( float f ) const
 {
 	return ME / vec2_t(f);
 }
 
+// float / vec2
+inline vec2_t operator /( float f, const vec2_t& v2 )
+{
+	return vec2_t( f/v2.x, f/v2.y );
+}
+
 // vec2 /= float
-M_INLINE vec2_t& vec2_t::operator /=( float f )
+inline vec2_t& vec2_t::operator /=( float f )
 {
 	ME /= vec2_t(f);
 	return ME;
 }
 
 // Length
-M_INLINE float vec2_t::Length() const
+inline float vec2_t::Length() const
 {
 	return Sqrt( x*x + y*y );
 }
 
 // set to zero
-M_INLINE void vec2_t::SetZero()
+inline void vec2_t::SetZero()
 {
 	x = y = 0.0;
 }
 
 // Normalize
-M_INLINE void vec2_t::Normalize()
+inline void vec2_t::Normalize()
 {
 	ME *= InvSqrt( x*x + y*y );
 }
 
 // Normalized (return the normalized)
-M_INLINE vec2_t vec2_t::GetNormalized() const
+inline vec2_t vec2_t::GetNormalized() const
 {
 	return ME * InvSqrt( x*x + y*y );
 }
 
 // Dot
-M_INLINE float vec2_t::Dot( const vec2_t& b ) const
+inline float vec2_t::Dot( const vec2_t& b ) const
 {
 	return x*b.x + y*b.y;
 }
 
 // GetZero
-M_INLINE vec2_t vec2_t::GetZero()
+inline vec2_t vec2_t::GetZero()
 {
 	return vec2_t(0.0);
 }
 
 // GetOne
-M_INLINE vec2_t vec2_t::GetOne()
+inline vec2_t vec2_t::GetOne()
 {
 	return vec2_t(1.0);
 }
 
 // Print
-M_INLINE void vec2_t::Print() const
+inline void vec2_t::Print() const
 {
 	for( int i=0; i<2; i++ )
 		cout << fixed << ME[i] << ' ';

src/math/vec4.h

@@ -57,6 +57,13 @@ class vec4_t
 };
 
 
+// other operators
+extern vec4_t operator +( float f, const vec4_t& v4 );
+extern vec4_t operator -( float f, const vec4_t& v4 );
+extern vec4_t operator *( float f, const vec4_t& v4 );
+extern vec4_t operator /( float f, const vec4_t& v4 );
+
+
 } // end namespace
 
 

src/math/vec4.inl.h

@@ -8,59 +8,59 @@ namespace m {
 
 
 // accessors
-M_INLINE float& vec4_t::operator []( uint i )
+inline float& vec4_t::operator []( uint i )
 {
 	return (&x)[i];
 }
 
-M_INLINE float vec4_t::operator []( uint i ) const
+inline float vec4_t::operator []( uint i ) const
 {
 	return (&x)[i];
 }
 
 // constructor []
-M_INLINE vec4_t::vec4_t()
+inline vec4_t::vec4_t()
 	: x(0.0), y(0.0), z(0.0), w(0.0)
 {}
 
 // constructor [float]
-M_INLINE vec4_t::vec4_t( float f )
+inline vec4_t::vec4_t( float f )
 	: x(f), y(f), z(f), w(f)
 {}
 
 // constructor [float, float, float, float]
-M_INLINE vec4_t::vec4_t( float x_, float y_, float z_, float w_ )
+inline vec4_t::vec4_t( float x_, float y_, float z_, float w_ )
 	: x(x_), y(y_), z(z_), w(w_)
 {}
 
 // constructor [vec2, float, float]
-M_INLINE vec4_t::vec4_t( const vec2_t& v2, float z_, float w_ )
+inline vec4_t::vec4_t( const vec2_t& v2, float z_, float w_ )
 	: x(v2.x), y(v2.y), z(z_), w(w_)
 {}
 
 // constructor [vec3, float]
-M_INLINE vec4_t::vec4_t( const vec3_t& v3, float w_ )
+inline vec4_t::vec4_t( const vec3_t& v3, float w_ )
 	: x(v3.x), y(v3.y), z(v3.z), w(w_)
 {}
 
 // constructor [vec4]
-M_INLINE vec4_t::vec4_t( const vec4_t& b )
+inline vec4_t::vec4_t( const vec4_t& b )
 	: x(b.x), y(b.y), z(b.z), w(b.w)
 {}
 
 // constructor [quat]
-M_INLINE vec4_t::vec4_t( const quat_t& q )
+inline vec4_t::vec4_t( const quat_t& q )
 	: x(q.x), y(q.y), z(q.z), w(q.w)
 {}
 
 // +
-M_INLINE vec4_t vec4_t::operator +( const vec4_t& b ) const
+inline vec4_t vec4_t::operator +( const vec4_t& b ) const
 {
 	return vec4_t( x+b.x, y+b.y, z+b.z, w+b.w );
 }
 
 // +=
-M_INLINE vec4_t& vec4_t::operator +=( const vec4_t& b )
+inline vec4_t& vec4_t::operator +=( const vec4_t& b )
 {
 	x += b.x;
 	y += b.y;
@@ -70,13 +70,13 @@ M_INLINE vec4_t& vec4_t::operator +=( const vec4_t& b )
 }
 
 // -
-M_INLINE vec4_t vec4_t::operator -( const vec4_t& b ) const
+inline vec4_t vec4_t::operator -( const vec4_t& b ) const
 {
 	return vec4_t( x-b.x, y-b.y, z-b.z, w-b.w );
 }
 
 // -=
-M_INLINE vec4_t& vec4_t::operator -=( const vec4_t& b )
+inline vec4_t& vec4_t::operator -=( const vec4_t& b )
 {
 	x -= b.x;
 	y -= b.y;
@@ -86,13 +86,13 @@ M_INLINE vec4_t& vec4_t::operator -=( const vec4_t& b )
 }
 
 // *
-M_INLINE vec4_t vec4_t::operator *( const vec4_t& b ) const
+inline vec4_t vec4_t::operator *( const vec4_t& b ) const
 {
 	return vec4_t( x*b.x, y*b.y, z*b.z, w*b.w );
 }
 
 // *=
-M_INLINE vec4_t& vec4_t::operator *=( const vec4_t& b )
+inline vec4_t& vec4_t::operator *=( const vec4_t& b )
 {
 	x *= b.x;
 	y *= b.y;
@@ -102,13 +102,13 @@ M_INLINE vec4_t& vec4_t::operator *=( const vec4_t& b )
 }
 
 // /
-M_INLINE vec4_t vec4_t::operator /( const vec4_t& b ) const
+inline vec4_t vec4_t::operator /( const vec4_t& b ) const
 {
 	return vec4_t( x/b.x, y/b.y, z/b.z, w/b.w );
 }
 
 // /=
-M_INLINE vec4_t& vec4_t::operator /=( const vec4_t& b )
+inline vec4_t& vec4_t::operator /=( const vec4_t& b )
 {
 	x /= b.x;
 	y /= b.y;
@@ -118,77 +118,101 @@ M_INLINE vec4_t& vec4_t::operator /=( const vec4_t& b )
 }
 
 // negative
-M_INLINE vec4_t vec4_t::operator -() const
+inline vec4_t vec4_t::operator -() const
 {
 	return vec4_t( -x, -y, -z, -w );
 }
 
 // ==
-M_INLINE bool vec4_t::operator ==( const vec4_t& b ) const
+inline bool vec4_t::operator ==( const vec4_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) && IsZero(z-b.z) && IsZero(w-b.w) ) ? true : false;
 }
 
 // !=
-M_INLINE bool vec4_t::operator !=( const vec4_t& b ) const
+inline bool vec4_t::operator !=( const vec4_t& b ) const
 {
 	return ( IsZero(x-b.x) && IsZero(y-b.y) && IsZero(z-b.z) && IsZero(w-b.w) ) ? false : true;
 }
 
 // vec4 + float
-M_INLINE vec4_t vec4_t::operator +( float f ) const
+inline vec4_t vec4_t::operator +( float f ) const
 {
 	return ME + vec4_t(f);
 }
 
+// float + vec4
+vec4_t operator +( float f, const vec4_t& v4 )
+{
+	return v4+f;
+}
+
 // vec4 += float
-M_INLINE vec4_t& vec4_t::operator +=( float f )
+inline vec4_t& vec4_t::operator +=( float f )
 {
 	ME += vec4_t(f);
 	return ME;
 }
 
 // vec4 - float
-M_INLINE vec4_t vec4_t::operator -( float f ) const
+inline vec4_t vec4_t::operator -( float f ) const
 {
 	return ME - vec4_t(f);
 }
 
+// float - vec4
+vec4_t operator -( float f, const vec4_t& v4 )
+{
+	return vec4_t( f-v4.x, f-v4.y, f-v4.z, f-v4.w );
+}
+
 // vec4 -= float
-M_INLINE vec4_t& vec4_t::operator -=( float f )
+inline vec4_t& vec4_t::operator -=( float f )
 {
 	ME -= vec4_t(f);
 	return ME;
 }
 
 // vec4 * float
-M_INLINE vec4_t vec4_t::operator *( float f ) const
+inline vec4_t vec4_t::operator *( float f ) const
 {
 	return ME * vec4_t(f);
 }
 
+// float * vec4
+vec4_t operator *( float f, const vec4_t& v4 )
+{
+	return v4*f;
+}
+
 // vec4 *= float
-M_INLINE vec4_t& vec4_t::operator *=( float f )
+inline vec4_t& vec4_t::operator *=( float f )
 {
 	ME *= vec4_t(f);
 	return ME;
 }
 
 // vec4 / float
-M_INLINE vec4_t vec4_t::operator /( float f ) const
+inline vec4_t vec4_t::operator /( float f ) const
 {
 	return ME / vec4_t(f);
 }
 
+// float / vec4
+vec4_t operator /( float f, const vec4_t& v4 )
+{
+	return vec4_t( f/vec4.x, f/vec4.y, f/vec4.z, f/vec4.w );
+}
+
 // vec4 /= float
-M_INLINE vec4_t& vec4_t::operator /=( float f )
+inline vec4_t& vec4_t::operator /=( float f )
 {
 	ME /= vec4_t(f);
 	return ME;
 }
 
 // vec4 * mat4
-M_INLINE vec4_t vec4_t::operator *( const mat4_t& m4 ) const
+inline vec4_t vec4_t::operator *( const mat4_t& m4 ) const
 {
 	return vec4_t(
 		x*m4(0,0) + y*m4(1,0) + z*m4(2,0) + w*m4(3,0),
@@ -199,31 +223,31 @@ M_INLINE vec4_t vec4_t::operator *( const mat4_t& m4 ) const
 }
 
 // Dot
-M_INLINE float vec4_t::Dot( const vec4_t& b ) const
+inline float vec4_t::Dot( const vec4_t& b ) const
 {
 	return x*b.x + y*b.y + z*b.z + w*b.w;
 }
 
 // Length
-M_INLINE float vec4_t::Length() const
+inline float vec4_t::Length() const
 {
 	return Sqrt( x*x + y*y + z*z + w*w );
 }
 
 // Normalized
-M_INLINE vec4_t vec4_t::GetNormalized() const
+inline vec4_t vec4_t::GetNormalized() const
 {
 	return ME * InvSqrt( x*x +y*y + z*z + w*w );
 }
 
 // Normalize
-M_INLINE void vec4_t::Normalize()
+inline void vec4_t::Normalize()
 {
 	ME *= InvSqrt( x*x +y*y + z*z + w*w );
 }
 
 // Print
-M_INLINE void vec4_t::Print() const
+inline void vec4_t::Print() const
 {
 	for( int i=0; i<4; i++ )
 		cout << fixed << ME[i] << " ";