Structs.h

Go to the documentation of this file.

// File name: structs.h
// Date: 30/5/1385
// Programmer: Ali Akbar Mohammadi(Kochol)

#ifndef GFX_STRUCTS_H
#define GFX_STRUCTS_H

#include "../kgedef.h"
#include "../math/Matrix.h"
#include "../math/Vector.h"
#include "Color.h"
#include <math.h>

namespace kge
{
namespace gfx
{

enum VertexType
{
        EVT_V2 = 0,             
        EVT_V3,                 
        EVT_V3C,                
        EVT_V3T,                
        EVT_V3CT,       
        EVT_V3TN,               
        EVT_V3TNC,              
        EVT_V3TTN,              
        EVT_P0NT1BT2I3, 
        EVT_P0NTC1BT2,
        EVT_PJ0NT1BT2I3,
//      EVT_P0NT1BT2I3, /**< Vertex3 + Normal vector + Texture coord + Tangent + Binormal in multi stream mode. */
//      EVT_P0NTC1BT2I3,/**< Vertex3 + Normal vector + Texture coord + Color + Tangent + Binormal + Instance data in multi stream mode. */
//      EVT_PJ0NT1BT2I3,/**< Vertex3 + Joint index for hardware skinning + Normal vector + Texture coord + Tangent + Binormal + Instance data in multi stream mode. */
//      EVT_P0NT1I2,    /**< Vertex3 + Normal vector + Texture coord + Instance data in multi stream mode. */
//      EVT_P0NTC1I2,   /**< Vertex3 + Normal vector + Texture coord + Color + Instance data in multi stream mode. */
//      EVT_PJ0NT1I2,   /**< Vertex3 + Joint index for hardware skinning + Normal vector + Texture coord + Instance data in multi stream mode. */

        EVT_Count               
}; // VertexType

struct Vertex2
{
        float X;        
        float Y;        
}; // Vertex2


struct Vertex3
{
        float X; 
        float Y; 
        float Z; 
        Vertex3() : X(0.0f), Y(0.0f), Z(0.0f) {}

        Vertex3(float x, float y, float z) : X(x), Y(y), Z(z) {}

        inline void Transform4(math::Matrix * mat)
        {
                float xt,yt,zt;
                xt= X * mat->m_fMat[0] + 
                        Y * mat->m_fMat[4] +
                        Z * mat->m_fMat[8] + 
                                mat->m_fMat[12];
                yt= X * mat->m_fMat[1] + 
                        Y * mat->m_fMat[5] + 
                        Z * mat->m_fMat[9] + 
                                mat->m_fMat[13];
                zt= X * mat->m_fMat[2] + 
                        Y * mat->m_fMat[6] + 
                        Z * mat->m_fMat[10]+
                                mat->m_fMat[14];
                X = xt;
                Y = yt;
                Z = zt;
        } // Transform4

        inline void Transform3(math::Matrix * mat)
        {
                float xt,yt,zt;
                xt= X * mat->m_fMat[0] + 
                        Y * mat->m_fMat[4] +
                        Z * mat->m_fMat[8];
                yt= X * mat->m_fMat[1] + 
                        Y * mat->m_fMat[5] + 
                        Z * mat->m_fMat[9];
                zt= X * mat->m_fMat[2] + 
                        Y * mat->m_fMat[6] + 
                        Z * mat->m_fMat[10];
                X = xt;
                Y = yt;
                Z = zt;
        } // Transform3

        inline Vertex3 operator - (const Vertex3 &o) const
        {
                Vertex3 r;
                r.X = X - o.X;
                r.Y = Y - o.Y;
                r.Z = Z - o.Z;

                return r;
        }

        inline Vertex3 operator + (const Vertex3 &o) const
        {
                Vertex3 r;
                r.X = X + o.X;
                r.Y = Y + o.Y;
                r.Z = Z + o.Z;

                return r;
        }

        inline Vertex3 operator * (const float &f) const
        {
                Vertex3 r;
                r.X = X * f;
                r.Y = Y * f;
                r.Z = Z * f;

                return r;
        }

        //inline Vertex3 operator *= (const float &f) const
        //{
        //      Vertex3 r;
        //      r.X = X * f;
        //      r.Y = Y * f;
        //      r.Z = Z * f;

        //      return r;
        //}

        inline void Normalize()
        {
                float f = (float)sqrt(X*X + Y*Y + Z*Z);
                if (f != 0.0f)
                {
                        X /= f;
                        Y /= f;
                        Z /= f;
                }
        } // Normalize

        inline kge::math::Vector ToVector()
        {
                math::Vector v;
                v.x = X;
                v.y = Y;
                v.z = Z;
                return v;

        } // ToVector

        inline void Cross(const Vertex3& v1, const Vertex3& v2)
        {
                X=v1.Y*v2.Z-v1.Z*v2.Y;
                Y=v1.Z*v2.X-v1.X*v2.Z;
                Z=v1.X*v2.Y-v1.Y*v2.X;

        } // Cross

}; // Vertex3

struct Vertex3C
{
        Vertex3 pos;    
        Color   c;              
}; // Vertex3C  

struct Vertex3T
{
        Vertex3 pos;    
        Vertex2 tex;    
}; // Vertex3T

struct Vertex3CT
{
        Vertex3 pos;    
        Color   col;    
        Vertex2 tex;    
}; // Vertex3CT

struct Vertex3TN
{
        Vertex3 pos;    
        Vertex3 Nor;    
        Vertex2 tex;    
}; // Vertex3TN

struct Vertex3TTN
{
        Vertex3 pos;    
        Vertex3 Nor;    
        Vertex2 tex0;   
        Vertex2 tex1;   

}; // Vertex3TTN

struct Vertex3TNC
{
        Vertex3 pos;    //*< Makane Vertex.
        Vertex3 Nor;    //*< Normal Vector.
        Vertex2 tex;    //*< Makane Texture.
        float   Color;  
}; // Vertex3TNC

struct VertexNTC
{
        Vertex3 Nor;    //*< Normal Vector.
        Vertex2 tex;    //*< Texture coordinate.
        ul32    Color;  
}; // Vertex3TNC

struct Vertex3I
{
        Vertex3 pos;
        int             BoneID;
};

struct TextureInfo
{
        u32 TextureID;                  //*< Texture ha dar renderer ba in shenase ha shenakhte mishavand.
        char* Name;                             //*< Texture name.

}; // Texture.

enum LightType
{
        ELT_Directional,
        ELT_Point,
        ELT_Spot
};

struct LightData
{
        Colorf           Ambient;               
        Colorf           Diffuse;               
        Colorf           Specular;              
        math::Vector Position;
        math::Vector Direction;
        float        Range;                     
        float        Theta;
        float            Phi;                   
        LightType        Type;
        int                      Index;

}; // LightSpot

enum FogType
{
        EFT_NONE,
        EFT_LINEAR,
        EFT_EXP,
        EFT_EXP2
}; // FogType

// byte-align structures
#ifdef _MSC_VER
#       pragma pack(push, packing)
#       pragma pack(1)
#       define PACK_STRUCT
#elif defined(__GNUC__)
#       define PACK_STRUCT      __attribute__((packed))
#else
#       error compiler not supported
#endif

// Rotation/Translation information for joints
struct KeyFrame
{
        float m_fTime;
        float m_fParam[3];
} PACK_STRUCT; // KeyFrame

// Bone Joints for animation
struct Joint
{
        char m_cName[32]; //Bone name
        Vertex3 m_vRotation; //Starting rotation
        Vertex3 m_vPosition; //Starting position
        u16 m_usNumRotFrames; //Number of rotation frames
        u16 m_usNumTransFrames; //Number of translation frames
        KeyFrame * m_RotKeyFrames; //Rotation keyframes
        KeyFrame * m_TransKeyFrames; //Translation keyframes
        short m_sParent; //Parent joint index
        math::Matrix m_matLocal;
        math::Matrix m_matAbs;
        math::Matrix m_matFinal;
        u16 m_usCurRotFrame;
        u16 m_usCurTransFrame;
} PACK_STRUCT; // Joint

// Default alignment
#ifdef _MSC_VER
#       pragma pack(pop, packing)
#endif

#undef PACK_STRUCT

} // gfx

} // kge

#endif // GFX_STRUCTS_H