162 lines
2.9 KiB
C++
162 lines
2.9 KiB
C++
// ==============================================================
|
|
// 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
|