iSDGE/Engine/Common/sgMatrix4x4.h

//
//  sgMatrix4x4.h
//  Engine
//
//      Created by Nils Daumann on 24.05.10.
//      Copyright (c) 2010 Nils Daumann

//      Permission is hereby granted, free of charge, to any person obtaining a copy
//      of this software and associated documentation files (the "Software"), to deal
//      in the Software without restriction, including without limitation the rights
//      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//      copies of the Software, and to permit persons to whom the Software is
//      furnished to do so, subject to the following conditions:

//      The above copyright notice and this permission notice shall be included in
//      all copies or substantial portions of the Software.

//      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//      THE SOFTWARE.

#import "sgVector4.h"
#import "sgVector3.h"

class sgQuaternion;

class sgMatrix4x4
{
        public:
                sgMatrix4x4();
        
                sgMatrix4x4(const sgMatrix4x4 &other);
        
                sgMatrix4x4(float *other);
                
                bool operator== (const sgMatrix4x4 &other);
        
                bool operator!= (const sgMatrix4x4 &other);
        
                sgMatrix4x4 &operator= (const sgMatrix4x4 &other);
        
                sgMatrix4x4 &operator= (float *other);
                
                sgMatrix4x4 operator* (const sgMatrix4x4 &other);
        
                sgMatrix4x4 &operator*= (const sgMatrix4x4 &other);
                
                sgVector4 operator* (const sgVector4 &other);
        
                sgVector3 operator* (const sgVector3 &other);
                
                void set(float *other);
                
                void makeIdentity();
        
                void makeProjectionOrtho(float left, float right, float bottom, float top, float clipnear, float clipfar);
        
                void makeProjectionPersp(float arc, float aspect, float clipnear, float clipfar);
        
                void makeTranslate(const sgVector4 &trans);
        
                void makeTranslate(const sgVector3 &trans);
        
                void makeScale(const sgVector4 &scal);
        
                void makeScale(const sgVector3 &scal);
        
                void makeRotate(const sgVector4 &rot);
        
                void makeRotate(const sgVector3 &rot);
        
                void makeRotate(const sgQuaternion &rot);
                
                void translate(const sgVector4 &trans);
        
                void translate(const sgVector3 &trans);
        
                void scale(const sgVector4 &scal);
        
                void scale(const sgVector3 &scal);
        
                void rotate(const sgVector4 &rot);
        
                void rotate(const sgVector3 &rot);
        
                void rotate(const sgQuaternion &rot);
                
                void transpose();
        
                sgVector4 transform(const sgVector4 &other);
        
                sgVector3 transform(const sgVector3 &other);
                
                float mat[16];
};

---