D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spVertexFormat.hpp

Go to the documentation of this file.

/*
 * Vertex format header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_HWBUFFER_VERTEXFORMAT_H__
#define __SP_HWBUFFER_VERTEXFORMAT_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spMath.hpp"
#include "Base/spMaterialConfigTypes.hpp"

#include <vector>


namespace sp
{
namespace video
{


enum EVertexFormatFlags
{
    VERTEXFORMAT_COORD      = 0x01, 
    VERTEXFORMAT_COLOR      = 0x02, 
    VERTEXFORMAT_NORMAL     = 0x04, 
    VERTEXFORMAT_BINORMAL   = 0x08, 
    VERTEXFORMAT_TANGENT    = 0x10, 
    VERTEXFORMAT_FOGCOORD   = 0x20, 
    VERTEXFORMAT_TEXCOORDS  = 0x40, 
    VERTEXFORMAT_UNIVERSAL  = 0x80, 
};

enum EVertexAttributes
{
    ATTRIBUTE_COORD,
    ATTRIBUTE_COLOR,
    ATTRIBUTE_NORMAL,
    ATTRIBUTE_BINORMAL,
    ATTRIBUTE_TANGENT,
    ATTRIBUTE_FOGCOORD,
    ATTRIBUTE_TEXCOORD0,
    ATTRIBUTE_TEXCOORD1,
    ATTRIBUTE_TEXCOORD2,
    ATTRIBUTE_TEXCOORD3,
    ATTRIBUTE_TEXCOORD4,
    ATTRIBUTE_TEXCOORD5,
    ATTRIBUTE_TEXCOORD6,
    ATTRIBUTE_TEXCOORD7,
    ATTRIBUTE_UNIVERSAL,
};

struct SVertexAttribute
{
    SVertexAttribute() :
        Size                (0              ),
        Offset              (0              ),
        Type                (DATATYPE_FLOAT ),
        hasDefaultSetting   (false          ),
        isReference         (false          )
    {
    }
    SVertexAttribute(
        s32 InitSize, const io::stringc InitName = "", const ERendererDataTypes InitType = DATATYPE_FLOAT,
        bool DefaultSetting = true, bool InitNormalize = false) :
        Size                (InitSize       ),
        Offset              (0              ),
        Type                (InitType       ),
        Name                (InitName       ),
        Normalize           (InitNormalize  ),
        hasDefaultSetting   (DefaultSetting ),
        isReference         (false          )
    {
    }
    ~SVertexAttribute()
    {
    }
    
    /* Members */
    s32 Size;                   
    s32 Offset;                 
    ERendererDataTypes Type;    
    io::stringc Name;           
    bool Normalize;             
    bool hasDefaultSetting;     // !!! CHECK IF WORKS CORRECT !!!
    bool isReference;           
};


class SP_EXPORT VertexFormat
{
    
    public:
        
        virtual ~VertexFormat();
        
        /* === Functions === */
        
        io::stringc getIdentifier() const;
        
        virtual u32 getFormatSize() const;
        
        static s32 getDataTypeSize(const ERendererDataTypes Type);
        
        /* === Inline functions === */
        
        inline s32 getFlags() const
        {
            return Flags_;
        }
        
        inline void setName(const io::stringc &Name)
        {
            Name_ = Name;
        }
        inline io::stringc getName() const
        {
            return Name_;
        }
        
        inline const SVertexAttribute& getCoord() const
        {
            return Coord_;
        }
        inline const SVertexAttribute& getColor() const
        {
            return Color_;
        }
        inline const SVertexAttribute& getNormal() const
        {
            return Normal_;
        }
        inline const SVertexAttribute& getBinormal() const
        {
            return Binormal_;
        }
        inline const SVertexAttribute& getTangent() const
        {
            return Tangent_;
        }
        inline const SVertexAttribute& getFogCoord() const
        {
            return FogCoord_;
        }
        
        inline const std::vector<SVertexAttribute>& getTexCoords() const
        {
            return TexCoords_;
        }
        inline const std::vector<SVertexAttribute>& getUniversals() const
        {
            return Universals_;
        }
        
    protected:
        
        friend class Direct3D11RenderSystem;
        friend class Direct3D11Shader;
        
        /* === Functions === */
        
        VertexFormat();
        VertexFormat(const io::stringc &Name, s32 Flags);
        
        virtual void getFormatSize(u32 &Size) const;
        void addComponentFormatSize(u32 &Size, const SVertexAttribute &Attrib) const;
        
        void constructComponent(
            const EVertexFormatFlags Type, SVertexAttribute &Attrib, s32 &Offset, s32 MinSize, s32 MaxSize
        );
        virtual void constructFormat();
        
        /* === Inline functions === */
        
        inline void addFlag(const EVertexFormatFlags Flag)
        {
            Flags_ |= Flag;
        }
        inline void removeFlag(const EVertexFormatFlags Flag)
        {
            if (Flags_ & Flag)
                Flags_ ^= Flag;
        }
        
        /* === Members === */
        
        s32 Flags_;
        io::stringc Name_;
        
        SVertexAttribute Coord_;
        SVertexAttribute Color_;
        SVertexAttribute Normal_;
        SVertexAttribute Binormal_;
        SVertexAttribute Tangent_;
        SVertexAttribute FogCoord_;
        
        std::vector<SVertexAttribute> TexCoords_;
        std::vector<SVertexAttribute> Universals_;
        
        void* InputLayout_; // Only for Direct3D11
        
};


} // /namespace video

} // /namespace sp


#endif



// ================================================================================