E:/Programming/MyProject/K_Game_hg/GameEngine/include/core/Matrix4.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _MATRIX4_H_
#define _MATRIX4_H_

#include <EngineConfig.h>
#include <core/Types.h>

namespace core
{

class vector3d;
class vector4d;
class plane3d;
class aabox3d;


class ENGINE_PUBLIC_EXPORT matrix4
{
public:

        matrix4();

        matrix4(f32 m00, f32 m01, f32 m02, f32 m03, f32 m10, f32 m11, f32 m12, f32 m13,
                        f32 m20, f32 m21, f32 m22, f32 m23, f32 m30, f32 m31, f32 m32, f32 m33);

        matrix4& operator=(const matrix4 &other);
        
        f32& operator()(s32 row, s32 col);

        const f32& operator()(s32 row, s32 col) const;

        f32& operator[](u32 index);

        const f32& operator[](u32 index) const;

        bool operator==(const matrix4 &other) const;

        bool operator!=(const matrix4 &other) const;

        matrix4& operator*=(const matrix4& other);

        matrix4 operator*(const matrix4& other) const;

        matrix4& operator+=(const matrix4& other);

        matrix4 operator+(const matrix4& other) const;

        matrix4& operator-=(const matrix4& other);

        matrix4 operator-(const matrix4& other) const;

        matrix4 operator- () const;

        void set(f32 m00, f32 m01, f32 m02, f32 m03, f32 m10, f32 m11, f32 m12, f32 m13,
                f32 m20, f32 m21, f32 m22, f32 m23, f32 m30, f32 m31, f32 m32, f32 m33);
        void set(const matrix4& other);

        f32* get();
        const f32* get() const;

        void makeIdentity();

        bool isIdentity();

        bool hasInverse();

        matrix4 getInverse() const;

        matrix4 getTransposed() const;

        void setTranslation(const vector3d& translation);

        vector3d getTranslation() const;

        void setInverseTranslation(const vector3d& translation);

        void setRotationRadians(const vector3d& rotation);

        void setRotationDegrees(const vector3d& rotation);

        vector3d getRotationDegrees() const;

        void setInverseRotationRadians(const vector3d& rotation);

        void setInverseRotationDegrees(const vector3d& rotation);

        void setScale(const vector3d& scale);

        vector3d getScale() const;

        void translateVector(vector3d& vect) const;

        void inverseTranslateVector(vector3d& vect) const;

        void rotateVector(vector3d& vect) const;

        void inverseRotateVect(vector3d& vect) const;

        void transformVector(vector3d& vect) const;

        void transformVector(const vector3d& in, vector3d& out) const;

        void transformVector(vector4d& vect) const;

        void transformVector(const vector4d& in, vector4d& out) const;

        void transformPlane(plane3d &plane) const;

        void transformPlane(const plane3d &in, plane3d &out) const;

        void transformBox(aabox3d& box) const;

        void buildProjectionMatrixInfinitePerspectiveFov(f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear);
        
        void buildProjectionMatrixPerspectiveFov(f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 zFar);
        
        void buildProjectionMatrixPerspective(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar);

        void buildProjectionMatrixOrtho(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar);

        void buildProjectionMatrixOrtho(f32 left, f32 right, f32 bottom, f32 top, f32 zNear, f32 zFar);

        void buildViewMatrix(const vector3d& position, const vector3d& target, const vector3d& upVector);

        void buildShadowMatrix(vector3d light, plane3d plane, f32 point = 1.0f);

        static const matrix4 ZERO;

        static const matrix4 IDENTITY;

private:

        static float empty;

        f32 M[16];
};

} // end namespace core

#endif