- Math optimizations

- Python interfaces

src/Math/Axisang.inl.h

@@ -48,34 +48,34 @@ inline Axisang::Axisang(const Mat3& m3)
 		}
 
 		ang = PI;
-		axis.x = (m3(0, 0)+1)/2;
-		if(axis.x > 0.0)
-			axis.x = M::sqrt(axis.x);
+		axis.x() = (m3(0, 0)+1)/2;
+		if(axis.x() > 0.0)
+			axis.x() = M::sqrt(axis.x());
 		else
-			axis.x = 0;
-		axis.y = (m3(1, 1)+1)/2;
-		if(axis.y > 0)
-			axis.y = M::sqrt(axis.y);
+			axis.x() = 0;
+		axis.y() = (m3(1, 1)+1)/2;
+		if(axis.y() > 0)
+			axis.y() = M::sqrt(axis.y());
 		else
-			axis.y = 0;
-		axis.z = (m3(2, 2)+1)/2;
-		if(axis.z > 0)
-			axis.z = M::sqrt(axis.z);
+			axis.y() = 0;
+		axis.z() = (m3(2, 2)+1)/2;
+		if(axis.z() > 0)
+			axis.z() = M::sqrt(axis.z());
 		else
-			axis.z = 0.0;
+			axis.z() = 0.0;
 
-		bool xZero = (fabs(axis.x)<EPSILON);
-		bool yZero = (fabs(axis.y)<EPSILON);
-		bool zZero = (fabs(axis.z)<EPSILON);
+		bool xZero = (fabs(axis.x())<EPSILON);
+		bool yZero = (fabs(axis.y())<EPSILON);
+		bool zZero = (fabs(axis.z())<EPSILON);
 		bool xyPositive = (m3(0, 1) > 0);
 		bool xzPositive = (m3(0, 2) > 0);
 		bool yzPositive = (m3(1, 2) > 0);
 		if(xZero && !yZero && !zZero){
-			if(!yzPositive) axis.y = -axis.y;
+			if(!yzPositive) axis.y() = -axis.y();
 		}else if(yZero && !zZero){
-			if(!xzPositive) axis.z = -axis.z;
+			if(!xzPositive) axis.z() = -axis.z();
 		}else if (zZero){
-			if(!xyPositive) axis.x = -axis.x;
+			if(!xyPositive) axis.x() = -axis.x();
 		}
 
 		return;
@@ -86,9 +86,9 @@ inline Axisang::Axisang(const Mat3& m3)
 	if(fabs(s) < 0.001) s = 1;
 
 	ang = acos((m3(0, 0) + m3(1, 1) + m3(2, 2) - 1)/2);
-	axis.x= (m3(2, 1) - m3(1, 2))/s;
-	axis.y= (m3(0, 2) - m3(2, 0))/s;
-	axis.z= (m3(1, 0) - m3(0, 1))/s;
+	axis.x() = (m3(2, 1) - m3(1, 2))/s;
+	axis.y() = (m3(0, 2) - m3(2, 0))/s;
+	axis.z() = (m3(1, 0) - m3(0, 1))/s;
 }
 
 

src/Math/Mat3.inl.h

@@ -117,19 +117,19 @@ inline Mat3::Mat3(const Axisang& axisang)
 	float t = 1.0 - c;
 
 	const Vec3& axis = axisang.axis;
-	ME(0, 0) = c + axis.x*axis.x*t;
-	ME(1, 1) = c + axis.y*axis.y*t;
-	ME(2, 2) = c + axis.z*axis.z*t;
+	ME(0, 0) = c + axis.x() * axis.x() * t;
+	ME(1, 1) = c + axis.y() * axis.y() * t;
+	ME(2, 2) = c + axis.z() * axis.z() * t;
 
-	float tmp1 = axis.x*axis.y*t;
-	float tmp2 = axis.z*s;
+	float tmp1 = axis.x() * axis.y() * t;
+	float tmp2 = axis.z() * s;
 	ME(1, 0) = tmp1 + tmp2;
 	ME(0, 1) = tmp1 - tmp2;
-	tmp1 = axis.x*axis.z*t;
-	tmp2 = axis.y*s;
+	tmp1 = axis.x() * axis.z() * t;
+	tmp2 = axis.y() * s;
 	ME(2, 0) = tmp1 - tmp2;
-	ME(0, 2) = tmp1 + tmp2;    tmp1 = axis.y*axis.z*t;
-	tmp2 = axis.x*s;
+	ME(0, 2) = tmp1 + tmp2;    tmp1 = axis.y() * axis.z() * t;
+	tmp2 = axis.x() * s;
 	ME(2, 1) = tmp1 + tmp2;
 	ME(1, 2) = tmp1 - tmp2;
 }
@@ -303,9 +303,9 @@ inline Mat3& Mat3::operator /=(float f)
 inline Vec3 Mat3::operator *(const Vec3& b) const
 {
 	return Vec3(
-		ME(0, 0)*b.x + ME(0, 1)*b.y + ME(0, 2)*b.z,
-		ME(1, 0)*b.x + ME(1, 1)*b.y + ME(1, 2)*b.z,
-		ME(2, 0)*b.x + ME(2, 1)*b.y + ME(2, 2)*b.z
+		ME(0, 0) * b.x() + ME(0, 1) * b.y() + ME(0, 2) * b.z(),
+		ME(1, 0) * b.x() + ME(1, 1) * b.y() + ME(1, 2) * b.z(),
+		ME(2, 0) * b.x() + ME(2, 1) * b.y() + ME(2, 2) * b.z()
 	);
 }
 
@@ -328,65 +328,65 @@ inline bool Mat3::operator !=(const Mat3& b) const
 // setRows
 inline void Mat3::setRows(const Vec3& a, const Vec3& b, const Vec3& c)
 {
-	ME(0, 0) = a.x;
-	ME(0, 1) = a.y;
-	ME(0, 2) = a.z;
-	ME(1, 0) = b.x;
-	ME(1, 1) = b.y;
-	ME(1, 2) = b.z;
-	ME(2, 0) = c.x;
-	ME(2, 1) = c.y;
-	ME(2, 2) = c.z;
+	ME(0, 0) = a.x();
+	ME(0, 1) = a.y();
+	ME(0, 2) = a.z();
+	ME(1, 0) = b.x();
+	ME(1, 1) = b.y();
+	ME(1, 2) = b.z();
+	ME(2, 0) = c.x();
+	ME(2, 1) = c.y();
+	ME(2, 2) = c.z();
 }
 
 // setColumns
 inline void Mat3::setColumns(const Vec3& a, const Vec3& b, const Vec3& c)
 {
-	ME(0, 0) = a.x;
-	ME(1, 0) = a.y;
-	ME(2, 0) = a.z;
-	ME(0, 1) = b.x;
-	ME(1, 1) = b.y;
-	ME(2, 1) = b.z;
-	ME(0, 2) = c.x;
-	ME(1, 2) = c.y;
-	ME(2, 2) = c.z;
+	ME(0, 0) = a.x();
+	ME(1, 0) = a.y();
+	ME(2, 0) = a.z();
+	ME(0, 1) = b.x();
+	ME(1, 1) = b.y();
+	ME(2, 1) = b.z();
+	ME(0, 2) = c.x();
+	ME(1, 2) = c.y();
+	ME(2, 2) = c.z();
 }
 
 // getRows
 inline void Mat3::getRows(Vec3& a, Vec3& b, Vec3& c) const
 {
-	a.x = ME(0, 0);
-	a.y = ME(0, 1);
-	a.z = ME(0, 2);
-	b.x = ME(1, 0);
-	b.y = ME(1, 1);
-	b.z = ME(1, 2);
-	c.x = ME(2, 0);
-	c.y = ME(2, 1);
-	c.z = ME(2, 2);
+	a.x() = ME(0, 0);
+	a.y() = ME(0, 1);
+	a.z() = ME(0, 2);
+	b.x() = ME(1, 0);
+	b.y() = ME(1, 1);
+	b.z() = ME(1, 2);
+	c.x() = ME(2, 0);
+	c.y() = ME(2, 1);
+	c.z() = ME(2, 2);
 }
 
 // getColumns
 inline void Mat3::getColumns(Vec3& a, Vec3& b, Vec3& c) const
 {
-	a.x = ME(0, 0);
-	a.y = ME(1, 0);
-	a.z = ME(2, 0);
-	b.x = ME(0, 1);
-	b.y = ME(1, 1);
-	b.z = ME(2, 1);
-	c.x = ME(0, 2);
-	c.y = ME(1, 2);
-	c.z = ME(2, 2);
+	a.x() = ME(0, 0);
+	a.y() = ME(1, 0);
+	a.z() = ME(2, 0);
+	b.x() = ME(0, 1);
+	b.y() = ME(1, 1);
+	b.z() = ME(2, 1);
+	c.x() = ME(0, 2);
+	c.y() = ME(1, 2);
+	c.z() = ME(2, 2);
 }
 
 // setRow
 inline void Mat3::setRow(const uint i, const Vec3& v)
 {
-	ME(i, 0)=v.x;
-	ME(i, 1)=v.y;
-	ME(i, 2)=v.z;
+	ME(i, 0) = v.x();
+	ME(i, 1) = v.y();
+	ME(i, 2) = v.z();
 }
 
 // getRow
@@ -398,9 +398,9 @@ inline Vec3 Mat3::getRow(const uint i) const
 // setColumn
 inline void Mat3::setColumn(const uint i, const Vec3& v)
 {
-	ME(0,i) = v.x;
-	ME(1,i) = v.y;
-	ME(2,i) = v.z;
+	ME(0, i) = v.x();
+	ME(1, i) = v.y();
+	ME(2, i) = v.z();
 }
 
 // getColumn

src/Math/Mat4.inl.h

@@ -85,15 +85,15 @@ inline Mat4::Mat4(const Vec3& 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;
@@ -497,9 +497,9 @@ inline void Mat4::setTranslationPart(const Vec4& v)
 // setTranslationPart
 inline void Mat4::setTranslationPart(const Vec3& v)
 {
-	ME(0, 3) = v.x;
-	ME(1, 3) = v.y;
-	ME(2, 3) = v.z;
+	ME(0, 3) = v.x();
+	ME(1, 3) = v.y();
+	ME(2, 3) = v.z();
 }
 
 // getTranslationPart

src/Math/Quat.inl.h

@@ -28,7 +28,7 @@ inline Quat::Quat(const Vec2& v2, float z_, float w_):
 
 // constructor [vec3, float]
 inline Quat::Quat(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]
@@ -119,9 +119,9 @@ inline Quat::Quat(const Axisang& axisang)
 
 	float scalefactor = sintheta / sqrt(lengthsq);
 
-	x = scalefactor * axisang.axis.x;
-	y = scalefactor * axisang.axis.y;
-	z = scalefactor * axisang.axis.z;
+	x = scalefactor * axisang.axis.x();
+	y = scalefactor * axisang.axis.y();
+	z = scalefactor * axisang.axis.z();
 	w = costheta;
 }
 
@@ -209,16 +209,20 @@ inline void Quat::invert()
 inline void Quat::setFrom2Vec3(const Vec3& from, const Vec3& to)
 {
 	Vec3 axis(from.cross(to));
-	ME = Quat(axis.x, axis.y, axis.z, from.dot(to));
+	ME = Quat(axis.x(), axis.y(), axis.z(), from.dot(to));
 	normalize();
 	w += 1.0;
 
 	if(w <= EPSILON)
 	{
-		if(from.z*from.z > from.x*from.x)
-			ME = Quat(0.0, from.z, -from.y, 0.0);
+		if(from.z() * from.z() > from.x() * from.x())
+		{
+			ME = Quat(0.0, from.z(), -from.y(), 0.0);
+		}
 		else
-			ME = Quat(from.y, -from.x, 0.0, 0.0);
+		{
+			ME = Quat(from.y(), -from.x(), 0.0, 0.0);
+		}
 	}
 	normalize();
 }

src/Math/Vec2.inl.h

@@ -75,8 +75,8 @@ inline Vec2::Vec2(const Vec2& b)
 // constructor [vec3]
 inline Vec2::Vec2(const Vec3& v3)
 {
-	x() = v3.x;
-	y() = v3.y;
+	x() = v3.x();
+	y() = v3.y();
 }
 
 // constructor [vec4]

src/Math/Vec3.h

@@ -11,29 +11,30 @@ namespace M {
 class Vec3
 {
 	public:
-		/// @name Data members
-		/// @{
-		float x, y, z;
-		/// @}
-
-		/// @name Accessors
-		/// @{
-		float& operator[](uint i);
-		float operator[](uint i) const;
-		/// @}
-
 		/// @name Constructors & distructors
 		/// @{
 		explicit Vec3();
+		explicit Vec3(float x, float y, float z);
 		explicit Vec3(float f);
 		explicit Vec3(float arr[]);
-		explicit Vec3(float x, float y, float z);
 		explicit Vec3(const Vec2& v2, float z);
 		         Vec3(const Vec3& b);
 		explicit Vec3(const Vec4& v4);
 		explicit Vec3(const Quat& q);
 		/// @}
 
+		/// @name Accessors
+		/// @{
+		float& x();
+		float x() const;
+		float& y();
+		float y() const;
+		float& z();
+		float z() const;
+		float& operator[](uint i);
+		float operator[](uint i) const;
+		/// @}
+
 		/// @name Operators with same type
 		/// @{
 		Vec3 operator+(const Vec3& b) const;
@@ -63,27 +64,27 @@ class Vec3
 
 		/// @name Operators with other types
 		/// @{
-		Vec3 operator* (const Mat3& m3) const;
+		Vec3 operator*(const Mat3& m3) const;
 		/// @}
 
-		/// @name Other
+		/// @name Misc methods
 		/// @{
 		float dot(const Vec3& b) const;
 		Vec3 cross(const Vec3& b) const;
 		float getLength() const;
 		float getLengthSquared() const;
 		float getDistanceSquared(const Vec3& b) const;
-		void  normalize();
+		void normalize();
 		Vec3 getNormalized() const;
 		Vec3 getProjection(const Vec3& toThis) const;
 		/// Returns q * this * q.Conjucated() aka returns a rotated this. 18 muls, 12 adds
 		Vec3 getRotated(const Quat& q) const;
-		void  rotate(const Quat& q);
+		void rotate(const Quat& q);
 		Vec3 lerp(const Vec3& v1, float t) const; ///< Return lerp(this, v1, t)
 		/// @}
 
 		/// @name Transformations
-		/// The faster way is by far the mat4 * vec3 or the getTransformed(Vec3, Mat3)
+		/// The faster way is by far the Mat4 * Vec3 or the getTransformed(Vec3, Mat3)
 		/**@{*/
 		Vec3 getTransformed(const Vec3& translate, const Mat3& rotate, float scale) const;
 		void transform(const Vec3& translate, const Mat3& rotate, float scale);
@@ -98,6 +99,20 @@ class Vec3
 		Vec3 getTransformed(const Transform& transform) const;
 		void transform(const Transform& transform);
 		/**@}*/
+
+	private:
+		/// @name Data
+		/// @{
+		union
+		{
+			struct
+			{
+				float x, y, z;
+			} vec;
+
+			boost::array<float, 3> arr;
+		};
+		/// @}
 };
 
 

src/Math/Vec3.inl.h

@@ -1,272 +1,341 @@
 #include "MathCommon.inl.h"
 
 
-#define ME (*this)
+#define SELF (*this)
 
 
 namespace M {
 
 
-// accessors
-inline float& Vec3::operator [](uint i)
-{
-	return (&x)[i];
-}
+//======================================================================================================================
+// Constructors                                                                                                        =
+//======================================================================================================================
 
-inline float Vec3::operator [](uint i) const
+// Default
+inline Vec3::Vec3()
 {
-	return (&x)[i];
+	arr[0] = arr[1] = arr[2] = 0.0;
 }
 
-// constructor []
-inline Vec3::Vec3()
-	: x(0.0), y(0.0), z(0.0)
-{}
-
-// constructor [float, float, float]
+// float, float, float
 inline Vec3::Vec3(float x_, float y_, float z_)
-	: x(x_), y(y_), z(z_)
-{}
+{
+	x() = x_;
+	y() = y_;
+	z() = z_;
+}
 
-// constructor [float]
+// float
 inline Vec3::Vec3(float f)
-	: x(f), y(f), z(f)
-{}
+{
+	arr[0] = arr[1] = arr[2] = f;
+}
 
-// constructor [float[]]
-inline Vec3::Vec3(float arr[])
+// float[]
+inline Vec3::Vec3(float arr_[])
 {
-	x = arr[0];
-	y = arr[1];
-	z = arr[2];
+	arr[0] = arr_[0];
+	arr[1] = arr_[1];
+	arr[2] = arr_[2];
 }
 
-// constructor [Vec3]
+// Copy
 inline Vec3::Vec3(const Vec3& b)
-	: x(b.x), y(b.y), z(b.z)
-{}
+{
+	arr[0] = b.arr[0];
+	arr[1] = b.arr[1];
+	arr[2] = b.arr[2];
+}
 
-// constructor [vec2, float]
+// Vec2, float
 inline Vec3::Vec3(const Vec2& v2, float z_)
-	: x(v2.x()), y(v2.y()), z(z_)
-{}
+{
+	x() = v2.x();
+	y() = v2.y();
+	z() = z_;
+}
 
-// constructor [vec4]
+// Vec4
 inline Vec3::Vec3(const Vec4& v4)
-	: x(v4.x()), y(v4.y()), z(v4.z())
-{}
+{
+	arr[0] = v4[0];
+	arr[1] = v4[1];
+	arr[2] = v4[2];
+}
 
-// constructor [quat]
+// Quat
 inline Vec3::Vec3(const Quat& q)
-	: x(q.x), y(q.y), z(q.z)
-{}
+{
+	x() = q.x;
+	y() = q.y;
+	z() = q.z;
+}
+
+//======================================================================================================================
+// Accessors                                                                                                                    =
+//======================================================================================================================
+
+inline float& Vec3::x()
+{
+	return vec.x;
+}
+
+inline float Vec3::x() const
+{
+	return vec.x;
+}
+
+inline float& Vec3::y()
+{
+	return vec.y;
+}
+
+inline float Vec3::y() const
+{
+	return vec.y;
+}
+
+inline float& Vec3::z()
+{
+	return vec.z;
+}
+
+inline float Vec3::z() const
+{
+	return vec.z;
+}
+
+inline float& Vec3::operator[](uint i)
+{
+	return arr[i];
+}
+
+inline float Vec3::operator[](uint i) const
+{
+	return arr[i];
+}
+
+
+//======================================================================================================================
+// Operators with same type                                                                                            =
+//======================================================================================================================
 
 // +
-inline Vec3 Vec3::operator +(const Vec3& b) const
+inline Vec3 Vec3::operator+(const Vec3& b) const
 {
-	return Vec3(x+b.x, y+b.y, z+b.z);
+	return Vec3(x() + b.x(), y() + b.y(), z() + b.z());
 }
 
 // +=
-inline Vec3& Vec3::operator +=(const Vec3& b)
+inline Vec3& Vec3::operator+=(const Vec3& b)
 {
-	x += b.x;
-	y += b.y;
-	z += b.z;
-	return ME;
+	x() += b.x();
+	y() += b.y();
+	z() += b.z();
+	return SELF;
 }
 
 // -
-inline Vec3 Vec3::operator -(const Vec3& b) const
+inline Vec3 Vec3::operator-(const Vec3& b) const
 {
-	return Vec3(x-b.x, y-b.y, z-b.z);
+	return Vec3(x() - b.x(), y() - b.y(), z() - b.z());
 }
 
 // -=
-inline Vec3& Vec3::operator -=(const Vec3& b)
+inline Vec3& Vec3::operator-=(const Vec3& b)
 {
-	x -= b.x;
-	y -= b.y;
-	z -= b.z;
-	return ME;
+	x() -= b.x();
+	y() -= b.y();
+	z() -= b.z();
+	return SELF;
 }
 
 // *
-inline Vec3 Vec3::operator *(const Vec3& b) const
+inline Vec3 Vec3::operator*(const Vec3& b) const
 {
-	return Vec3(x*b.x, y*b.y, z*b.z);
+	return Vec3(x() * b.x(), y() * b.y(), z() * b.z());
 }
 
 // *=
-inline Vec3& Vec3::operator *=(const Vec3& b)
+inline Vec3& Vec3::operator*=(const Vec3& b)
 {
-	x *= b.x;
-	y *= b.y;
-	z *= b.z;
-	return ME;
+	x() *= b.x();
+	y() *= b.y();
+	z() *= b.z();
+	return SELF;
 }
 
 // /
-inline Vec3 Vec3::operator /(const Vec3& b) const
+inline Vec3 Vec3::operator/(const Vec3& b) const
 {
-	return Vec3(x/b.x, y/b.y, z/b.z);
+	return Vec3(x() / b.x(), y() / b.y(), z() / b.z());
 }
 
 // /=
-inline Vec3& Vec3::operator /=(const Vec3& b)
+inline Vec3& Vec3::operator/=(const Vec3& b)
 {
-	x /= b.x;
-	y /= b.y;
-	z /= b.z;
-	return ME;
+	x() /= b.x();
+	y() /= b.y();
+	z() /= b.z();
+	return SELF;
 }
 
 // negative
-inline Vec3 Vec3::operator -() const
+inline Vec3 Vec3::operator-() const
 {
-	return Vec3(-x, -y, -z);
+	return Vec3(-x(), -y(), -z());
 }
 
 // ==
-inline bool Vec3::operator ==(const Vec3& b) const
+inline bool Vec3::operator==(const Vec3& b) const
 {
-	return (isZero(x-b.x) && isZero(y-b.y) && isZero(z-b.z)) ? true : false;
+	return isZero(x() - b.x()) && isZero(y() - b.y()) && isZero(z() - b.z());
 }
 
 // !=
-inline bool Vec3::operator !=(const Vec3& b) const
+inline bool Vec3::operator!=(const Vec3& b) const
 {
-	return (isZero(x-b.x) && isZero(y-b.y) && isZero(z-b.z)) ? false : true;
+	return !(isZero(x() - b.x()) && isZero(y() - b.y()) && isZero(z() - b.z()));
 }
 
+
+//======================================================================================================================
+// Operators with float                                                                                                =
+//======================================================================================================================
+
 // Vec3 + float
-inline Vec3 Vec3::operator +(float f) const
+inline Vec3 Vec3::operator+(float f) const
 {
-	return ME + Vec3(f);
+	return SELF + Vec3(f);
 }
 
 // float + Vec3
-inline Vec3 operator +(float f, const Vec3& v)
+inline Vec3 operator+(float f, const Vec3& v)
 {
-	return v+f;
+	return v + f;
 }
 
 // Vec3 += float
-inline Vec3& Vec3::operator +=(float f)
+inline Vec3& Vec3::operator+=(float f)
 {
-	ME += Vec3(f);
-	return ME;
+	SELF += Vec3(f);
+	return SELF;
 }
 
 // Vec3 - float
-inline Vec3 Vec3::operator -(float f) const
+inline Vec3 Vec3::operator-(float f) const
 {
-	return ME - Vec3(f);
+	return SELF - Vec3(f);
 }
 
 // float - Vec3
-inline Vec3 operator -(float f, const Vec3& v)
+inline Vec3 operator-(float f, const Vec3& v)
 {
-	return Vec3(f-v.x, f-v.y, f-v.z);
+	return Vec3(f - v.x(), f - v.y(), f - v.z());
 }
 
 // Vec3 -= float
-inline Vec3& Vec3::operator -=(float f)
+inline Vec3& Vec3::operator-=(float f)
 {
-	ME -= Vec3(f);
-	return ME;
+	SELF -= Vec3(f);
+	return SELF;
 }
 
 // Vec3 * float
-inline Vec3 Vec3::operator *(float f) const
+inline Vec3 Vec3::operator*(float f) const
 {
-	return ME * Vec3(f);
+	return SELF * Vec3(f);
 }
 
 // float * Vec3
-inline Vec3 operator *(float f, const Vec3& v)
+inline Vec3 operator*(float f, const Vec3& v)
 {
-	return v*f;
+	return v * f;
 }
 
 // Vec3 *= float
-inline Vec3& Vec3::operator *=(float f)
+inline Vec3& Vec3::operator*=(float f)
 {
-	ME *= Vec3(f);
-	return ME;
+	SELF *= Vec3(f);
+	return SELF;
 }
 
 // Vec3 / float
-inline Vec3 Vec3::operator /(float f) const
+inline Vec3 Vec3::operator/(float f) const
 {
-	return ME / Vec3(f);
+	return SELF / Vec3(f);
 }
 
 // float / Vec3
-inline Vec3 operator /(float f, const Vec3& v)
+inline Vec3 operator/(float f, const Vec3& v)
 {
-	return Vec3(f/v.x, f/v.y, f/v.z);
+	return Vec3(f / v.x(), f / v.y(), f / v.z());
 }
 
 // Vec3 /= float
-inline Vec3& Vec3::operator /=(float f)
+inline Vec3& Vec3::operator/=(float f)
 {
-	ME /= Vec3(f);
-	return ME;
+	SELF /= Vec3(f);
+	return SELF;
 }
 
+
+//======================================================================================================================
+// Misc methods                                                                                                        =
+//======================================================================================================================
+
 // dot
 inline float Vec3::dot(const Vec3& b) const
 {
-	return x*b.x + y*b.y + z*b.z;
+	return x() * b.x() + y() * b.y() + z() * b.z();
 }
 
 // cross prod
 inline Vec3 Vec3::cross(const Vec3& b) const
 {
-	return Vec3(y*b.z-z*b.y, z*b.x-x*b.z, x*b.y-y*b.x);
+	return Vec3(y() * b.z() - z() * b.y(), z() * b.x() - x() * b.z(), x() * b.y() - y() * b.x());
 }
 
 // getLength
 inline float Vec3::getLength() const
 {
-	return M::sqrt(x*x + y*y + z*z);
+	return M::sqrt(getLengthSquared());
 }
 
 // getLengthSquared
 inline float Vec3::getLengthSquared() const
 {
-	return x*x + y*y + z*z;
+	return x() * x() + y() * y() + z() * z();
 }
 
 // getDistanceSquared
 inline float Vec3::getDistanceSquared(const Vec3& b) const
 {
-	return (ME-b).getLengthSquared();
+	return (SELF - b).getLengthSquared();
 }
 
 // normalize
 inline void Vec3::normalize()
 {
-	ME /= getLength();
+	SELF /= getLength();
 }
 
-// Normalized (return the normalized)
+// getNormalized
 inline Vec3 Vec3::getNormalized() const
 {
-	return ME / getLength();
+	return SELF / getLength();
 }
 
 // getProjection
 inline Vec3 Vec3::getProjection(const Vec3& toThis) const
 {
-	return toThis * (ME.dot(toThis)/(toThis.dot(toThis)));
+	return toThis * (SELF.dot(toThis) / (toThis.dot(toThis)));
 }
 
-// Rotated
+// getRotated
 inline Vec3 Vec3::getRotated(const Quat& q) const
 {
-	RASSERT_THROW_EXCEPTION(!isZero(1.0-q.getLength())); // Not normalized quat
+	RASSERT_THROW_EXCEPTION(!isZero(1.0 - q.getLength())); // Not normalized quat
 
 	/*float vmult = 2.0f*(q.x*x + q.y*y + q.z*z);
 	float crossmult = 2.0*q.w;
@@ -276,89 +345,96 @@ inline Vec3 Vec3::getRotated(const Quat& q) const
 							   pmult*y + vmult*q.y + crossmult*(q.z*x - q.x*z),
 	               pmult*z + vmult*q.z + crossmult*(q.x*y - q.y*x));*/
 	Vec3 qXyz(q);
-	return ME + qXyz.cross(qXyz.cross(ME) + ME*q.w) * 2.0;
+	return SELF + qXyz.cross(qXyz.cross(SELF) + SELF * q.w) * 2.0;
 }
 
 // rotate
 inline void Vec3::rotate(const Quat& q)
 {
-	ME = getRotated(q);
+	SELF = getRotated(q);
 }
 
 // lerp
 inline Vec3 Vec3::lerp(const Vec3& v1, float t) const
 {
-	return (ME*(1.0f-t))+(v1*t);
+	return (SELF * (1.0 - t)) + (v1 * t);
 }
 
-// getTransformed [mat3]
+
+//======================================================================================================================
+// Transformations                                                                                                     =
+//======================================================================================================================
+
+// Mat3
 inline Vec3 Vec3::getTransformed(const Vec3& translate, const Mat3& rotate, float scale) const
 {
-	return (rotate * (ME * scale)) + translate;
+	return (rotate * (SELF * scale)) + translate;
 }
 
-// transform [mat3]
+// Mat3
 inline void Vec3::transform(const Vec3& translate, const Mat3& rotate, float scale)
 {
-	ME = getTransformed(translate, rotate, scale);
+	SELF = getTransformed(translate, rotate, scale);
 }
 
-// getTransformed [mat3] no scale
+// Mat3 no scale
 inline Vec3 Vec3::getTransformed(const Vec3& translate, const Mat3& rotate) const
 {
-	return (rotate * ME) + translate;
+	return (rotate * SELF) + translate;
 }
 
-// transform [mat3] no scale
+// Mat3 no scale
 inline void Vec3::transform(const Vec3& translate, const Mat3& rotate)
 {
-	ME = getTransformed(translate, rotate);
+	SELF = getTransformed(translate, rotate);
 }
 
-// getTransformed [quat]
+// Quat
 inline Vec3 Vec3::getTransformed(const Vec3& translate, const Quat& rotate, float scale) const
 {
-	return (ME * scale).getRotated(rotate) + translate;
+	return (SELF * scale).getRotated(rotate) + translate;
 }
 
-// transform [quat3] no scale
+// Quat
 inline void Vec3::transform(const Vec3& translate, const Quat& rotate, float scale)
 {
-	ME = getTransformed(translate, rotate, scale);
+	SELF = getTransformed(translate, rotate, scale);
 }
 
-// getTransformed [mat4]
+// Mat4
 inline Vec3 Vec3::getTransformed(const Mat4& transform) const
 {
 	return Vec3(
-		transform(0, 0)*x + transform(0, 1)*y + transform(0, 2)*z + transform(0, 3),
-		transform(1, 0)*x + transform(1, 1)*y + transform(1, 2)*z + transform(1, 3),
-		transform(2, 0)*x + transform(2, 1)*y + transform(2, 2)*z + transform(2, 3)
+		transform(0, 0) * x() + transform(0, 1) * y() + transform(0, 2) * z() + transform(0, 3),
+		transform(1, 0) * x() + transform(1, 1) * y() + transform(1, 2) * z() + transform(1, 3),
+		transform(2, 0) * x() + transform(2, 1) * y() + transform(2, 2) * z() + transform(2, 3)
 	);
 }
 
-// getTransformed [mat4]
+// Mat4
 inline void Vec3::transform(const Mat4& transform)
 {
-	ME = getTransformed(transform);
+	SELF = getTransformed(transform);
 }
 
-// getTransformed [Transform]
+// Transform
 inline Vec3 Vec3::getTransformed(const Transform& transform) const
 {
-	return (transform.rotation * (ME * transform.scale)) + transform.origin;
+	return (transform.rotation * (SELF * transform.scale)) + transform.origin;
 }
 
-// getTransformed [Transform]
+// Transform
 inline void Vec3::transform(const Transform& transform)
 {
-	ME = getTransformed(transform);
+	SELF = getTransformed(transform);
 }
 
-// print
+//======================================================================================================================
+// Print                                                                                                               =
+//======================================================================================================================
 inline std::ostream& operator<<(std::ostream& s, const Vec3& v)
 {
-	s << v.x << ' ' << v.y << ' ' << v.z;
+	s << v.x() << ' ' << v.y() << ' ' << v.z();
 	return s;
 }
 

src/Math/Vec4.h

@@ -11,6 +11,21 @@ namespace M {
 class Vec4
 {
 	public:
+		/// @name Constructors & distructors
+		/// @{
+		explicit Vec4();
+		explicit Vec4(float x, float y, float z, float w);
+		explicit Vec4(float f);
+		explicit Vec4(float arr[]);
+		explicit Vec4(const Vec2& v2, float z, float w);
+		explicit Vec4(const Vec3& v3, float w);
+		         Vec4(const Vec4& b);
+		explicit Vec4(const Quat& q);
+		#if defined(MATH_INTEL_SIMD)
+			explicit Vec4(const __m128& mm);
+		#endif
+		/// @}
+
 		/// @name Accessors
 		/// @{
 		float& x();
@@ -29,21 +44,6 @@ class Vec4
 		#endif
 		/// @}
 
-		/// @name Constructors & distructors
-		/// @{
-		explicit Vec4();
-		explicit Vec4(float x, float y, float z, float w);
-		explicit Vec4(float f);
-		explicit Vec4(float arr[]);
-		explicit Vec4(const Vec2& v2, float z, float w);
-		explicit Vec4(const Vec3& v3, float w);
-		         Vec4(const Vec4& b);
-		explicit Vec4(const Quat& q);
-		#if defined(MATH_INTEL_SIMD)
-			explicit Vec4(const __m128& mm);
-		#endif
-		/// @}
-
 		/// @name Operators with same
 		/// @{
 		Vec4 operator+(const Vec4& b) const;
@@ -73,10 +73,10 @@ class Vec4
 
 		/// @name Operators with other
 		/// @{
-		Vec4  operator*(const Mat4& m4) const;
+		Vec4 operator*(const Mat4& m4) const;
 		/// @}
 
-		/// @name Other
+		/// @name Misc methods
 		/// @{
 		float getLength() const;
 		Vec4 getNormalized() const;
@@ -104,16 +104,18 @@ class Vec4
 };
 
 
-/// @name Other operators
+/// @name Global operators with Vec4 and float
 /// @{
 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);
 /// @}
 
 
+extern std::ostream& operator<<(std::ostream& s, const Vec4& v);
+
+
 } // end namespace
 
 

src/Math/Vec4.inl.h

@@ -7,90 +7,31 @@
 namespace M {
 
 
-// accessors
-inline float& Vec4::operator[](uint i)
-{
-	return arr[i];
-}
-
-inline float Vec4::operator[](uint i) const
-{
-	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;
-}
+//======================================================================================================================
+// Constructors                                                                                                        =
+//======================================================================================================================
 
-inline float Vec4::w() const
-{
-	return vec.w;
-}
-
-#if defined(MATH_INTEL_SIMD)
-	inline __m128& Vec4::getMm()
-	{
-		return mm;
-	}
-
-	inline const __m128& Vec4::getMm() const
-	{
-		return mm;
-	}
-#endif
-
-// default constructor
+// default
 inline Vec4::Vec4()
 {
 	#if defined(MATH_INTEL_SIMD)
 		mm = _mm_setzero_ps();
 	#else
-		x() = y() = z() = w() = 0.0;
+		arr[0] = arr[1] = arr[2] = arr[3] = 0.0;
 	#endif
 }
 
-// constructor [float]
+// float
 inline Vec4::Vec4(float f)
 {
 	#if defined(MATH_INTEL_SIMD)
 		mm = _mm_set1_ps(f);
 	#else
-		x() = y() = z() = w() = f;
+		arr[0] = arr[1] = arr[2] = arr[3] = f;
 	#endif
 }
 
-// Constructor [float[]]
+// float[]
 inline Vec4::Vec4(float arr_[])
 {
 	#if defined(MATH_INTEL_SIMD)
@@ -103,7 +44,7 @@ inline Vec4::Vec4(float arr_[])
 	#endif
 }
 
-// constructor [float, float, float, float]
+// float, float, float, float
 inline Vec4::Vec4(float x_, float y_, float z_, float w_)
 {
 	#if defined(MATH_INTEL_SIMD)
@@ -116,15 +57,7 @@ inline Vec4::Vec4(float x_, float y_, float z_, float w_)
 	#endif
 }
 
-// constructor [__m128]
-#if defined(MATH_INTEL_SIMD)
-	inline Vec4::Vec4(const __m128& mm_)
-	{
-		mm = mm_;
-	}
-#endif
-
-// constructor [vec2, float, float]
+// vec2, float, float
 inline Vec4::Vec4(const Vec2& v2, float z_, float w_)
 {
 	x() = v2.x();
@@ -133,16 +66,16 @@ inline Vec4::Vec4(const Vec2& v2, float z_, float w_)
 	w() = w_;
 }
 
-// constructor [vec3, float]
+// vec3, float
 inline Vec4::Vec4(const Vec3& v3, float w_)
 {
-	x() = v3.x;
-	y() = v3.y;
-	z() = v3.z;
+	x() = v3.x();
+	y() = v3.y();
+	z() = v3.z();
 	w() = w_;
 }
 
-// constructor [vec4]
+// copy
 inline Vec4::Vec4(const Vec4& b)
 {
 	#if defined(MATH_INTEL_SIMD)
@@ -155,7 +88,7 @@ inline Vec4::Vec4(const Vec4& b)
 	#endif
 }
 
-// constructor [quat]
+// quat
 inline Vec4::Vec4(const Quat& q)
 {
 	x() = q.x;
@@ -164,6 +97,86 @@ inline Vec4::Vec4(const Quat& q)
 	w() = q.w;
 }
 
+// __m128
+#if defined(MATH_INTEL_SIMD)
+	inline Vec4::Vec4(const __m128& mm_)
+	{
+		mm = mm_;
+	}
+#endif
+
+
+//======================================================================================================================
+// Accessors                                                                                                           =
+//======================================================================================================================
+
+inline float& Vec4::operator[](uint i)
+{
+	return arr[i];
+}
+
+inline float Vec4::operator[](uint i) const
+{
+	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;
+}
+
+#if defined(MATH_INTEL_SIMD)
+	inline __m128& Vec4::getMm()
+	{
+		return mm;
+	}
+
+	inline const __m128& Vec4::getMm() const
+	{
+		return mm;
+	}
+#endif
+
+
+//======================================================================================================================
+// Operators with same                                                                                                 =
+//======================================================================================================================
+
 // +
 inline Vec4 Vec4::operator+(const Vec4& b) const
 {
@@ -280,83 +293,93 @@ inline bool Vec4::operator!=(const Vec4& b) const
 	return !(isZero(sub.x()) && isZero(sub.y()) && isZero(sub.z()) && isZero(sub.w()));
 }
 
-// vec4 + float
+
+//======================================================================================================================
+// Operators with float                                                                                                =
+//======================================================================================================================
+
+// Vec4 + float
 inline Vec4 Vec4::operator+(float f) const
 {
 	return SELF + Vec4(f);
 }
 
-// float + vec4
+// float + Vec4
 inline Vec4 operator+(float f, const Vec4& v4)
 {
 	return v4 + f;
 }
 
-// vec4 += float
+// Vec4 += float
 inline Vec4& Vec4::operator+=(float f)
 {
 	SELF += Vec4(f);
 	return SELF;
 }
 
-// vec4 - float
+// Vec4 - float
 inline Vec4 Vec4::operator-(float f) const
 {
 	return SELF - Vec4(f);
 }
 
-// float - vec4
+// float - Vec4
 inline Vec4 operator-(float f, const Vec4& v4)
 {
 	return Vec4(f) - v4;
 }
 
-// vec4 -= float
+// Vec4 -= float
 inline Vec4& Vec4::operator-=(float f)
 {
 	SELF -= Vec4(f);
 	return SELF;
 }
 
-// vec4 * float
+// Vec4 * float
 inline Vec4 Vec4::operator*(float f) const
 {
 	return SELF * Vec4(f);
 }
 
-// float * vec4
+// float * Vec4
 inline Vec4 operator*(float f, const Vec4& v4)
 {
 	return v4 * f;
 }
 
-// vec4 *= float
+// Vec4 *= float
 inline Vec4& Vec4::operator*=(float f)
 {
 	SELF *= Vec4(f);
 	return SELF;
 }
 
-// vec4 / float
+// Vec4 / float
 inline Vec4 Vec4::operator/(float f) const
 {
 	return SELF / Vec4(f);
 }
 
-// float / vec4
+// float / Vec4
 inline Vec4 operator/(float f, const Vec4& v4)
 {
 	return Vec4(f) / v4;
 }
 
-// vec4 /= float
+// Vec4 /= float
 inline Vec4& Vec4::operator/=(float f)
 {
 	SELF /= Vec4(f);
 	return SELF;
 }
 
-// vec4 * mat4
+
+//======================================================================================================================
+// Operators with other                                                                                                =
+//======================================================================================================================
+
+// Vec4 * mat4
 inline Vec4 Vec4::operator*(const Mat4& m4) const
 {
 	return Vec4(
@@ -367,6 +390,11 @@ inline Vec4 Vec4::operator*(const Mat4& m4) const
 	);
 }
 
+
+//======================================================================================================================
+// Misc methods                                                                                                        =
+//======================================================================================================================
+
 // dot
 inline float Vec4::dot(const Vec4& b) const
 {
@@ -385,7 +413,7 @@ inline float Vec4::getLength() const
 	return M::sqrt(dot(SELF));
 }
 
-// Normalized
+// getNormalized
 inline Vec4 Vec4::getNormalized() const
 {
 	return SELF / getLength();
@@ -397,7 +425,10 @@ inline void Vec4::normalize()
 	SELF /= getLength();
 }
 
-// print
+
+//======================================================================================================================
+// Print                                                                                                               =
+//======================================================================================================================
 inline std::ostream& operator<<(std::ostream& s, const Vec4& v)
 {
 	s << v.x() << ' ' << v.y() << ' ' << v.z() << ' ' << v.w();

src/Physics/BtAndAnkiConvertors.h

@@ -44,7 +44,7 @@ inline Transform toAnki(const btTransform& t)
 
 inline btVector3 toBt(const Vec3& v)
 {
-	return btVector3(v.x,  v.y, v.z);
+	return btVector3(v.x(),  v.y(), v.z());
 }
 
 

src/Renderer/Dbg.cpp

@@ -172,14 +172,14 @@ void Dbg::drawCube(float size)
 	Vec3 minPos = Vec3(-0.5 * size);
 
 	Vec3 points[] = {
-		Vec3(maxPos.x, maxPos.y, maxPos.z),  // right top front
-		Vec3(minPos.x, maxPos.y, maxPos.z),  // left top front
-		Vec3(minPos.x, minPos.y, maxPos.z),  // left bottom front
-		Vec3(maxPos.x, minPos.y, maxPos.z),  // right bottom front
-		Vec3(maxPos.x, maxPos.y, minPos.z),  // right top back
-		Vec3(minPos.x, maxPos.y, minPos.z),  // left top back
-		Vec3(minPos.x, minPos.y, minPos.z),  // left bottom back
-		Vec3(maxPos.x, minPos.y, minPos.z)   // right bottom back
+		Vec3(maxPos.x(), maxPos.y(), maxPos.z()),  // right top front
+		Vec3(minPos.x(), maxPos.y(), maxPos.z()),  // left top front
+		Vec3(minPos.x(), minPos.y(), maxPos.z()),  // left bottom front
+		Vec3(maxPos.x(), minPos.y(), maxPos.z()),  // right bottom front
+		Vec3(maxPos.x(), maxPos.y(), minPos.z()),  // right top back
+		Vec3(minPos.x(), maxPos.y(), minPos.z()),  // left top back
+		Vec3(minPos.x(), minPos.y(), minPos.z()),  // left bottom back
+		Vec3(maxPos.x(), minPos.y(), minPos.z())   // right bottom back
 	};
 
 	const uint indeces[] = {0, 1, 2, 3, 4, 0, 3, 7, 1, 5, 6, 2, 5, 4, 7, 6, 0, 4, 5, 1, 3, 2, 6, 7};

src/Renderer/Is.cpp

@@ -51,9 +51,9 @@ void Is::calcViewVectors()
 		*/
 
 		Vec3 vec;
-		vec.x = (2.0 * (pixels[i][0] - viewport[0])) / viewport[2] - 1.0;
-		vec.y = (2.0 * (pixels[i][1] - viewport[1])) / viewport[3] - 1.0;
-		vec.z = 1.0;
+		vec.x() = (2.0 * (pixels[i][0] - viewport[0])) / viewport[2] - 1.0;
+		vec.y() = (2.0 * (pixels[i][1] - viewport[1])) / viewport[3] - 1.0;
+		vec.z() = 1.0;
 
 		viewVectors[i] = vec.getTransformed(cam.getInvProjectionMatrix());
 		// end of optimized code

src/Renderer/Renderer.cpp

@@ -375,9 +375,9 @@ 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.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;

src/Scripting/Math/Vec2.bpi.cpp

@@ -5,9 +5,6 @@
 WRAP(Vec2)
 {
 	class_<Vec2>("Vec2")
-		/// @todo fix this
-		/*.def_readwrite("x", &Vec2::x)
-		.def_readwrite("y", &Vec2::y)*/
 		// constructors
 		.def(init<>())
 		.def(init<float>())
@@ -15,6 +12,9 @@ WRAP(Vec2)
 		.def(init<const Vec2&>())
 		.def(init<const Vec3&>())
 		.def(init<const Vec4&>())
+		// Accessors
+		BP_PROPERTY_MATH(Vec2, x)
+		BP_PROPERTY_MATH(Vec2, y)
 		// ops with same type
 		.def(self + self)
 		.def(self += self)

src/Scripting/Math/Vec3.bpi.cpp

@@ -5,9 +5,10 @@
 WRAP(Vec3)
 {
 	class_<Vec3>("Vec3")
-		.def_readwrite("x", &Vec3::x)
+		/// @todo correct
+		/*.def_readwrite("x", &Vec3::x)
 		.def_readwrite("y", &Vec3::y)
-		.def_readwrite("z", &Vec3::z)
+		.def_readwrite("z", &Vec3::z)*/
 		// constructors
 		.def(init<>())
 		.def(init<float>())

src/Scripting/Renderer/Hdr.bpi.cpp

@@ -5,8 +5,8 @@
 WRAP(Hdr)
 {
 	class_<Hdr, noncopyable>("Hdr", no_init)
-		BP_PROPERTY_RW("blurringIterationsNum", Hdr::getBlurringIterationsNum, Hdr::setBlurringIterationsNum)
-		BP_PROPERTY_RW("exposure", Hdr::getExposure, Hdr::setExposure)
-		BP_PROPERTY_RW("blurringDist", Hdr::getBlurringDist, Hdr::setBlurringDist)
+		BP_PROPERTY_BASIC_TYPE(uint, Hdr, "blurringIterationsNum", getBlurringIterationsNum, setBlurringIterationsNum)
+		BP_PROPERTY_BASIC_TYPE(float, Hdr, "exposure", getExposure, setExposure)
+		BP_PROPERTY_BASIC_TYPE(float, Hdr, "blurringDist", getBlurringDist, setBlurringDist)
 	;
 }

src/Scripting/ScriptingCommon.h

@@ -22,6 +22,48 @@ using namespace boost::python;
 	}
 
 
-/// Boost python property read write
-#define BP_PROPERTY_RW(name__, getter__, setter__) \
-	.add_property(name__, & getter__##Value, & setter__##Value)
+//======================================================================================================================
+// Property for simple types                                                                                           =
+//======================================================================================================================
+
+template<typename ClassType, typename RetType, const RetType& (ClassType::* accessor)() const>
+RetType getterSv(const ClassType* t)
+{
+	return (t->*accessor)();
+}
+
+
+template<typename ClassType, typename InType, void (ClassType::* accessor)(const InType&)>
+void setterSv(ClassType* t, InType in)
+{
+	(t->*accessor)(in);
+}
+
+/// Boost python property for simple RW types (int, float etc) that cannot be wrapped by boost::python correctly
+#define BP_PROPERTY_BASIC_TYPE(Type__, Class__, var__, getter__, setter__) \
+	.add_property(var__, &getterSv<Class__, Type__, &Class__::getter__>, \
+	              &setterSv<Class__, Type__, &Class__::setter__>)
+
+
+//======================================================================================================================
+// Math library stuff                                                                                                  =
+//======================================================================================================================
+
+template<typename ClassType, typename RetType, RetType (ClassType::* accessor)() const>
+RetType getM(const ClassType* t)
+{
+	return (t->*accessor)();
+}
+
+
+template<typename ClassType, typename InType, InType& (ClassType::* accessor)()>
+void setM(ClassType* t, InType in)
+{
+	(t->*accessor)() = in;
+}
+
+
+#define BP_PROPERTY_MATH(ClassType__, name__) \
+	.add_property(#name__, &getM<ClassType__, float, &ClassType__::name__>, \
+	              &setM<ClassType__, float, &ClassType__::name__>)
+

src/Util/Properties.h

@@ -13,10 +13,8 @@
 		Type__ varName__; \
 	public: \
 		void setFunc__(const Type__& x__) {varName__ = x__;} \
-		void setFunc__##Value(Type__ x__) {varName__ = x__;} \
 		const Type__& getFunc__() const {return varName__;} \
 		Type__& getFunc__() {return varName__;} \
-		Type__ getFunc__##Value() const {return varName__;}
 
 
 /// Read only private property