genesis-3d_engine/Engine/rendersystem/base/VertexComponent.h

/****************************************************************************
Copyright (c) 2007, Radon Labs GmbH
Copyright (c) 2011-2013,WebJet Business Division,CYOU
 
http://www.genesis-3d.com.cn

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.
****************************************************************************/
#ifndef VERTEXCOMPONENT_H_
#define VERTEXCOMPONENT_H_
#include "core/types.h"
#include "util/string.h"
#include "util/array.h"
#include "core/refcounted.h"
//------------------------------------------------------------------------------
namespace RenderBase
{

class VertexComponent
{
public:
    /// component semantic
    enum SemanticName
    {
        Position = 0,
        Normal,
        Tangent,
        Binormal,
        TexCoord,        
        Color,
        SkinWeights,
        SkinJIndices,
		Size,

        Invalid,
    };



    /// component format
    enum Format
    {
        Float,      //> one-component float, expanded to (float, 0, 0, 1)
        Float2,     //> two-component float, expanded to (float, float, 0, 1)
        Float3,     //> three-component float, expanded to (float, float, float, 1)
        Float4,     //> four-component float
        UByte4,     //> four-component unsigned byte
        Short2,     //> two-component signed short, expanded to (value, value, 0, 1)
        Short4,     //> four-component signed short
        UByte4N,    //> four-component normalized unsigned byte (value / 255.0f)
        Short2N,    //> two-component normalized signed short (value / 32767.0f)
        Short4N,    //> four-component normalized signed short (value / 32767.0f)
		ColorBGRA,	//> color type. for D3D9 fix function support
		ColorRGBA,	//> color type. for opengl fix function support

        // PS3-specific
        Float16,
        Float16_2,
        Float16_3,
        Float16_4,
    };
    
    /// access type hint, this is only relevant on the Wii
    enum AccessType
    {
        None,
        Direct,     //> component has direct value (non-indexed)
        Index8,     //> component is indexed with 8-bit indices           
        Index16,    //> component is indexed with 16-bit indices
        Index32,    //> component is indexed with 32-bit indices
    };
	struct Semantic
	{
		SemanticName name;
		ushort index;
		inline Semantic()
			:name(RenderBase::VertexComponent::Invalid)
			,index(0)
		{
		}
		inline Semantic(SemanticName _name, ushort _index)
			:name(_name)
			,index(_index)
		{
		}

		inline const Semantic& operator = (const Semantic& rhs)
		{
			this->name = rhs.name;
			this->index = rhs.index;
			return *this;
		}

		inline bool operator == (const Semantic& rhs) const
		{
			return (this->name == rhs.name) && (this->index == rhs.index);
		}

		inline bool operator != (const Semantic& rhs) const
		{
			return (this->name != rhs.name) || (this->index != rhs.index);
		}

		inline bool operator > (const Semantic& rhs) const
		{
			return ((int(this->name) << 16) + int(this->index)) > ((int(rhs.name) << 16) + int(rhs.index));
		}

		inline bool operator < (const Semantic& rhs) const
		{
			return ((int(this->name) << 16) + int(this->index)) < ((int(rhs.name) << 16) + int(rhs.index));
		}
	};

    /// default constructor
    VertexComponent();
    /// constructor
    VertexComponent(SemanticName semName, IndexT semIndex, Format format, IndexT streamIndex=0);
    /// get semantic name
    SemanticName GetSemanticName() const;

	const Semantic& GetSemantic() const;
    /// get semantic index
    IndexT GetSemanticIndex() const;
    /// get vertex component format
    Format GetFormat() const;
    /// get stream index
    IndexT GetStreamIndex() const;
    /// get the byte size of the vertex component
    SizeT GetByteSize() const;
    /// get a unique signature of the vertex component
    Util::String GetSignature() const;
    /// get access type
    AccessType GetAccessType() const;
    /// convert string to semantic name
    static SemanticName StringToSemanticName(const Util::String& str);
    /// convert semantic name to string
    static Util::String SemanticNameToString(SemanticName n);
    /// convert string to format
    static Format StringToFormat(const Util::String& str);
    /// convert format to string
    static Util::String FormatToString(Format f);
    /// get the byte offset of this component (only valid when part of a VertexLayout)
    IndexT GetByteOffset() const;
	/// Utility method which returns the count of values in a given type
	static uint GetTypeCount(Format format);
	static SizeT GetByteSize(Format format);
	static int BuildComponentsOffsetAndSize(Util::Array<VertexComponent>& in_out);

protected:
    friend class VertexLayout;

    /// set the vertex byte offset (called from VertexLayoutBase::Setup())
    void SetByteOffset(IndexT offset);

    Semantic semantic;
    Format format;
    AccessType accessType;
    IndexT streamIndex;
    IndexT byteOffset;
};

//------------------------------------------------------------------------------
/**
*/
inline
VertexComponent::VertexComponent() :
    format(Float),
    accessType(Index16),
    streamIndex(0),
    byteOffset(0)
{
    // empty
}

//------------------------------------------------------------------------------
/**
*/
inline
VertexComponent::VertexComponent(SemanticName semName_, IndexT semIndex_, Format format_, IndexT streamIndex_) :
	semantic(semName_, (ushort)semIndex_),
    format(format_),
    accessType(Index16),
    streamIndex(streamIndex_),
    byteOffset(-1)
{
}

//------------------------------------------------------------------------------
/**
*/
inline VertexComponent::SemanticName
VertexComponent::GetSemanticName() const
{
    return this->semantic.name;
}
//------------------------------------------------------------------------------
/**
*/
inline const VertexComponent::Semantic& 
VertexComponent::GetSemantic() const
{
	return semantic;
}
//------------------------------------------------------------------------------
/**
*/
inline VertexComponent::AccessType
VertexComponent::GetAccessType() const
{
    return this->accessType;     
}

//------------------------------------------------------------------------------
/**
*/
inline IndexT
VertexComponent::GetSemanticIndex() const
{
    return this->semantic.index;
}

//------------------------------------------------------------------------------
/**
*/
inline VertexComponent::Format
VertexComponent::GetFormat() const
{
    return this->format;
}

//------------------------------------------------------------------------------
/**
*/
inline IndexT
VertexComponent::GetStreamIndex() const
{
    return this->streamIndex;
}
//------------------------------------------------------------------------------
/**
*/
inline SizeT
	VertexComponent::GetByteSize(Format format)
{
	switch (format)
	{
	case Float:     return 4;
	case Float2:    return 8;
	case Float3:    return 12;
	case Float4:    return 16;
	case UByte4:    return 4;
	case Short2:    return 4;
	case Short4:    return 8;
	case UByte4N:   return 4;
	case Short2N:   return 4;
	case Short4N:   return 8;
	case ColorBGRA: return 4;
	case ColorRGBA: return 4;

		// PS3-specific
	case Float16:   return 2;
	case Float16_2: return 4;
	case Float16_3: return 6;
	case Float16_4: return 8;
	}
	n_error("Can't happen");
	return 0;
}

//------------------------------------------------------------------------------
/**
*/
inline SizeT
VertexComponent::GetByteSize() const
{
   return GetByteSize(this->format);
}

//------------------------------------------------------------------------------
/**
*/
inline Util::String
VertexComponent::SemanticNameToString(SemanticName n)
{
    switch (n)
    {
        case Position:      return "Position";
        case Normal:        return "Normal";
        case Tangent:       return "Tangent";
        case Binormal:      return "Binormal";
        case TexCoord:      return "TexCoord";
        case Color:         return "Color";
        case SkinWeights:   return "SkinWeights";
        case SkinJIndices:  return "SkinJIndices";
		case Size:			return "Size";
        default:
            n_error("VertexComponent::SemanticNameToString(): invalid SemanticName code!");
            return "";
    }
}

//------------------------------------------------------------------------------
/**
*/
inline VertexComponent::SemanticName
VertexComponent::StringToSemanticName(const Util::String& str)
{
    if (str == "Position") return Position;
    else if (str == "Normal") return Normal;
    else if (str == "Tangent") return Tangent;
    else if (str == "Binormal") return Binormal;
    else if (str == "TexCoord") return TexCoord;
    else if (str == "Color") return Color;
    else if (str == "SkinWeights") return SkinWeights;
    else if (str == "SkinJIndices") return SkinJIndices;
	else if (str == "Size")	return Size;
    else
    {
        n_error("VertexComponent::StringToSemanticName(): invalid string '%s'!", str.AsCharPtr());
        return Invalid;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline Util::String
VertexComponent::FormatToString(Format f)
{
    switch (f)
    {
        case Float:     return "Float";
        case Float2:    return "Float2";
        case Float3:    return "Float3";
        case Float4:    return "Float4";
        case UByte4:    return "UByte4";
        case Short2:    return "Short2";
        case Short4:    return "Short4";
        case UByte4N:   return "UByte4N";
        case Short2N:   return "Short2N";
        case Short4N:   return "Short4N";
		case ColorBGRA: return "ColorBGRA";
		case ColorRGBA: return "ColorRGBA";

        // PS3-specific
        case Float16:   return "Float16";
        case Float16_2: return "Float16_2";
        case Float16_3: return "Float16_3";
        case Float16_4: return "Float16_4";

        default:
            n_error("VertexComponent::FormatToString(): invalid Format code!");
            return "";
    }
}

//------------------------------------------------------------------------------
/**
*/
inline VertexComponent::Format
VertexComponent::StringToFormat(const Util::String& str)
{
    if (str == "Float") return Float;
    else if (str == "Float2") return Float2;
    else if (str == "Float3") return Float3;
    else if (str == "Float4") return Float4;
    else if (str == "UByte4") return UByte4;
    else if (str == "Short2") return Short2;
    else if (str == "Short4") return Short4;
    else if (str == "UByte4N") return UByte4N;
    else if (str == "Short2N") return Short2N;
    else if (str == "Short4N") return Short4N;
	else if (str == "ColorBGRA") return ColorBGRA;
	else if (str == "ColorRGBA") return ColorRGBA;
    else if (str == "Float16") return Float16;
    else if (str == "Float16_2") return Float16_2;
    else if (str == "Float16_3") return Float16_3;
    else if (str == "Float16_4") return Float16_4;
    else
    {
        n_error("VertexComponent::StringToFormat(): invalid string '%s'!\n", str.AsCharPtr());
        return Float;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline Util::String
VertexComponent::GetSignature() const
{
    Util::String str;
    switch (this->semantic.name)
    {
        case Position:      str = "pos"; break;
        case Normal:        str = "nrm"; break;
        case Tangent:       str = "tan"; break;
        case Binormal:      str = "bin"; break;
        case TexCoord:      str = "tex"; break;
        case Color:         str = "clr"; break;
        case SkinWeights:   str = "skw"; break;
        case SkinJIndices:  str = "sji"; break;
		case Size:			str = "sze"; break;
        default:
            n_error("can't happen!");
            break;
    }
    str.AppendInt(GetSemanticIndex());    
    str.Append(FormatToString(this->format));
    return str;
}

//------------------------------------------------------------------------------
/**
*/
inline void
VertexComponent::SetByteOffset(IndexT offset)
{
    this->byteOffset = offset;
}

//------------------------------------------------------------------------------
/**
*/
inline IndexT
VertexComponent::GetByteOffset() const
{
    return this->byteOffset;
}

//------------------------------------------------------------------------------
/**
*/
inline uint
	VertexComponent::GetTypeCount(Format format)
{
	switch (format)
	{
	case Float:	
		return 1;
	case Float2:
		return 2;
	case Float3:
		return 3;
	case Float4:
		return 4;
	case UByte4:
		return 4;
	case Short2:
		return 2;
	case Short4:
		return 4;
	case UByte4N:
		return 4;
	case Short2N:
		return 2;
	case Short4N:
		return 4;
	case ColorBGRA:
	case ColorRGBA:
		return 4;
	}

	n_error("Invalid type!");

	return 0;
}

} // namespace RenderBase
//------------------------------------------------------------------------------

#endif