- Fixing the unit tests

- The first SIMD math lines of code

src/Core/Logger.h

@@ -21,7 +21,7 @@ class Logger
 		/// Accessor
 		Signal& getSignal() {return sig;}
 
-		/// @name Numeric operators
+		/// @name Operators for numbers
 		/// @{
 		Logger& operator<<(const bool& val) {return appendUsingLexicalCast(val);}
 		Logger& operator<<(const short& val) {return appendUsingLexicalCast(val);}
@@ -35,11 +35,14 @@ class Logger
 		Logger& operator<<(const long double& val) {return appendUsingLexicalCast(val);}
 		/// @}
 
+		/// @name Operators for other types
+		/// @{
 		Logger& operator<<(const void* val);
 		Logger& operator<<(const char* val);
 		Logger& operator<<(const std::string& val);
 		Logger& operator<<(Logger& (*funcPtr)(Logger&));
 		Logger& operator<<(const LoggerSender& sender);
+		/// @}
 
 		/// An alternative method to write in the Logger
 		void write(const char* file, int line, const char* func, const char* msg);

src/Math/Mat4.inl.h

@@ -106,19 +106,19 @@ inline Mat4::Mat4(const Vec4& v)
 	ME(0, 0) = 1.0;
 	ME(0, 1) = 0.0;
 	ME(0, 2) = 0.0;
-	ME(0, 3) = v.x;
+	ME(0, 3) = v.x();
 	ME(1, 0) = 0.0;
 	ME(1, 1) = 1.0;
 	ME(1, 2) = 0.0;
-	ME(1, 3) = v.y;
+	ME(1, 3) = v.y();
 	ME(2, 0) = 0.0;
 	ME(2, 1) = 0.0;
 	ME(2, 2) = 1.0;
-	ME(2, 3) = v.z;
+	ME(2, 3) = v.z();
 	ME(3, 0) = 0.0;
 	ME(3, 1) = 0.0;
 	ME(3, 2) = 0.0;
-	ME(3, 3) = v.w;
+	ME(3, 3) = v.w();
 }
 
 // constructor [vec3, mat3]
@@ -240,10 +240,10 @@ inline bool Mat4::operator !=(const Mat4& b) const
 // 4x4 * vec4
 inline Vec4 Mat4::operator *(const Vec4& b) const
 {
-	return Vec4(ME(0, 0)*b.x + ME(0, 1)*b.y + ME(0, 2)*b.z + ME(0, 3)*b.w,
-	            ME(1, 0)*b.x + ME(1, 1)*b.y + ME(1, 2)*b.z + ME(1, 3)*b.w,
-	            ME(2, 0)*b.x + ME(2, 1)*b.y + ME(2, 2)*b.z + ME(2, 3)*b.w,
-	            ME(3, 0)*b.x + ME(3, 1)*b.y + ME(3, 2)*b.z + ME(3, 3)*b.w);
+	return Vec4(ME(0, 0) * b.x() + ME(0, 1) * b.y() + ME(0, 2) * b.z() + ME(0, 3) * b.w(),
+	            ME(1, 0) * b.x() + ME(1, 1) * b.y() + ME(1, 2) * b.z() + ME(1, 3) * b.w(),
+	            ME(2, 0) * b.x() + ME(2, 1) * b.y() + ME(2, 2) * b.z() + ME(2, 3) * b.w(),
+	            ME(3, 0) * b.x() + ME(3, 1) * b.y() + ME(3, 2) * b.z() + ME(3, 3) * b.w());
 }
 
 // 4x4 + float
@@ -251,14 +251,16 @@ inline Mat4 Mat4::operator +(float f) const
 {
 	Mat4 c;
 	for(int i=0; i<16; i++)
+	{
 		c[i] = ME[i] + f;
+	}
 	return c;
 }
 
 // float + 4x4
 inline Mat4 operator +(float f, const Mat4& m4)
 {
-	return m4+f;
+	return m4 + f;
 }
 
 // 4x4 + float (self)
@@ -347,63 +349,63 @@ inline Mat4& Mat4::operator /=(float f)
 // setRows
 inline void Mat4::setRows(const Vec4& a, const Vec4& b, const Vec4& c, const Vec4& d)
 {
-	ME(0, 0) = a.x;
-	ME(0, 1) = a.y;
-	ME(0, 2) = a.z;
-	ME(0, 3) = a.w;
-	ME(1, 0) = b.x;
-	ME(1, 1) = b.y;
-	ME(1, 2) = b.z;
-	ME(1, 3) = b.w;
-	ME(2, 0) = c.x;
-	ME(2, 1) = c.y;
-	ME(2, 2) = c.z;
-	ME(2, 3) = c.w;
-	ME(3, 0) = d.x;
-	ME(3, 1) = d.y;
-	ME(3, 2) = d.z;
-	ME(3, 3) = d.w;
+	ME(0, 0) = a.x();
+	ME(0, 1) = a.y();
+	ME(0, 2) = a.z();
+	ME(0, 3) = a.w();
+	ME(1, 0) = b.x();
+	ME(1, 1) = b.y();
+	ME(1, 2) = b.z();
+	ME(1, 3) = b.w();
+	ME(2, 0) = c.x();
+	ME(2, 1) = c.y();
+	ME(2, 2) = c.z();
+	ME(2, 3) = c.w();
+	ME(3, 0) = d.x();
+	ME(3, 1) = d.y();
+	ME(3, 2) = d.z();
+	ME(3, 3) = d.w();
 }
 
 // setRow
 inline void Mat4::setRow(uint i, const Vec4& v)
 {
 	RASSERT_THROW_EXCEPTION(i > 3);
-	ME(i, 0) = v.x;
-	ME(i, 1) = v.y;
-	ME(i, 2) = v.z;
-	ME(i, 3) = v.w;
+	ME(i, 0) = v.x();
+	ME(i, 1) = v.y();
+	ME(i, 2) = v.z();
+	ME(i, 3) = v.w();
 }
 
 // setColumns
 inline void Mat4::setColumns(const Vec4& a, const Vec4& b, const Vec4& c, const Vec4& d)
 {
-	ME(0, 0) = a.x;
-	ME(1, 0) = a.y;
-	ME(2, 0) = a.z;
-	ME(3, 0) = a.w;
-	ME(0, 1) = b.x;
-	ME(1, 1) = b.y;
-	ME(2, 1) = b.z;
-	ME(3, 1) = b.w;
-	ME(0, 2) = c.x;
-	ME(1, 2) = c.y;
-	ME(2, 2) = c.z;
-	ME(3, 2) = c.w;
-	ME(0, 3) = d.x;
-	ME(1, 3) = d.y;
-	ME(2, 3) = d.z;
-	ME(3, 3) = d.w;
+	ME(0, 0) = a.x();
+	ME(1, 0) = a.y();
+	ME(2, 0) = a.z();
+	ME(3, 0) = a.w();
+	ME(0, 1) = b.x();
+	ME(1, 1) = b.y();
+	ME(2, 1) = b.z();
+	ME(3, 1) = b.w();
+	ME(0, 2) = c.x();
+	ME(1, 2) = c.y();
+	ME(2, 2) = c.z();
+	ME(3, 2) = c.w();
+	ME(0, 3) = d.x();
+	ME(1, 3) = d.y();
+	ME(2, 3) = d.z();
+	ME(3, 3) = d.w();
 }
 
 // setColumn
 inline void Mat4::setColumn(uint i, const Vec4& v)
 {
 	RASSERT_THROW_EXCEPTION(i > 3);
-	ME(0,i) = v.x;
-	ME(1,i) = v.y;
-	ME(2,i) = v.z;
-	ME(3,i) = v.w;
+	ME(0,i) = v.x();
+	ME(1,i) = v.y();
+	ME(2,i) = v.z();
+	ME(3,i) = v.w();
 }
 
 // transpose
@@ -486,10 +488,10 @@ inline Mat3 Mat4::getRotationPart() const
 // setTranslationPart
 inline void Mat4::setTranslationPart(const Vec4& v)
 {
-	ME(0, 3) = v.x;
-	ME(1, 3) = v.y;
-	ME(2, 3) = v.z;
-	ME(3, 3) = v.w;
+	ME(0, 3) = v.x();
+	ME(1, 3) = v.y();
+	ME(2, 3) = v.z();
+	ME(3, 3) = v.w();
 }
 
 // setTranslationPart

src/Math/Quat.inl.h

@@ -33,7 +33,7 @@ inline Quat::Quat(const Vec3& v3, float w_):
 
 // constructor [vec4]
 inline Quat::Quat(const Vec4& v4):
-	x(v4.x), y(v4.y), z(v4.z), w(v4.w)
+	x(v4.x()), y(v4.y()), z(v4.z()), w(v4.w())
 {}
 
 // constructor [quat]

src/Math/Vec2.inl.h

@@ -41,7 +41,7 @@ inline Vec2::Vec2(const Vec3& v3): x(v3.x), y(v3.y)
 {}
 
 // constructor [vec4]
-inline Vec2::Vec2(const Vec4& v4): x(v4.x), y(v4.y)
+inline Vec2::Vec2(const Vec4& v4): x(v4.x()), y(v4.y())
 {}
 
 // +

src/Math/Vec3.inl.h

@@ -45,7 +45,7 @@ inline Vec3::Vec3(const Vec2& v2, float z_)
 
 // constructor [vec4]
 inline Vec3::Vec3(const Vec4& v4)
-	: x(v4.x), y(v4.y), z(v4.z)
+	: x(v4.x()), y(v4.y()), z(v4.z())
 {}
 
 // constructor [quat]

src/Math/Vec4.h

@@ -1,7 +1,11 @@
 #ifndef VEC4_H
 #define VEC4_H
 
+#include <boost/array.hpp>
 #include "MathCommon.h"
+#if defined(MATH_INTEL_SIMD)
+	#include <tmmintrin.h>
+#endif
 
 
 namespace M {
@@ -11,15 +15,18 @@ namespace M {
 class Vec4
 {
 	public:
-		/// @name Data members
-		/// @{
-		float x, y, z, w;
-		/// @}
-
 		/// @name Accessors
 		/// @{
-		float& operator [](uint i);
-		float  operator [](uint i) const;
+		float& operator[](uint i);
+		float operator[](uint i) const;
+		float& x();
+		float x() const;
+		float& y();
+		float y() const;
+		float& z();
+		float z() const;
+		float& w();
+		float w() const;
 		/// @}
 
 		/// @name Constructors & distructors
@@ -35,34 +42,34 @@ class Vec4
 
 		/// @name Operators with same
 		/// @{
-		Vec4 operator +(const Vec4& b) const;
-		Vec4& operator +=(const Vec4& b);
-		Vec4 operator -(const Vec4& b) const;
-		Vec4& operator -=(const Vec4& b);
-		Vec4 operator *(const Vec4& b) const;
-		Vec4& operator *=(const Vec4& b);
-		Vec4 operator /(const Vec4& b) const;
-		Vec4& operator /=(const Vec4& b);
-		Vec4 operator -() const;
-		bool operator ==(const Vec4& b) const;
-		bool operator !=(const Vec4& b) const;
+		Vec4 operator+(const Vec4& b) const;
+		Vec4& operator+=(const Vec4& b);
+		Vec4 operator-(const Vec4& b) const;
+		Vec4& operator-=(const Vec4& b);
+		Vec4 operator*(const Vec4& b) const;
+		Vec4& operator*=(const Vec4& b);
+		Vec4 operator/(const Vec4& b) const;
+		Vec4& operator/=(const Vec4& b);
+		Vec4 operator-() const;
+		bool operator==(const Vec4& b) const;
+		bool operator!=(const Vec4& b) const;
 		/// @}
 
 		/// @name Operators with float
 		/// @{
-		Vec4 operator +(float f) const;
-		Vec4& operator +=(float f);
-		Vec4 operator -(float f) const;
-		Vec4& operator -=(float f);
-		Vec4 operator *(float f) const;
-		Vec4& operator *=(float f);
-		Vec4 operator /(float f) const;
-		Vec4& operator /=(float f);
+		Vec4 operator+(float f) const;
+		Vec4& operator+=(float f);
+		Vec4 operator-(float f) const;
+		Vec4& operator-=(float f);
+		Vec4 operator*(float f) const;
+		Vec4& operator*=(float f);
+		Vec4 operator/(float f) const;
+		Vec4& operator/=(float f);
 		/// @}
 
 		/// @name Operators with other
 		/// @{
-		Vec4  operator * (const Mat4& m4) const;
+		Vec4  operator*(const Mat4& m4) const;
 		/// @}
 
 		/// @name Other
@@ -72,15 +79,33 @@ class Vec4
 		void normalize();
 		float dot(const Vec4& b) const;
 		/// @}
+
+	private:
+		/// @name Data
+		/// @{
+		union
+		{
+			struct
+			{
+				float x, y, z, w;
+			} vec;
+
+			boost::array<float, 4> arr;
+
+			#if defined(MATH_INTEL_SIMD)
+				__m128 mm;
+			#endif
+		};
+		/// @}
 };
 
 
 /// @name Other operators
 /// @{
-extern Vec4 operator +(float f, const Vec4& v4);
-extern Vec4 operator -(float f, const Vec4& v4);
-extern Vec4 operator *(float f, const Vec4& v4);
-extern Vec4 operator /(float f, const Vec4& v4);
+extern Vec4 operator+(float f, const Vec4& v4);
+extern Vec4 operator-(float f, const Vec4& v4);
+extern Vec4 operator*(float f, const Vec4& v4);
+extern Vec4 operator/(float f, const Vec4& v4);
 extern std::ostream& operator<<(std::ostream& s, const Vec4& v);
 /// @}
 

src/Math/Vec4.inl.h

@@ -1,255 +1,333 @@
 #include "MathCommon.inl.h"
 
 
-#define ME (*this)
+#define SELF (*this)
 
 
 namespace M {
 
 
 // accessors
-inline float& Vec4::operator [](uint i)
+inline float& Vec4::operator[](uint i)
 {
-	return (&x)[i];
+	return arr[i];
 }
 
-inline float Vec4::operator [](uint i) const
+inline float Vec4::operator[](uint i) const
 {
-	return (&x)[i];
+	return arr[i];
+}
+
+inline float& Vec4::x()
+{
+	return vec.x;
+}
+
+inline float Vec4::x() const
+{
+	return vec.x;
+}
+
+inline float& Vec4::y()
+{
+	return vec.y;
+}
+
+inline float Vec4::y() const
+{
+	return vec.y;
+}
+
+inline float& Vec4::z()
+{
+	return vec.z;
+}
+
+inline float Vec4::z() const
+{
+	return vec.z;
+}
+
+inline float& Vec4::w()
+{
+	return vec.w;
+}
+
+inline float Vec4::w() const
+{
+	return vec.w;
 }
 
 // constructor []
 inline Vec4::Vec4()
-	: x(0.0), y(0.0), z(0.0), w(0.0)
-{}
+{
+	#if defined(MATH_INTEL_SIMD)
+		mm = _mm_setzero_ps();
+	#else
+		x() = y() = z() = w() = 0.0;
+	#endif
+}
 
 // constructor [float]
 inline Vec4::Vec4(float f)
-	: x(f), y(f), z(f), w(f)
-{}
+{
+	#if defined(MATH_INTEL_SIMD)
+		mm = _mm_set1_ps(f);
+	#else
+		x() = y() = z() = w() = f;
+	#endif
+}
 
 // constructor [float, float, float, float]
 inline Vec4::Vec4(float x_, float y_, float z_, float w_)
-	: x(x_), y(y_), z(z_), w(w_)
-{}
+{
+	#if defined(MATH_INTEL_SIMD)
+		mm = _mm_set1_ps(f);
+	#else
+		x() = x_;
+		y() = y_;
+		z() = z_;
+		w() = w_;
+	#endif
+}
 
 // constructor [vec2, float, float]
 inline Vec4::Vec4(const Vec2& v2, float z_, float w_)
-	: x(v2.x), y(v2.y), z(z_), w(w_)
-{}
+{
+	x() = v2.x;
+	y() = v2.y;
+	z() = z_;
+	w() = w_;
+}
 
 // constructor [vec3, float]
 inline Vec4::Vec4(const Vec3& v3, float w_)
-	: x(v3.x), y(v3.y), z(v3.z), w(w_)
-{}
+{
+	x() = v3.x;
+	y() = v3.y;
+	z() = v3.z;
+	w() = w_;
+}
 
 // constructor [vec4]
 inline Vec4::Vec4(const Vec4& b)
-	: x(b.x), y(b.y), z(b.z), w(b.w)
-{}
+{
+	#if defined(MATH_INTEL_SIMD)
+		mm = b.mm;
+	#else
+		x() = b.x();
+		y() = b.y();
+		z() = b.z();
+		w() = b.w();
+	#endif
+}
 
 // constructor [quat]
 inline Vec4::Vec4(const Quat& q)
-	: x(q.x), y(q.y), z(q.z), w(q.w)
-{}
+{
+	x() = q.x;
+	y() = q.y;
+	z() = q.z;
+	w() = q.w;
+}
 
 // +
-inline Vec4 Vec4::operator +(const Vec4& b) const
+inline Vec4 Vec4::operator+(const Vec4& b) const
 {
-	return Vec4(x+b.x, y+b.y, z+b.z, w+b.w);
+	return Vec4(x() + b.x(), y() + b.y(), z() + b.z(), w() + b.w());
 }
 
 // +=
-inline Vec4& Vec4::operator +=(const Vec4& b)
+inline Vec4& Vec4::operator+=(const Vec4& b)
 {
-	x += b.x;
-	y += b.y;
-	z += b.z;
-	w += b.w;
-	return ME;
+	x() += b.x();
+	y() += b.y();
+	z() += b.z();
+	w() += b.w();
+	return SELF;
 }
 
 // -
-inline Vec4 Vec4::operator -(const Vec4& b) const
+inline Vec4 Vec4::operator-(const Vec4& b) const
 {
-	return Vec4(x-b.x, y-b.y, z-b.z, w-b.w);
+	return Vec4(x() - b.x(), y() - b.y(), z() - b.z(), w() - b.w());
 }
 
 // -=
-inline Vec4& Vec4::operator -=(const Vec4& b)
+inline Vec4& Vec4::operator-=(const Vec4& b)
 {
-	x -= b.x;
-	y -= b.y;
-	z -= b.z;
-	w -= b.w;
-	return ME;
+	x() -= b.x();
+	y() -= b.y();
+	z() -= b.z();
+	w() -= b.w();
+	return SELF;
 }
 
 // *
-inline Vec4 Vec4::operator *(const Vec4& b) const
+inline Vec4 Vec4::operator*(const Vec4& b) const
 {
-	return Vec4(x*b.x, y*b.y, z*b.z, w*b.w);
+	return Vec4(x() * b.x(), y() * b.y(), z() * b.z(), w() * b.w());
 }
 
 // *=
-inline Vec4& Vec4::operator *=(const Vec4& b)
+inline Vec4& Vec4::operator*=(const Vec4& b)
 {
-	x *= b.x;
-	y *= b.y;
-	z *= b.z;
-	w *= b.w;
-	return ME;
+	x() *= b.x();
+	y() *= b.y();
+	z() *= b.z();
+	w() *= b.w();
+	return SELF;
 }
 
 // /
-inline Vec4 Vec4::operator /(const Vec4& b) const
+inline Vec4 Vec4::operator/(const Vec4& b) const
 {
-	return Vec4(x/b.x, y/b.y, z/b.z, w/b.w);
+	return Vec4(x() / b.x(), y() / b.y(), z() / b.z(), w() / b.w());
 }
 
 // /=
-inline Vec4& Vec4::operator /=(const Vec4& b)
+inline Vec4& Vec4::operator/=(const Vec4& b)
 {
-	x /= b.x;
-	y /= b.y;
-	z /= b.z;
-	w /= b.w;
-	return ME;
+	x() /= b.x();
+	y() /= b.y();
+	z() /= b.z();
+	w() /= b.w();
+	return SELF;
 }
 
 // negative
-inline Vec4 Vec4::operator -() const
+inline Vec4 Vec4::operator-() const
 {
-	return Vec4(-x, -y, -z, -w);
+	return Vec4(-x(), -y(), -z(), -w());
 }
 
 // ==
-inline bool Vec4::operator ==(const Vec4& b) const
+inline bool Vec4::operator==(const Vec4& b) const
 {
-	return (isZero(x-b.x) && isZero(y-b.y) && isZero(z-b.z) && isZero(w-b.w)) ? true : false;
+	return isZero(x() - b.x()) && isZero(y() - b.y()) && isZero(z() - b.z()) && isZero(w() - b.w());
 }
 
 // !=
-inline bool Vec4::operator !=(const Vec4& b) const
+inline bool Vec4::operator!=(const Vec4& b) const
 {
-	return (isZero(x-b.x) && isZero(y-b.y) && isZero(z-b.z) && isZero(w-b.w)) ? false : true;
+	return isZero(x() - b.x()) && isZero(y() - b.y()) && isZero(z() - b.z()) && isZero(w() - b.w());
 }
 
 // vec4 + float
-inline Vec4 Vec4::operator +(float f) const
+inline Vec4 Vec4::operator+(float f) const
 {
-	return ME + Vec4(f);
+	return SELF + Vec4(f);
 }
 
 // float + vec4
-inline Vec4 operator +(float f, const Vec4& v4)
+inline Vec4 operator+(float f, const Vec4& v4)
 {
-	return v4+f;
+	return v4 + f;
 }
 
 // vec4 += float
-inline Vec4& Vec4::operator +=(float f)
+inline Vec4& Vec4::operator+=(float f)
 {
-	ME += Vec4(f);
-	return ME;
+	SELF += Vec4(f);
+	return SELF;
 }
 
 // vec4 - float
-inline Vec4 Vec4::operator -(float f) const
+inline Vec4 Vec4::operator-(float f) const
 {
-	return ME - Vec4(f);
+	return SELF - Vec4(f);
 }
 
 // float - vec4
-inline Vec4 operator -(float f, const Vec4& v4)
+inline Vec4 operator-(float f, const Vec4& v4)
 {
-	return Vec4(f-v4.x, f-v4.y, f-v4.z, f-v4.w);
+	return Vec4(f - v4.x(), f - v4.y(), f - v4.z(), f -v4.w());
 }
 
 // vec4 -= float
-inline Vec4& Vec4::operator -=(float f)
+inline Vec4& Vec4::operator-=(float f)
 {
-	ME -= Vec4(f);
-	return ME;
+	SELF -= Vec4(f);
+	return SELF;
 }
 
 // vec4 * float
-inline Vec4 Vec4::operator *(float f) const
+inline Vec4 Vec4::operator*(float f) const
 {
-	return ME * Vec4(f);
+	return SELF * Vec4(f);
 }
 
 // float * vec4
-inline Vec4 operator *(float f, const Vec4& v4)
+inline Vec4 operator*(float f, const Vec4& v4)
 {
-	return v4*f;
+	return v4 * f;
 }
 
 // vec4 *= float
-inline Vec4& Vec4::operator *=(float f)
+inline Vec4& Vec4::operator*=(float f)
 {
-	ME *= Vec4(f);
-	return ME;
+	SELF *= Vec4(f);
+	return SELF;
 }
 
 // vec4 / float
-inline Vec4 Vec4::operator /(float f) const
+inline Vec4 Vec4::operator/(float f) const
 {
-	return ME / Vec4(f);
+	return SELF / Vec4(f);
 }
 
 // float / vec4
-inline Vec4 operator /(float f, const Vec4& v4)
+inline Vec4 operator/(float f, const Vec4& v4)
 {
-	return Vec4(f/v4.x, f/v4.y, f/v4.z, f/v4.w);
+	return Vec4(f / v4.x(), f / v4.y(), f / v4.z(), f / v4.w());
 }
 
 // vec4 /= float
-inline Vec4& Vec4::operator /=(float f)
+inline Vec4& Vec4::operator/=(float f)
 {
-	ME /= Vec4(f);
-	return ME;
+	SELF /= Vec4(f);
+	return SELF;
 }
 
 // vec4 * mat4
-inline Vec4 Vec4::operator *(const Mat4& m4) const
+inline Vec4 Vec4::operator*(const Mat4& m4) const
 {
 	return Vec4(
-		x*m4(0, 0) + y*m4(1, 0) + z*m4(2, 0) + w*m4(3, 0),
-		x*m4(0, 1) + y*m4(1, 1) + z*m4(2, 1) + w*m4(3, 1),
-		x*m4(0, 2) + y*m4(1, 2) + z*m4(2, 2) + w*m4(3, 2),
-		x*m4(0, 3) + y*m4(1, 3) + z*m4(2, 3) + w*m4(3, 3)
+		x() * m4(0, 0) + y() * m4(1, 0) + z() * m4(2, 0) + w() * m4(3, 0),
+		x() * m4(0, 1) + y() * m4(1, 1) + z() * m4(2, 1) + w() * m4(3, 1),
+		x() * m4(0, 2) + y() * m4(1, 2) + z() * m4(2, 2) + w() * m4(3, 2),
+		x() * m4(0, 3) + y() * m4(1, 3) + z() * m4(2, 3) + w() * m4(3, 3)
 	);
 }
 
 // dot
 inline float Vec4::dot(const Vec4& b) const
 {
-	return x*b.x + y*b.y + z*b.z + w*b.w;
+	return x() * b.x() + y() * b.y() + z() * b.z() + w() * b.w();
 }
 
 // getLength
 inline float Vec4::getLength() const
 {
-	return M::sqrt(x*x + y*y + z*z + w*w);
+	return M::sqrt(x() * x() + y() * y() + z() * z() + w() * w());
 }
 
 // Normalized
 inline Vec4 Vec4::getNormalized() const
 {
-	return ME * invSqrt(x*x +y*y + z*z + w*w);
+	return SELF * invSqrt(x() * x() + y() * y() + z() * z() + w() * w());
 }
 
 // normalize
 inline void Vec4::normalize()
 {
-	ME *= invSqrt(x*x +y*y + z*z + w*w);
+	SELF *= invSqrt(x() * x() + y() * y() + z() * z() + w() * w());
 }
 
 // print
 inline std::ostream& operator<<(std::ostream& s, const Vec4& v)
 {
-	s << v.x << ' ' << v.y << ' ' << v.z << ' ' << v.w;
+	s << v.x() << ' ' << v.y() << ' ' << v.z() << ' ' << v.w();
 	return s;
 }
 

src/Physics/BtAndAnkiConvertors.h

@@ -50,7 +50,7 @@ inline btVector3 toBt(const Vec3& v)
 
 inline btVector4 toBt(const Vec4& v)
 {
-	return btVector4(v.x,  v.y, v.z, v.w);
+	return btVector4(v.x(), v.y(), v.z(), v.w());
 }
 
 

src/Renderer/Renderer.cpp

@@ -375,13 +375,13 @@ Vec3 Renderer::unproject(const Vec3& windowCoords, const Mat4& modelViewMat, con
 
 	// the vec is in NDC space meaning: -1<=vec.x<=1 -1<=vec.y<=1 -1<=vec.z<=1
 	Vec4 vec;
-	vec.x = (2.0 * (windowCoords.x - view[0])) / view[2] - 1.0;
-	vec.y = (2.0 * (windowCoords.y - view[1])) / view[3] - 1.0;
-	vec.z = 2.0 * windowCoords.z - 1.0;
-	vec.w = 1.0;
+	vec.x() = (2.0 * (windowCoords.x - view[0])) / view[2] - 1.0;
+	vec.y() = (2.0 * (windowCoords.y - view[1])) / view[3] - 1.0;
+	vec.z() = 2.0 * windowCoords.z - 1.0;
+	vec.w() = 1.0;
 
 	Vec4 final = invPm * vec;
-	final /= final.w;
+	final /= final.w();
 	return Vec3(final);
 }
 

src/Resources/Core/ResourceManager.cpp

@@ -23,9 +23,9 @@
 	} \
 	\
 	template<> \
-	void ResourceManager::unload<type__>(const Types<type__>::Info& info) \
+	void ResourceManager::unload<type__>(const Types<type__>::Hook& hook) \
 	{ \
-		unloadR<type__>(info); \
+		unloadR<type__>(hook); \
 	}
 
 

src/Resources/Core/ResourceManager.h

@@ -38,8 +38,8 @@ class ResourceManager
 		template<typename Type>
 		struct Types
 		{
-			typedef RsrcHook<Type> Info;
-			typedef std::list<Info> Container;
+			typedef RsrcHook<Type> Hook;
+			typedef std::list<Hook> Container;
 			typedef typename Container::iterator Iterator;
 			typedef typename Container::const_iterator ConstIterator;
 		};
@@ -48,14 +48,14 @@ class ResourceManager
 		/// See if its already loaded, if its not:
 		/// - Create a instance
 		/// - Call load method of the instance
-		/// If it loaded:
+		/// If its loaded:
 		/// - Increase the resource counter
 		template<typename Type>
-		typename Types<Type>::Info& load(const char* filename);
+		typename Types<Type>::Hook& load(const char* filename);
 
 		/// Unload a resource if no one uses it
 		template<typename Type>
-		void unload(const typename Types<Type>::Info& info);
+		void unload(const typename Types<Type>::Hook& info);
 
 	private:
 		/// Find a resource using the filename
@@ -72,7 +72,7 @@ class ResourceManager
 
 		/// Unload a resource if no one uses it. This is the real deal
 		template<typename Type>
-		void unloadR(const typename Types<Type>::Info& info);
+		void unloadR(const typename Types<Type>::Hook& info);
 
 		/// @name Containers
 		/// @{

src/Resources/Core/ResourceManager.inl.h

@@ -6,7 +6,7 @@
 // loadRsrc                                                                                                            =
 //======================================================================================================================
 template<typename Type>
-typename ResourceManager::Types<Type>::Info& ResourceManager::load(const char* filename)
+typename ResourceManager::Types<Type>::Hook& ResourceManager::load(const char* filename)
 {
 	// Chose container
 	typename Types<Type>::Container& c = choseContainer<Type>();
@@ -38,7 +38,7 @@ typename ResourceManager::Types<Type>::Info& ResourceManager::load(const char* f
 			//throw EXCEPTION("Cannot load resource: " + e.what());
 		}
 
-		c.push_back(typename Types<Type>::Info());
+		c.push_back(typename Types<Type>::Hook());
 		it = c.end();
 		--it;
 
@@ -55,22 +55,22 @@ typename ResourceManager::Types<Type>::Info& ResourceManager::load(const char* f
 // unload                                                                                                              =
 //======================================================================================================================
 template<typename Type>
-void ResourceManager::unloadR(const typename Types<Type>::Info& info)
+void ResourceManager::unloadR(const typename Types<Type>::Hook& hook)
 {
 	// Chose container
 	typename Types<Type>::Container& c = choseContainer<Type>();
 
 	// Find
-	typename Types<Type>::Iterator it = find<Type>(info.resource, c);
+	typename Types<Type>::Iterator it = find<Type>(hook.resource, c);
 
 	// If not found
 	if(it == c.end())
 	{
-		throw EXCEPTION("Resource hook incorrect (\"" + info.uuid + "\")");
+		throw EXCEPTION("Resource hook incorrect (\"" + hook.uuid + "\")");
 	}
 
-	RASSERT_THROW_EXCEPTION(it->uuid != info.uuid);
-	RASSERT_THROW_EXCEPTION(it->referenceCounter != info.referenceCounter);
+	RASSERT_THROW_EXCEPTION(it->uuid != hook.uuid);
+	RASSERT_THROW_EXCEPTION(it->referenceCounter != hook.referenceCounter);
 
 	--it->referenceCounter;
 

src/Resources/Texture.h

@@ -72,7 +72,7 @@ class Texture
 		static int  anisotropyLevel;
 		/// @}
 
-				void setTexParameter(uint paramName, int value) const;
+		void setTexParameter(uint paramName, int value) const;
 		void setTexParameter(uint paramName, float value) const;
 
 		bool isLoaded() const;

src/Scripting/Math/Vec4.bpi.cpp

@@ -5,10 +5,11 @@
 WRAP(Vec4)
 {
 	class_<Vec4>("Vec4")
-		.def_readwrite("x", &Vec4::x)
+		/// @todo Correct this
+		/*.def_readwrite("x", &Vec4::x)
 		.def_readwrite("y", &Vec4::y)
 		.def_readwrite("z", &Vec4::z)
-		.def_readwrite("w", &Vec4::w)
+		.def_readwrite("w", &Vec4::w)*/
 		// constructors
 		.def(init<>())
 		.def(init<float>())

unit-tests/Main.cpp

@@ -7,8 +7,7 @@
 int main(int argc, char** argv)
 {
 	// Init app
-	new App(0, NULL);
-	app->initWindow();
+	AppSingleton::getInstance().init(argc, argv);
 
 	// Init mainRenderer
 	RendererInitializer initializer;
@@ -21,13 +20,13 @@ int main(int argc, char** argv)
 	initializer.pps.hdr.enabled = true;
 	initializer.pps.hdr.renderingQuality = 0.25;
 	initializer.pps.hdr.blurringDist = 1.0;
-	initializer.pps.hdr.blurringIterations = 2;
+	initializer.pps.hdr.blurringIterationsNum = 2;
 	initializer.pps.hdr.exposure = 4.0;
-	initializer.pps.ssao.blurringIterations = 2;
+	initializer.pps.ssao.blurringIterationsNum = 2;
 	initializer.pps.ssao.enabled = true;
 	initializer.pps.ssao.renderingQuality = 0.5;
 	initializer.mainRendererQuality = 1.0;
-	app->getMainRenderer().init(initializer);
+	MainRendererSingleton::getInstance().init(initializer);
 
 	// Tests
 	::testing::InitGoogleTest(&argc, argv);

unit-tests/Resources/Material.ut.cpp

@@ -15,7 +15,6 @@ TEST(MaterialTests, Test)
 	{
 		RsrcPtr<Material> mtl;
 		EXPECT_NO_THROW(mtl.loadRsrc("unit-tests/data/custom_sprog_skinning.mtl"));
-		EXPECT_EQ(mtl->hasHwSkinning(), true);
 		EXPECT_EQ(mtl->getBlendingSfactor(), GL_ONE);
 		EXPECT_EQ(mtl->getBlendingDfactor(), GL_SRC_ALPHA);
 		EXPECT_EQ(mtl->isBlendingEnabled(), true);