copied refactor to trunk

12 files changed, 12 insertions, 694 deletions

diff --git a/src/base/tl/algorithm.hpp b/src/base/tl/algorithm.h
index 9d78810b..32c2da73 100644
--- a/src/base/tl/algorithm.hpp
+++ b/src/base/tl/algorithm.h
@@ -1,7 +1,7 @@
 #ifndef TL_FILE_ALGORITHM_HPP
 #define TL_FILE_ALGORITHM_HPP
 
-#include "range.hpp"
+#include "range.h"
 
 
 /*
@@ -59,7 +59,7 @@ R find_linear(R range, T value)
 	concept_empty::check(range);
 	concept_forwarditeration::check(range);
 	for(; !range.empty(); range.pop_front())
-		if(value < range.front())
+		if(value == range.front())
 			break;
 	return range;
 }
diff --git a/src/base/tl/allocator.hpp b/src/base/tl/allocator.h
index 3baa1c19..3baa1c19 100644
--- a/src/base/tl/allocator.hpp
+++ b/src/base/tl/allocator.h
diff --git a/src/base/tl/array.hpp b/src/base/tl/array.h
index 7b8698d4..580f4682 100644
--- a/src/base/tl/array.hpp
+++ b/src/base/tl/array.h
@@ -1,8 +1,8 @@
 #ifndef TL_FILE_ARRAY_HPP
 #define TL_FILE_ARRAY_HPP
 
-#include "range.hpp"
-#include "allocator.hpp"
+#include "range.h"
+#include "allocator.h"
 
 
 /*
@@ -165,7 +165,7 @@ public:
 	int add(const T& item)
 	{
 		incsize();
-		num_elements = size()+1;
+		set_size(size()+1);
 		list[num_elements-1] = item;
 		return num_elements-1;
 	}
@@ -189,7 +189,7 @@ public:
 			
 		int index = (int)(&r.front()-list);
 		incsize();
-		num_elements = size()+1;
+		set_size(size()+1);
 		
 		for(int i = num_elements-1; i > index; i--)
 			list[i] = list[i-1];
@@ -283,7 +283,7 @@ public:
 	*/
 	int memusage()
 	{
-		return sizeof(*this) + sizeof(T)*list_size;
+		return sizeof(array) + sizeof(T)*size;
 	}
 
 	/*
diff --git a/src/base/tl/base.hpp b/src/base/tl/base.h
index c202de79..c202de79 100644
--- a/src/base/tl/base.hpp
+++ b/src/base/tl/base.h
diff --git a/src/base/tl/math.hpp b/src/base/tl/math.hpp
deleted file mode 100644
index b323dea8..00000000
--- a/src/base/tl/math.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* copyright (c) 2007 magnus auvinen, see licence.txt for more info */
-#ifndef BASE_MATH_H
-#define BASE_MATH_H
-
-#include <stdlib.h>
-
-template <typename T>
-inline T clamp(T val, T min, T max)
-{
-	if(val < min)
-		return min;
-	if(val > max)
-		return max;
-	return val;
-}
-
-inline float sign(float f)
-{
-	return f<0.0f?-1.0f:1.0f;
-}
-
-inline int round(float f)
-{
-	if(f > 0)
-		return (int)(f+0.5f);
-	return (int)(f-0.5f);
-}
-
-template<typename T, typename TB>
-inline T mix(const T a, const T b, TB amount)
-{
-	return a + (b-a)*amount;
-}
-
-inline float frandom() { return rand()/(float)(RAND_MAX); }
-
-const float pi = 3.1415926535897932384626433f;
-
-template <typename T> inline T min(T a, T b) { return a<b?a:b; }
-template <typename T> inline T max(T a, T b) { return a>b?a:b; }
-
-template <typename T> inline T min(T a, T b, T c) { return min(min(a,b),c); }
-template <typename T> inline T max(T a, T b, T c) { return max(max(a,b),c); }
-
-#endif // BASE_MATH_H
diff --git a/src/base/tl/matrix.hpp b/src/base/tl/matrix.hpp
deleted file mode 100644
index b723eaa7..00000000
--- a/src/base/tl/matrix.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#ifndef TL_FILE_MATRIX_HPP
-#define TL_FILE_MATRIX_HPP
-
-/*
- 
- Looks like OpenGL 
- 
- Column Major
-
-        / m[0][0]  m[1][0]  m[2][0]  m[3][0] \     / v[0] \
-        |                                    |     |      |
-		| m[0][1]  m[1][1]  m[2][1]  m[3][1] |     | v[1] |
-        |                                    |     |      |
- M(v) = | m[0][2]  m[1][2]  m[2][2]  m[3][2] |  X  | v[2] |
-        |                                    |     |      |
-        \ m[0][3]  m[1][3]  m[2][3]  m[3][3] /     \ v[3] /
- 
- v[0] = x
- v[1] = y
- v[2] = z
- v[3] = w or 1
- 
-   +y
-   |
-   |
-   |_____ +x
-   /
-  /
- +z
- 
- right = +x
- up = +y
- forward = -z
-
-*/
-
-template<class T>
-class matrix4_base
-{
-public:
-	// [col][row]
-	T m[4][4];
-
-	//
-	inline matrix4_base()
-	{}
-
-	inline vector3_base<T> get_column3(const int i) const { return vector3_base<T>(m[i][0], m[i][1], m[i][2]); }
-	inline vector3_base<T> get_column4(const int i) const { return vector4_base<T>(m[i][0], m[i][1], m[i][2], m[i][3]); }
-	inline vector3_base<T> get_row3(const int i) const { return vector3_base<T>(m[0][i], m[1][i], m[2][i]); }
-	inline vector4_base<T> get_row4(const int i) const { return vector4_base<T>(m[0][i], m[1][i], m[2][i], m[3][i]); }
-
-	inline vector3_base<T> get_right() const { return get_row3(0); }
-	inline vector3_base<T> get_up() const { return get_row3(1); }
-	inline vector3_base<T> get_forward() const { return -get_row3(2); }
-	inline vector3_base<T> get_translation() const { return get_column3(3); }
-
-	//
-	void unit()
-	{
-		m[0][1] = m[0][2] = m[0][3] = 0;
-		m[1][0] = m[1][2] = m[1][3] = 0;
-		m[2][0] = m[2][1] = m[2][3] = 0;
-		m[3][0] = m[3][1] = m[3][2] = 0;
-
-		m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1;
-	}
-
-	//
-	vector3_base<T> operator *(const vector3_base<T> &v) const
-	{
-		vector3_base<T> r(0,0,0);
-
-		r.x += v.x*m[0][0] + v.y*m[1][0] + v.z*m[2][0] + m[3][0];
-		r.y += v.x*m[0][1] + v.y*m[1][1] + v.z*m[2][1] + m[3][1];
-		r.z += v.x*m[0][2] + v.y*m[1][2] + v.z*m[2][2] + m[3][2];
-		return r;
-	}
-
-	//
-	vector4_base<T> operator *(const vector4_base<T> &v) const
-	{
-		vector4_base<T> r(0,0,0,0);
-
-		r.x += v.x*m[0][0] + v.y*m[1][0] + v.z*m[2][0] + v.w*m[3][0];
-		r.y += v.x*m[0][1] + v.y*m[1][1] + v.z*m[2][1] + v.w*m[3][1];
-		r.z += v.x*m[0][2] + v.y*m[1][2] + v.z*m[2][2] + v.w*m[3][2];
-		r.w += v.x*m[0][3] + v.y*m[1][3] + v.z*m[2][3] + v.w*m[3][3];
-		return r;
-	}
-	//
-	matrix4_base operator *(const matrix4_base &other) const
-	{
-		matrix4_base r;
-
-		for(int i = 0; i < 4; i++)
-			for(int j = 0; j < 4; j++)
-			{
-				r.m[i][j] = 0;
-				for(int a = 0; a < 4; a++)
-					r.m[i][j] += m[a][j] * other.m[i][a];
-			}
-		return r;
-	}
-	
-	
-	//
-	// THIS PART IS KINDA UGLY BECAUSE MAT4 IS NOT IMMUTABLE
-	//
-	
-	inline void set_row(const vector3_base<T>& v, const int row)
-	{
-		m[0][row] = v.x;
-		m[1][row] = v.y;
-		m[2][row] = v.z;
-	}
-
-	inline void set_column(const vector3_base<T>& v, const int col)
-	{
-		m[col][0] = v.x;
-		m[col][1] = v.y;
-		m[col][2] = v.z;
-	}
-
-	inline void set_translation(const vector3_base<T>& v) { set_column(v,3); }	
-
-	//
-	void rot_x(T angle)
-	{
-		T sina = (T)sin(angle);
-		T cosa = (T)cos(angle);
-
-		unit();
-		m[1][1] = cosa; m[2][1] =-sina;
-		m[1][2] = sina; m[2][2] = cosa;
-	}
-
-	//
-	void rot_y(T angle)
-	{
-		T sina = (T)sin(-angle);
-		T cosa = (T)cos(-angle);
-
-		unit();
-		m[0][0] = cosa; m[2][0] =-sina;
-		m[0][2] = sina; m[2][2] = cosa;
-	}
-
-	//
-	void rot_z(T angle)
-	{
-		T sina = (T)sin(angle);
-		T cosa = (T)cos(angle);
-
-		unit();
-		m[0][0] = cosa; m[1][0] =-sina;
-		m[0][1] = sina; m[1][1] = cosa;
-	}
-};
-
-typedef matrix4_base<float> mat4;
-
-#endif
diff --git a/src/base/tl/quat.hpp b/src/base/tl/quat.hpp
deleted file mode 100644
index 2f381e11..00000000
--- a/src/base/tl/quat.hpp
+++ /dev/null
@@ -1,211 +0,0 @@
-
-
-template<class T>
-class quaternion_base
-{
-public:
-	T k[4];
-
-	/*void Unit()
-	{
-		k[0] = 0;
-		k[1] = 0;
-		k[2] = 0;
-		k[3] = 1;
-	}*/
-	
-	inline quaternion_base(){}
-
-	inline quaternion_base(T x, T y, T z, T w)
-	{
-		k[0] = x;
-		k[1] = y;
-		k[2] = z;
-		k[3] = w;
-	}
-	
-	inline quaternion_base(vector3_base<T> axis, T angle)
-	{
-		T sin_angle = sin(angle * (T)0.5);
-		T cos_angle = cos(angle * (T)0.5);
-		k[0] = axis.x * sin_angle;
-		k[1] = axis.y * sin_angle;
-		k[2] = axis.z * sin_angle;
-		k[3] = cos_angle;
-	}
-	
-
-	T magnitude()
-	{
-		return sqrt(k[0] * k[0] + k[1] * k[1] + k[2] * k[2] + k[3] * k[3]);
-	}
-
-	matrix4_base<T> create_matrix() const
-	{
-		matrix4_base<T> mat;
-		
-		T xx = k[0] * k[0];
-		T xy = k[0] * k[1];
-		T xz = k[0] * k[2];
-		T xw = k[0] * k[3];
-		T yy = k[1] * k[1];
-		T yz = k[1] * k[2];
-		T yw = k[1] * k[3];
-		T zz = k[2] * k[2];
-		T zw = k[2] * k[3];
-		
-		mat.k[0][0] = 1 - 2 * (yy + zz);
-		mat.k[0][1] = 2 * (xy + zw);
-		mat.k[0][2] = 2 * (xz - yw);
-		mat.k[0][3] = 0;
-		
-		mat.k[1][0] = 2 * (xy - zw);
-		mat.k[1][1] = 1 - 2 * (xx + zz);
-		mat.k[1][2] = 2 * (yz + xw);
-		mat.k[1][3] = 0;
-
-		mat.k[2][0] = 2 * (xz + yw);
-		mat.k[2][1] = 2 * (yz - xw);
-		mat.k[2][2] = 1 - 2 * (xx + yy);
-		mat.k[2][3] = 0;
-
-		mat.k[3][0] = 0;
-		mat.k[3][1] = 0;
-		mat.k[3][2] = 0;
-		mat.k[3][3] = 1;
-	}
-
-	/*
-	void CreateDOOM(T x, T y, T z)
-	{
-		k[0] = x;
-		k[1] = y;
-		k[2] = z;
-		T Term = 1 - (x * x) - (y * y) - (z * z);
-		if (Term < 0)
-			k[3] = 0;
-		else
-			k[3] = -sqrt(Term);
-
-		Normalize();
-	}
-	
-	T DotProd(const TQuaternion<T>& Quat) const
-	{
-		return (k[0] * Quat.k[0] + k[1] * Quat.k[1] + k[2] * Quat.k[2] + k[3] * Quat.k[3]);
-	}
-
-	void Interpolate(const TQuaternion<T>& Quat, TQuaternion& Dest, T Scale)
-	{
-		T Separation = k[0] * Quat.k[0] + k[1] * Quat.k[1] + k[2] * Quat.k[2] + k[3] * Quat.k[3];
-		T Factor1,Factor2;
-
-		if (Separation > 1)
-			Separation = 1;
-		if (Separation < -1)
-			Separation = -1;
-		Separation = acos(Separation);
-		if (Separation == 0 || Separation == pi)
-		{
-			Factor1 = 1;
-			Factor2 = 0;
-		}
-		else
-		{
-			Factor1 = sin((1 - Scale)*Separation) / sin(Separation);
-			Factor2 = sin(Scale * Separation) / sin(Separation);
-		}
-		
-		Dest.k[0] = k[0] * Factor1 + Quat.k[0] * Factor2;
-		Dest.k[1] = k[1] * Factor1 + Quat.k[1] * Factor2;
-		Dest.k[2] = k[2] * Factor1 + Quat.k[2] * Factor2;
-		Dest.k[3] = k[3] * Factor1 + Quat.k[3] * Factor2;
-	}
-
-	void Slerp(const TQuaternion<T>& Quat, TQuaternion& Dest, T Scale) const
-	{
-		T Sq1,Sq2;
-		T Dot = DotProd(Quat);
-
-		TQuaternion Temp;
-
-		if (Dot < 0.0f)
-		{
-			Dot = -Dot;
-			Temp.k[0] = -Quat.k[0];
-			Temp.k[1] = -Quat.k[1];
-			Temp.k[2] = -Quat.k[2];
-			Temp.k[3] = -Quat.k[3];
-		}
-		else
-		{
-			Temp = Quat;
-		}
-
-		if ((1.0 + Dot) > 0.00001)
-		{
-			if ((1.0 - Dot) > 0.00001)
-			{
-				T om = (T)acos(Dot);
-				T rsinom = (T)(1.0f / sin(om));
-				Sq1 = (T)sin(((T)1.0 - Scale) * om) * rsinom;
-				Sq2 = (T)sin(Scale * om) * rsinom;
-			}
-			else
-			{
-				Sq1 = (T)(1.0 - Scale);
-				Sq2 = Scale;
-			}
-			Dest.k[0] = Sq1 * k[0] + Sq2 * Temp[0];
-			Dest.k[1] = Sq1 * k[1] + Sq2 * Temp[1];
-			Dest.k[2] = Sq1 * k[2] + Sq2 * Temp[2];
-			Dest.k[3] = Sq1 * k[3] + Sq2 * Temp[3];
-		}
-		else
-		{
-			Sq1 = (T)sin(((T)1.0 - Scale) * (T)0.5 * pi);
-			Sq2 = (T)sin(Scale * (T)0.5 * pi);
-
-			Dest.k[0] = Sq1 * k[0] + Sq2 * Temp[1];
-			Dest.k[1] = Sq1 * k[1] + Sq2 * Temp[0];
-			Dest.k[2] = Sq1 * k[2] + Sq2 * Temp[3];
-			Dest.k[3] = Sq1 * k[3] + Sq2 * Temp[2];
-		}
-	}*/
-
-	// perators
-	T& operator [] (int i) { return k[i]; }
-
-	// quaternion multiply
-	quaternion_base operator *(const quaternion_base& other) const
-	{
-		// (w1 dot w2 - v1 dot v2, w1 dot v2 + w2 dot v1 + v1 cross v2)
-		quaternion_base r;
-		r.k[0] = k[3] * other.k[0] + k[0] * other.k[3] + k[1] * other.k[2] - k[2] * other.k[1];
-		r.k[1] = k[3] * other.k[1] + k[1] * other.k[3] + k[2] * other.k[0] - k[0] * other.k[2];
-		r.k[2] = k[3] * other.k[2] + k[2] * other.k[3] + k[0] * other.k[1] - k[1] * other.k[0];
-		r.k[3] = k[3] * other.k[3] - k[0] * other.k[0] - k[1] * other.k[1] - k[2] * other.k[2];
-
-		return normalize(r);
-	}
-	
-	/*
-	bool operator == (const quaternion_base<T>& t) const { return ((k[0] == t.k[0]) && (k[1] == t.k[1]) && (k[2] == t.k[2]) && (k[3] == t.k[3])); }
-	bool operator != (const quaternion_base<T>& t) const { return ((k[0] != t.k[0]) || (k[1] != t.k[1]) || (k[2] != t.k[2]) || (k[3] != t.k[3])); }
-
-	void operator = (const quaternion_base<T>& other) { k[0] = other.k[0]; k[1] = other.k[1]; k[2] = other.k[2]; k[3] = other.k[3]; }
-	*/
-	
-	/*void operator *= (const TQuaternion<T>& t) 				{ TQuaternion Temp = Multiply(t); *this = Temp; }
-	TQuaternion operator * (const TQuaternion<T>& t)		const	{ return Multiply(t); }
-	*/
-};
-
-template<typename T>
-inline quaternion_base<T> normalize(const quaternion_base<T> &v)
-{
-	T factor = 1.0f/v.magnitude();
-	return quaternion_base<T>(v.k[0]*factor, v.k[1]*factor,v. k[2]*factor,v. k[3]*factor);
-}
-
-
diff --git a/src/base/tl/range.hpp b/src/base/tl/range.h
index 559daffa..1c63e73c 100644
--- a/src/base/tl/range.hpp
+++ b/src/base/tl/range.h
@@ -1,7 +1,7 @@
 #ifndef TL_FILE_RANGE_HPP
 #define TL_FILE_RANGE_HPP
 
-#include "base.hpp"
+#include "base.h"
 
 /*
 	Group: Range concepts
diff --git a/src/base/tl/sorted_array.hpp b/src/base/tl/sorted_array.h
index 30c1df24..95f06157 100644
--- a/src/base/tl/sorted_array.hpp
+++ b/src/base/tl/sorted_array.h
@@ -1,8 +1,8 @@
 #ifndef TL_FILE_SORTED_ARRAY_HPP
 #define TL_FILE_SORTED_ARRAY_HPP
 
-#include "algorithm.hpp"
-#include "array.hpp"
+#include "algorithm.h"
+#include "array.h"
 
 template <class T, class ALLOCATOR = allocator_default<T> >
 class sorted_array : public array<T, ALLOCATOR>
diff --git a/src/base/tl/stream.hpp b/src/base/tl/stream.hpp
deleted file mode 100644
index c307b968..00000000
--- a/src/base/tl/stream.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef TL_FILE_STREAM_HPP
-#define TL_FILE_STREAM_HPP
-
-class input_stream
-{
-public:	
-	virtual ~input_stream() {}
-	virtual size_t read(void *data, size_t size) = 0;
-	virtual size_t size() = 0;
-};
-
-class output_stream
-{
-public:	
-	virtual ~output_stream() {}
-	virtual size_t write(const void *data, size_t size) = 0;
-};
-
-
-// input wrapping
-// RAII style
-class file_backend
-{
-private:
-	file_backend(const file_backend &other) { /* no copy allowed */ }
-protected:
-	IOHANDLE file_handle;
-	
-	explicit file_backend(const char *filename, int flags)
-	{
-		file_handle = io_open(filename, flags);
-	}
-	
-	~file_backend()
-	{
-		if(file_handle)
-			io_close(file_handle);
-	}
-public:
-	bool is_open() const { return file_handle != 0; }
-};
-
-class file_reader : public input_stream, public file_backend
-{
-public:	
-	explicit file_reader(const char *filename)
-	: file_backend(filename, IOFLAG_READ)
-	{}
-	
-	virtual size_t read(void *data, size_t size) { return io_read(file_handle, data, size); }
-	virtual size_t size() { return io_length(file_handle); }
-};
-
-
-class file_writer : public output_stream, public file_backend
-{
-public:	
-	explicit file_writer(const char *filename)
-	: file_backend(filename, IOFLAG_WRITE)
-	{}
-	
-	virtual size_t write(const void *data, size_t size) { return io_write(file_handle, data, size); }
-};
-
-#endif
diff --git a/src/base/tl/string.hpp b/src/base/tl/string.h
index 2b164091..155ca2a4 100644
--- a/src/base/tl/string.hpp
+++ b/src/base/tl/string.h
@@ -1,8 +1,8 @@
 #ifndef TL_FILE_STRING_HPP
 #define TL_FILE_STRING_HPP
 
-#include "base.hpp"
-#include "allocator.hpp"
+#include "base.h"
+#include "allocator.h"
 
 template<class ALLOCATOR >
 class string_base : private ALLOCATOR
diff --git a/src/base/tl/vector.hpp b/src/base/tl/vector.hpp
deleted file mode 100644
index 1c1bb804..00000000
--- a/src/base/tl/vector.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/* copyright (c) 2007 magnus auvinen, see licence.txt for more info */
-#ifndef TL_FILE_VECTOR_HPP
-#define TL_FILE_VECTOR_HPP
-
-#include <math.h>
-
-// ------------------------------------
-
-template<typename T>
-class vector2_base
-{
-public:
-	union { T x,u; };
-	union { T y,v; };
-	
-	vector2_base() {}
-	vector2_base(float nx, float ny)
-	{
-		x = nx;
-		y = ny;
-	}
-	
-	vector2_base operator -() const { return vector2_base(-x, -y); }
-	vector2_base operator -(const vector2_base &v) const { return vector2_base(x-v.x, y-v.y); }
-	vector2_base operator +(const vector2_base &v) const { return vector2_base(x+v.x, y+v.y); }
-	vector2_base operator *(const T v) const { return vector2_base(x*v, y*v); }
-	
-	const vector2_base &operator =(const vector2_base &v) { x = v.x; y = v.y; return *this; }
-
-	const vector2_base &operator +=(const vector2_base &v) { x += v.x; y += v.y; return *this; }
-	const vector2_base &operator -=(const vector2_base &v) { x -= v.x; y -= v.y; return *this; }
-	const vector2_base &operator *=(const T v) { x *= v; y *= v; return *this;	}
-
-	bool operator ==(const vector2_base &v) const { return x == v.x && y == v.y; } //TODO: do this with an eps instead
-
-	operator const T* () { return &x; }
-};
-
-
-template<typename T>
-inline T length(const vector2_base<T> &a)
-{
-	return sqrtf(a.x*a.x + a.y*a.y);
-}
-
-template<typename T>
-inline T distance(const vector2_base<T> a, const vector2_base<T> &b)
-{
-	return length(a-b);
-}
-
-template<typename T>
-inline T dot(const vector2_base<T> a, const vector2_base<T> &b)
-{
-	return a.x*b.x + a.y*b.y;
-}
-
-template<typename T>
-inline vector2_base<T> normalize(const vector2_base<T> &v)
-{
-	T l = (T)(1.0f/sqrtf(v.x*v.x + v.y*v.y));
-	return vector2_base<T>(v.x*l, v.y*l);
-}
-
-typedef vector2_base<float> vec2;
-typedef vector2_base<bool> bvec2;
-typedef vector2_base<int> ivec2;
-
-template<typename T>
-inline vector2_base<T> closest_point_on_line(vector2_base<T> line_point0, vector2_base<T> line_point1, vector2_base<T> target_point)
-{
-	vector2_base<T> c = target_point - line_point0;
-	vector2_base<T> v = (line_point1 - line_point0);
-	v = normalize(v);
-	T d = length(line_point0-line_point1);
-	T t = dot(v, c)/d;
-	return mix(line_point0, line_point1, clamp(t, (T)0, (T)1));
-	/*
-	if (t < 0) t = 0;
-	if (t > 1.0f) return 1.0f;
-	return t;*/
-}
-	
-// ------------------------------------
-template<typename T>
-class vector3_base
-{
-public:
-	union { T x,r,h; };
-	union { T y,g,s; };
-	union { T z,b,v,l; };
-
-	vector3_base() {}
-	vector3_base(float nx, float ny, float nz)
-	{
-		x = nx;
-		y = ny;
-		z = nz;
-	}
-	
-	const vector3_base &operator =(const vector3_base &v) { x = v.x; y = v.y; z = v.z; return *this; }
-
-	vector3_base operator -(const vector3_base &v) const { return vector3_base(x-v.x, y-v.y, z-v.z); }
-	vector3_base operator -() const { return vector3_base(-x, -y, -z); }
-	vector3_base operator +(const vector3_base &v) const { return vector3_base(x+v.x, y+v.y, z+v.z); }
-	vector3_base operator *(const T v) const { return vector3_base(x*v, y*v, z*v); }
-	vector3_base operator *(const vector3_base &v) const { return vector3_base(x*v.x, y*v.y, z*v.z); }
-	vector3_base operator /(const T v) const { return vector3_base(x/v, y/v, z/v); }
-	
-	const vector3_base &operator +=(const vector3_base &v) { x += v.x; y += v.y; z += v.z; return *this; }
-	const vector3_base &operator -=(const vector3_base &v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
-	const vector3_base &operator *=(const T v) { x *= v; y *= v; z *= v; return *this;	}
-
-	bool operator ==(const vector3_base &v) const { return x == v.x && y == v.y && z == v.z; } //TODO: do this with an eps instead
-
-	operator const T* () { return &x; }
-};
-
-template<typename T>
-inline T length(const vector3_base<T> &a)
-{
-	return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z);
-}
-
-template<typename T>
-inline T distance(const vector3_base<T> &a, const vector3_base<T> &b)
-{
-	return length(a-b);
-}
-
-template<typename T>
-inline T dot(const vector3_base<T> &a, const vector3_base<T> &b)
-{
-	return a.x*b.x + a.y*b.y + a.z*b.z;
-}
-
-template<typename T>
-inline vector3_base<T> normalize(const vector3_base<T> &v)
-{
-	T l = (T)(1.0f/sqrtf(v.x*v.x + v.y*v.y + v.z*v.z));
-	return vector3_base<T>(v.x*l, v.y*l, v.z*l);
-}
-
-template<typename T>
-inline vector3_base<T> cross(const vector3_base<T> &a, const vector3_base<T> &b)
-{
-	return vector3_base<T>(
-		a.y*b.z - a.z*b.y,
-		a.z*b.x - a.x*b.z,
-		a.x*b.y - a.y*b.x);
-}
-
-typedef vector3_base<float> vec3;
-typedef vector3_base<bool> bvec3;
-typedef vector3_base<int> ivec3;
-
-// ------------------------------------
-
-template<typename T>
-class vector4_base
-{
-public:
-	union { T x,r; };
-	union { T y,g; };
-	union { T z,b; };
-	union { T w,a; };
-
-	vector4_base() {}
-	vector4_base(float nx, float ny, float nz, float nw)
-	{
-		x = nx;
-		y = ny;
-		z = nz;
-		w = nw;
-	}
-	
-	vector4_base operator +(const vector4_base &v) const { return vector4_base(x+v.x, y+v.y, z+v.z, w+v.w); }
-	vector4_base operator -(const vector4_base &v) const { return vector4_base(x-v.x, y-v.y, z-v.z, w-v.w); }
-	vector4_base operator -() const { return vector4_base(-x, -y, -z, -w); }
-	vector4_base operator *(const vector4_base &v) const { return vector4_base(x*v.x, y*v.y, z*v.z, w*v.w); }
-	vector4_base operator *(const T v) const { return vector4_base(x*v, y*v, z*v, w*v); }
-	
-	const vector4_base &operator =(const vector4_base &v) { x = v.x; y = v.y; z = v.z; w = v.w; return *this; }
-
-	const vector4_base &operator +=(const vector4_base &v) { x += v.x; y += v.y; z += v.z; w += v.w; return *this; }
-	const vector4_base &operator -=(const vector4_base &v) { x -= v.x; y -= v.y; z -= v.z; w -= v.w; return *this; }
-	const vector4_base &operator *=(const T v) { x *= v; y *= v; z *= v; w *= v; return *this;	}
-
-	bool operator ==(const vector4_base &v) const { return x == v.x && y == v.y && z == v.z && w == v.w; } //TODO: do this with an eps instead
-
-	operator const T* () { return &x; }
-};
-
-typedef vector4_base<float> vec4;
-typedef vector4_base<bool> bvec4;
-typedef vector4_base<int> ivec4;
-
-#endif