D:/Zythum/DinoKod/Common/Vertex.h

#ifndef __VERTEX_H__
#define __VERTEX_H__

#include "Common/CommonDll.h"
#include <math.h>
#include <memory.h>
#include "Common/Types.h"
#include "Common/Vector.h"

// KIndex
//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KIndex
{
public:
        unsigned short  v0;
        unsigned short  v1;
        unsigned short  v2;
};

// KVertex
//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KVertex
{
public:
        // position
        KVector Position;
        // normal
        KVector Normal;
        // texture UV
        float   tu;
        float   tv;

        inline KVertex()
        {
                tu = 0.0f;
                tv = 0.0f;
        }
};

// KVertex2
class COMMON_API KVertex2
{
public:
        // position
        KVector Position;
        // normal
        KVector Normal;
        // texture UV
        float   tu1;
        float   tv1;
        float   tu2;
        float   tv2;

        inline KVertex2()
        {
                tu1 = 0.0f;
                tv1 = 0.0f;
                tu2 = 0.0f;
                tv2 = 0.0f;
        }

        inline bool operator != ( KVertex2& Vertex )
        {
                return ( ( Position != Vertex.Position ) || ( Normal != Vertex.Normal ) || ( tu1 != Vertex.tu1 ) || ( tv1 != Vertex.tv1 ) || ( tu2 != Vertex.tu2 ) || ( tv2 != Vertex.tv2 ) );
        }

        inline bool operator == ( KVertex2& Vertex )
        {
                return ( ( Position == Vertex.Position ) && ( Normal == Vertex.Normal ) && ( tu1 == Vertex.tu1 ) && ( tv1 == Vertex.tv1 ) && ( tu2 == Vertex.tu2 ) && ( tv2 == Vertex.tv2 ) );
        }
};

// KBVertex
#define KBVERTEX_NUNBLENDWEIGHT 4

class COMMON_API KBVertex
{
public:
        // position
        KVector m_Position;
        // weights
        u8      m_Weight[KBVERTEX_NUNBLENDWEIGHT];
        // weights indicies
        u8      m_Indices[KBVERTEX_NUNBLENDWEIGHT];
        // normal
        KVector m_Normal;
        // texture UV
        float   m_TU;
        float   m_TV;
        
        inline KBVertex()
        {
        }

        inline bool operator != ( KBVertex& Vertex )
        {
                return memcmp( this, &Vertex, sizeof( Vertex ) ) ? true : false;
        }

        inline bool operator == ( KBVertex& Vertex )
        {
                return memcmp( this, &Vertex, sizeof( Vertex ) ) ? false : true;
        }
};

// KLVertex
//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KLVertex
{
public:
        // position
        KVector Position;
        // color
        int             Color;
        int             Specular;
        // texture UV
        float   tu;
        float   tv;

        inline KLVertex()
        {
                Color           = 0;
                Specular        = 0;
                tu                      = 0.0f;
                tv                      = 0.0f;
        }
};

//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KLVertex2
{
public:
        // position
        KVector Position;
        // color
        int             Color;
        int             Specular;
        // texture UV
        float   tu1;
        float   tv1;
        float   tu2;
        float   tv2;

        inline KLVertex2()
        {
                Color           = 0;
                Specular        = 0;
                tu1                     = 0.0f;
                tv1                     = 0.0f;
                tu2                     = 0.0f;
                tv2                     = 0.0f;
        }

        inline KLVertex2 operator +( KLVertex2& v )
        {
                KLVertex2 Result;

                Result                  = *this;
                Result.Position = Position + v.Position;
                Result.tu1              = tu1 + v.tu1;
                Result.tv1              = tv1 + v.tv1;
                Result.tu2              = tu2 + v.tu2;
                Result.tv2              = tv2 + v.tv2;

                return Result;
        }

        inline KLVertex2 operator /( KLVertex2& v )
        {
                KLVertex2 Result;

                Result                  = *this;
                Result.Position = Position / v.Position;
                Result.tu1              = tu1 / v.tu1;
                Result.tv1              = tv1 / v.tv1;
                Result.tu2              = tu2 / v.tu2;
                Result.tv2              = tv2 / v.tv2;

                return Result;
        }

        inline KLVertex2 operator /( float f )
        {
                KLVertex2 Result;

                Result                  = *this;
                Result.Position = Position / f;
                Result.tu1              = tu1 / f;
                Result.tv1              = tv1 / f;
                Result.tu2              = tu2 / f;
                Result.tv2              = tv2 / f;

                return Result;
        }

        inline bool operator ==( KLVertex2& v )
        {
                return (        ( Position == v.Position ) &&
                                        ( Color == v.Color ) && 
                                        ( Specular == v.Specular ) &&
                                        ( tu1 == v.tu1 ) &&
                                        ( tv1 == v.tv1 ) &&
                                        ( tu2 == v.tu2 ) &&
                                        ( tv2 == v.tv2 ) );
        }
};

//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KLVertex3
{
public:
        // position
        KVector Position;
        // color
        int             Color;
        int             Specular;
        // texture UV
        float   tu1;
        float   tv1;
        float   tu2;
        float   tv2;
        float   tu3;
        float   tv3;

        inline KLVertex3()
        {
                Color           = 0;
                Specular        = 0;
                tu1                     = 0.0f;
                tv1                     = 0.0f;
                tu2                     = 0.0f;
                tv2                     = 0.0f;
                tu3                     = 0.0f;
                tv3                     = 0.0f;
        }
};

// KTLVertex
//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KTLVertex
{
public:
        float   x;
        float   y;
        float   z;
        float   rhw;
        int             color;
        int             specular;
        float   tu;
        float   tv;

        inline KTLVertex()
        {
                x = 0.0f;
                y = 0.0f;
                z = 0.0f;
                rhw = 0.0f;
                color = 0;
                specular = 0;
                tu = 0.0f;
                tv = 0.0f;
        }
        
        inline KTLVertex( float x, float y, float z, float rhw, int color, int specular = 0, float tu = 0.0f, float tv = 0.0f)
        {
                this->x = x;
                this->y = y;
                this->z = z;
                this->rhw = rhw;
                this->color = color;
                this->specular = specular;
                this->tu = tu;
                this->tv = tv;
        }
};

// KTLVertex2
//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KTLVertex2
{
public:
        float   x;
        float   y;
        float   z;
        float   rhw;
        int             color;
        int             specular;
        float   tu1;
        float   tv1;
        float   tu2;
        float   tv2;

        inline KTLVertex2()
        {
                x = 0.0f;
                y = 0.0f;
                z = 0.0f;
                rhw = 0.0f;
                color = 0;
                specular = 0;
                tu1 = 0.0f;
                tv1 = 0.0f;
                tu2 = 0.0f;
                tv2 = 0.0f;
        }
        
        inline KTLVertex2( float x, float y, float z, float rhw, int color, int specular = 0, float tu1 = 0.0f, float tv1 = 0.0f, float tu2 = 0.0f, float tv2 = 0.0f)
        {
                this->x = x;
                this->y = y;
                this->z = z;
                this->rhw = rhw;
                this->color = color;
                this->specular = specular;
                this->tu1 = tu1;
                this->tv1 = tv1;
                this->tu2 = tu2;
                this->tv2 = tv2;
        }
};

#endif // __VERTEX_H__

---