AllVertexTypes.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Types.h"
#include "VectorMath.h"
#include "MathFunc.h"

#include <climits>
#include <cmath>

namespace Eegeo
{
    namespace Rendering
    {
        namespace VertexTypes
        {
            struct TextVertex
            {
                float x,y,z,altitude;
                float u,v,shadow;
            };
            
            inline TextVertex CreateTextVertex(float x, float y, float z, float altitude, float u, float v, float shadow)
            {
                TextVertex vtx;
                vtx.x = x;
                vtx.y = y;
                vtx.z = z;
                vtx.altitude = altitude;
                vtx.u = u;
                vtx.v = v;
                vtx.shadow = shadow;
                return vtx;
            }
            
            struct ScreenTextVertex
            {
                float x,y;
                u16 u,v;
                u8 altColor, pad0, pad1, pad2;
                
                ScreenTextVertex()
                {}
                
                ScreenTextVertex(float x, float y, u16 u, u16 v, u8 altColor)
                : x(x), y(y), u(u), v(v), altColor(altColor), pad0(0), pad1(0), pad2(255)
                {}
            };
            
            struct WorldTextVertex
            {
                float x, y, z;
                u16 u,v;
                u8 altColor, pad0, pad1, pad2;
            };
            
            struct PackedDiffuseVertex
            {
                u16 x,y,z,lightDots;
                u16 u,v;
            };

            struct PackedDiffuseUvLightDotColorVertex
            {
                u16 x,y,z,lightDots;
                u16 u,v;
                Byte r, g, b, a;
            };
            
            struct PackedPositionNormalUvColorVertex
            {
                u16 x,y,z,pad1;
                s8 nx,ny,nz,pad2;
                u16 u,v;
                Byte r, g, b, a;
            };
            
            struct PackedPositionNormalUvVertex
            {
                u16 x,y,z,pad1;
                s8 nx,ny,nz,pad2;
                u16 u,v;
            };
            
            struct PackedTwoTextureVertex
            {
                u16 x,y,z,lightDots;
                u16 u,v;
                u16 u2,v2;
            };
            
            struct PackedStencilShadowVertex
            {
                u16 x,y,z,h;
            };
            
            struct ShortPositionVertex
            {
                u16 x,y,z;
            };
            
            struct DiffuseVertex
            {
                float x,y,z,lightDots;
                float u,v;
            };
            
            
            struct PositionVertex
            {
                float x,y,z;
            };
            
            struct TexturedVertex
            {
                float x,y,z;
                float u,v;
            };
            
            struct ColoredVertex
            {
                float x,y,z;
                float r,g,b,a;
            };
            
            struct TexturedColoredVertex
            {
                float x,y,z;
                float u,v;
                float r,g,b,a;
            };
            
            struct ModelDiffuseVertex
            {
                float x,y,z;
                float nx,ny,nz;
                float u,v;
            };
            
            inline ScreenTextVertex CreateScreenTextVertex(float x, float y, float u, float v, float altColorParam)
            {
                const float uvScale = 65536.f;
                
                u16 su = static_cast<u16>(Math::Clamp(static_cast<int>(u*uvScale), 0, 0xffff));
                u16 sv = static_cast<u16>(Math::Clamp(static_cast<int>(v*uvScale), 0, 0xffff));
                u8 altColor = static_cast<u8>(Math::Clamp(static_cast<int>(altColorParam*256.f), 0, 0xff));
                return ScreenTextVertex(x, y, su, sv, altColor);
            }
            
            inline WorldTextVertex CreateWorldTextVertex(float x, float y, float z, float u, float v, float altColorParam)
            {
                const float uvScale = 65536.f;
                
                WorldTextVertex vtx;
                vtx.x = x;
                vtx.y = y;
                vtx.z = z;
                vtx.u = static_cast<u16>(Math::Clamp(static_cast<int>(u*uvScale), 0, 0xffff));
                vtx.v = static_cast<u16>(Math::Clamp(static_cast<int>(v*uvScale), 0, 0xffff));
                vtx.altColor = static_cast<u8>(Math::Clamp(static_cast<int>(altColorParam*256.f), 0, 0xff));
                vtx.pad0 = 0;
                vtx.pad1 = 0;
                vtx.pad2 = 0;
                return vtx;
            }
            
            inline ColoredVertex CreateColoredVertex(const v3& position, const v4& color)
            {
                ColoredVertex vert;
                vert.x = position.GetX();
                vert.y = position.GetY();
                vert.z = position.GetZ();
                
                vert.r = color.GetX();
                vert.g = color.GetY();
                vert.b = color.GetZ();
                vert.a = color.GetW();
                
                return vert;
            }
            
            inline ColoredVertex CreateColoredVertex(const v3& position, const v3& color)
            {
                ColoredVertex vert = CreateColoredVertex(position, v4(color, 1.f));
                return vert;
            }
            
            inline TexturedColoredVertex CreateTexturedColoredVertex(const v3& position, const v2& uv, const v4& color)
            {
                TexturedColoredVertex vert;
                vert.x = position.GetX();
                vert.y = position.GetY();
                vert.z = position.GetZ();
                
                vert.u = uv.x;
                vert.v = uv.y;
                
                vert.r = color.GetX();
                vert.g = color.GetY();
                vert.b = color.GetZ();
                vert.a = color.GetW();
                
                return vert;

            }
            
            inline PositionVertex CreatePositionVertex(float x, float y, float z)
            {
                PositionVertex vtx;
                vtx.x = x;
                vtx.y = y;
                vtx.z = z;
                return vtx;
            }

            inline PositionVertex CreatePositionVertex(const Eegeo::v3& p)
            {
                return CreatePositionVertex(p.x, p.y, p.z);
            }
            
            inline TexturedVertex CreateTexturedVertex(float x, float y, float z, float u, float v)
            {
                TexturedVertex vtx;
                vtx.x = x;
                vtx.y = y;
                vtx.z = z;
                vtx.u = u;
                vtx.v = v;
                return vtx;
            }
            
            inline TexturedVertex CreateTexturedVertex(const Eegeo::v3& p, const Eegeo::v2& uv)
            {
                return CreateTexturedVertex(p.x, p.y, p.z, uv.x, uv.y);
            }
            
            struct Textured2DVertex
            {
                float x, y, u, v;
            };
            
            inline Textured2DVertex CreateTextured2DVertex(float x, float y, float u, float v)
            {
                Textured2DVertex vtx;
                vtx.x = x;
                vtx.y = y;
                vtx.u = u;
                vtx.v = v;
                return vtx;
            }
            
            inline ModelDiffuseVertex CreateModelDiffuseVertex(const Eegeo::v3& position, const Eegeo::v3& normal, const Eegeo::v2& uv)
            {
                ModelDiffuseVertex vtx;
                vtx.x = position.x;
                vtx.y = position.y;
                vtx.z = position.z;
                vtx.nx = normal.x;
                vtx.ny = normal.y;
                vtx.nz = normal.z;
                vtx.u = uv.x;
                vtx.v = uv.y;
                return vtx;
            }
        }
    }
    
}