glest-source/source/shared_lib/include/graphics/matrix.h

// ==============================================================
//	This file is part of Glest Shared Library (www.glest.org)
//
//	Copyright (C) 2001-2008 Martiño Figueroa
//
//	You can redistribute this code and/or modify it under 
//	the terms of the GNU General Public License as published 
//	by the Free Software Foundation; either version 2 of the 
//	License, or (at your option) any later version
// ==============================================================

#ifndef _SHARED_GRAPHICS_MATRIX_H_
#define _SHARED_GRAPHICS_MATRIX_H_

#include "vec.h"
#include "leak_dumper.h"

namespace Shared {
	namespace Graphics {

		// =====================================================
		//	class Matrix3
		// =====================================================

		template<typename T>
		class Matrix3 {
		private:
			T data[9];
		public:
			Matrix3() {
			};

			Matrix3(T *p) {
				for (int i = 0; i < 9; ++i) {
					data[i] = p[i];
				}
			}

			T *ptr() {
				return data;
			}

			const T *ptr() const {
				return data;
			}

			T &operator[](int i) {
				return data[i];
			}

			T &operator()(int i, int j) {
				return data[i * 3 + j];
			}

			Vec3<T> operator * (const Vec3<T> &v) const {
				Vec3<T> rv;

				return Vec3f(
					data[0] * v.x + data[1] * v.y + data[2] * v.z,
					data[3] * v.x + data[4] * v.y + data[5] * v.z,
					data[6] * v.x + data[7] * v.y + data[8] * v.z);
			}

			Matrix3<T> operator * (const Matrix3<T> &m) const {
				Matrix3<T> rm;

				for (int i = 0; i < 3; ++i) {
					for (int j = 0; j < 3; ++j) {
						T acum = 0.0f;
						for (int k = 0; k < 3; ++k) {
							acum += data[i * 3 + k] * m[k * 3 + j];
						}
						rm[i * 3 + j] = acum;
					}
				}
				return rm;
			}

			void traspose() {
				for (int i = 0; i < 3; ++i) {
					for (int j = 0; j < 3; ++j) {
						T tmp = data[j * 3 + i];
						data[j * 3 + i] = data[i * 3 + j];
						data[i * 3 + j] = tmp;
					}
				}
			}
		};

		typedef Matrix3<float> Matrix3f;
		typedef Matrix3<double> Matrix3d;

		// =====================================================
		//	class Matrix4
		// =====================================================

		template<typename T>
		class Matrix4 {
		private:
			T data[16];
		public:
			Matrix4() {
			};

			Matrix4(T *p) {
				for (int i = 0; i < 16; ++i) {
					data[i] = p[i];
				}
			}

			T *ptr() {
				return data;
			}

			const T *ptr() const {
				return data;
			}

			T &operator[](int i) {
				return data[i];
			}

			const T &operator[](int i) const {
				return data[i];
			}

			T &operator()(int i, int j) {
				return data[i * 4 + j];
			}

			Vec4<T> operator * (const Vec4<T> &v) const {
				Vec4<T> rv;

				return Vec4f(
					data[0] * v.x + data[1] * v.y + data[2] * v.z + data[3] * v.w,
					data[4] * v.x + data[5] * v.y + data[6] * v.z + data[7] * v.w,
					data[8] * v.x + data[9] * v.y + data[10] * v.z + data[11] * v.w,
					data[12] * v.x + data[13] * v.y + data[14] * v.z + data[15] * v.w);
			}

			Matrix4<T> operator * (const Matrix4<T> &m) const {
				Matrix4<T> rm;

				for (int i = 0; i < 4; ++i) {
					for (int j = 0; j < 4; ++j) {
						T acum = 0.0f;
						for (int k = 0; k < 4; ++k) {
							acum += data[i * 4 + k] * m[k * 4 + j];
						}
						rm[i * 4 + j] = acum;
					}
				}
				return rm;
			}

		};

		typedef Matrix4<float> Matrix4f;
		typedef Matrix4<double> Matrix4d;


	}
} //enmd namespace

#endif