#ifndef IMESH_H
#define IMESH_H

#ifdef _WIN32
#pragma once
#endif

#include "interface.h"
#include "imaterial.h"
#include <float.h>
#include <string.h>
#include "dbg.h"
#include "meshutils.h"

#include "imaterialsystem.h" 

#ifdef OSX
#endif

class IMaterial;
class CMeshBuilder;
class IMaterialVar;
typedef uint64 VertexFormat_t;
struct ShaderStencilState_t;


#ifdef _DEBUG
#endif


enum
{
	VERTEX_MAX_TEXTURE_COORDINATES = 8,
	BONE_MATRIX_INDEX_INVALID = 255
};

enum
{
	INDEX_BUFFER_SIZE = 32768,
	DYNAMIC_VERTEX_BUFFER_MEMORY = (1024 + 512) * 1024,
	DYNAMIC_VERTEX_BUFFER_MEMORY_SMALL = 384 * 1024,        
};

enum WriteCombineOrdering_t
{
	MB_FIELD_NONE = -1,
	MB_FIELD_POSITION = 0,
	MB_FIELD_BONE_WEIGHTS,
	MB_FIELD_BONE_INDEX,
	MB_FIELD_NORMAL,
	MB_FIELD_COLOR,
	MB_FIELD_SPECULAR,
	MB_FIELD_TEXCOORD_FIRST,
	MB_FIELD_TEXCOORD_LAST = MB_FIELD_TEXCOORD_FIRST + VERTEX_MAX_TEXTURE_COORDINATES - 1,
	MB_FIELD_TANGENT_S,
	MB_FIELD_TANGENT_T,
	MB_FIELD_USERDATA,
};

#define MB_FIELD_TEXCOORD( nStage ) ( MB_FIELD_TEXCOORD_FIRST + ( nStage ) )

struct VertexDesc_t
{
	int	m_VertexSize_Position;
	int m_VertexSize_BoneWeight;
	int m_VertexSize_BoneMatrixIndex;
	int	m_VertexSize_Normal;
	int	m_VertexSize_Color;
	int	m_VertexSize_Specular;
	int m_VertexSize_TexCoord[VERTEX_MAX_TEXTURE_COORDINATES];
	int m_VertexSize_TangentS;
	int m_VertexSize_TangentT;
	int m_VertexSize_Wrinkle;

	int m_VertexSize_UserData;

	int m_ActualVertexSize;	          
	VertexCompressionType_t m_CompressionType;

	int m_NumBoneWeights;

	float* m_pPosition;

	float* m_pBoneWeight;

#ifndef NEW_SKINNING
	unsigned char* m_pBoneMatrixIndex;
#else
	float* m_pBoneMatrixIndex;
#endif

	float* m_pNormal;

	unsigned char* m_pColor;
	unsigned char* m_pSpecular;
	float* m_pTexCoord[VERTEX_MAX_TEXTURE_COORDINATES];

	float* m_pTangentS;
	float* m_pTangentT;

	float* m_pWrinkle;

	float* m_pUserData;

	int	m_nFirstVertex;

	unsigned int	m_nOffset;

#ifdef DEBUG_WRITE_COMBINE
	int m_nLastWrittenField;
	unsigned char* m_pLastWrittenAddress;
#endif
};

struct IndexDesc_t
{
	unsigned short* m_pIndices;

	unsigned int	m_nOffset;

	unsigned int	m_nFirstIndex;

	unsigned int	m_nIndexSize;
};


struct MeshDesc_t : public VertexDesc_t, public IndexDesc_t
{
};


struct ModelVertexDX8_t
{
	Vector			m_vecPosition;
	Vector			m_vecNormal;
	Vector2D		m_vecTexCoord;
	Vector4D		m_vecUserData;
};

struct QuadTessVertex_t
{
	Vector4D	m_vTangent;		        
	Vector4D	m_vUV01;		           
	Vector4D	m_vUV23;		           
};

struct MeshBoneRemap_t     
{
	DECLARE_BYTESWAP_DATADESC();
	int m_nActualBoneIndex;
	int m_nSrcBoneIndex;
};

struct MeshInstanceData_t
{
	int						m_nIndexOffset;
	int						m_nIndexCount;
	int						m_nBoneCount;
	MeshBoneRemap_t* m_pBoneRemap;		            
	matrix3x4_t* m_pPoseToWorld;	                
	const ITexture* m_pEnvCubemap;
	MaterialLightingState_t* m_pLightingState;
	MaterialPrimitiveType_t m_nPrimType;
	const IVertexBuffer* m_pVertexBuffer;
	int						m_nVertexOffsetInBytes;
	const IIndexBuffer* m_pIndexBuffer;
	const IVertexBuffer* m_pColorBuffer;
	int						m_nColorVertexOffsetInBytes;
	ShaderStencilState_t* m_pStencilState;
	Vector4D				m_DiffuseModulation;
};

struct MeshBuffersAllocationSettings_t
{
	uint32 m_uiIbUsageFlags;
};

inline float* OffsetFloatPointer(float* pBufferPointer, int nVertexCount, int vertexSize)
{
	return reinterpret_cast<float*>(
		reinterpret_cast<unsigned char*>(pBufferPointer) +
		nVertexCount * vertexSize);
}

inline const float* OffsetFloatPointer(const float* pBufferPointer, int nVertexCount, int vertexSize)
{
	return reinterpret_cast<const float*>(
		reinterpret_cast<unsigned char const*>(pBufferPointer) +
		nVertexCount * vertexSize);
}

inline void IncrementFloatPointer(float*& pBufferPointer, int vertexSize)
{
	pBufferPointer = reinterpret_cast<float*>(reinterpret_cast<unsigned char*>(pBufferPointer) + vertexSize);
}


class CPrimList
{
public:
	CPrimList();
	CPrimList(int nFirstIndex, int nIndexCount);

	int			m_FirstIndex;
	int			m_NumIndices;
};

inline CPrimList::CPrimList()
{
}

inline CPrimList::CPrimList(int nFirstIndex, int nIndexCount)
{
	m_FirstIndex = nFirstIndex;
	m_NumIndices = nIndexCount;
}

abstract_class IVertexBuffer
{
public:
	virtual int VertexCount() const = 0;
	virtual VertexFormat_t GetVertexFormat() const = 0;

	virtual bool IsDynamic() const = 0;

	virtual void BeginCastBuffer(VertexFormat_t format) = 0;
	virtual void EndCastBuffer() = 0;

	virtual int GetRoomRemaining() const = 0;

	virtual bool Lock(int nVertexCount, bool bAppend, VertexDesc_t& desc) = 0;
	virtual void Unlock(int nVertexCount, VertexDesc_t& desc) = 0;

	virtual void Spew(int nVertexCount, const VertexDesc_t& desc) = 0;

	virtual void ValidateData(int nVertexCount, const VertexDesc_t& desc) = 0;
};

abstract_class IIndexBuffer
{
public:
	virtual int IndexCount() const = 0;
	virtual MaterialIndexFormat_t IndexFormat() const = 0;

	virtual bool IsDynamic() const = 0;

	virtual void BeginCastBuffer(MaterialIndexFormat_t format) = 0;
	virtual void EndCastBuffer() = 0;

	virtual int GetRoomRemaining() const = 0;

	virtual bool Lock(int nMaxIndexCount, bool bAppend, IndexDesc_t& desc) = 0;
	virtual void Unlock(int nWrittenIndexCount, IndexDesc_t& desc) = 0;

	virtual void ModifyBegin(bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc) = 0;
	virtual void ModifyEnd(IndexDesc_t& desc) = 0;

	virtual void Spew(int nIndexCount, const IndexDesc_t& desc) = 0;

	virtual void ValidateData(int nIndexCount, const IndexDesc_t& desc) = 0;

	virtual IMesh* GetMesh() = 0;
};

abstract_class ICachedPerFrameMeshData
{
public:
	virtual void Free() = 0;
};

abstract_class IMesh : public IVertexBuffer, public IIndexBuffer
{
public:
	virtual void SetPrimitiveType(MaterialPrimitiveType_t type) = 0;

	virtual void Draw(int firstIndex = -1, int numIndices = 0) = 0;

	virtual void SetColorMesh(IMesh* pColorMesh, int nVertexOffset) = 0;

	virtual void Draw(CPrimList* pLists, int nLists) = 0;

	virtual void CopyToMeshBuilder(
		int iStartVert,		    
		int nVerts,
		int iStartIndex,	    
		int nIndices,
		int indexOffset,	      
		CMeshBuilder& builder) = 0;

	virtual void Spew(int numVerts, int numIndices, const MeshDesc_t& desc) = 0;

	virtual void ValidateData(int numVerts, int numIndices, const MeshDesc_t& desc) = 0;

	virtual void LockMesh(int numVerts, int numIndices, MeshDesc_t& desc, MeshBuffersAllocationSettings_t* pSettings) = 0;
	virtual void ModifyBegin(int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc) = 0;
	virtual void ModifyEnd(MeshDesc_t& desc) = 0;
	virtual void UnlockMesh(int numVerts, int numIndices, MeshDesc_t& desc) = 0;

	virtual void ModifyBeginEx(bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc) = 0;

	virtual void SetFlexMesh(IMesh* pMesh, int nVertexOffset) = 0;

	virtual void DisableFlexMesh() = 0;

	virtual void MarkAsDrawn() = 0;

	virtual void DrawModulated(const Vector4D& vecDiffuseModulation, int firstIndex = -1, int numIndices = 0) = 0;

	virtual unsigned int ComputeMemoryUsed() = 0;

	virtual void* AccessRawHardwareDataStream(uint8 nRawStreamIndex, uint32 numBytes, uint32 uiFlags, void* pvContext) = 0;

	virtual ICachedPerFrameMeshData* GetCachedPerFrameMeshData() = 0;
	virtual void ReconstructFromCachedPerFrameMeshData(ICachedPerFrameMeshData* pData) = 0;
};


#include "meshreader.h"

#define INVALID_BUFFER_OFFSET 0xFFFFFFFFUL

#define VTX_HAVEPOS 1
#define VTX_HAVENORMAL 2
#define VTX_HAVECOLOR 4
#define VTX_HAVEALL ( VTX_HAVEPOS | VTX_HAVENORMAL | VTX_HAVECOLOR )


class CVertexBuilder : private VertexDesc_t
{
public:
	CVertexBuilder();
	CVertexBuilder(IVertexBuffer* pVertexBuffer, VertexFormat_t fmt = 0);
	~CVertexBuilder();

	bool Lock(int nMaxIndexCount, bool bAppend = false);
	void Unlock();

	void SpewData();

	int GetRoomRemaining() const;

	void Bind(IMatRenderContext* pContext, int nStreamID, VertexFormat_t usage = 0);

	int Offset() const;

	void SetCompressionType(VertexCompressionType_t compressionType);
	void ValidateCompressionType();

	void Begin(IVertexBuffer* pVertexBuffer, int nVertexCount, int* nFirstVertex);
	void Begin(IVertexBuffer* pVertexBuffer, int nVertexCount);

	void End(bool bSpewData = false);

	void BeginModify(IVertexBuffer* pVertexBuffer, int nFirstVertex = 0, int nVertexCount = -1);
	void EndModify(bool bSpewData = false);

	int VertexCount() const;

	int TotalVertexCount() const;

	void Reset();

	int VertexSize() { return m_ActualVertexSize; }

	int TextureCoordinateSize(int nTexCoordNumber) { return m_VertexSize_TexCoord[nTexCoordNumber]; }

	void* BaseVertexData();

	void SelectVertex(int idx);

	void AdvanceVertex(void);
	template<int nFlags, int nNumTexCoords> void AdvanceVertexF(void);
	void AdvanceVertices(int nVerts);

	int GetCurrentVertex() const;
	int GetFirstVertex() const;

	const float* Position() const;

	const float* Normal() const;

	unsigned int Color() const;

	unsigned char* Specular() const;

	const float* TexCoord(int stage) const;

	const float* TangentS() const;
	const float* TangentT() const;

	const float* BoneWeight() const;
	float Wrinkle() const;

	int NumBoneWeights() const;
#ifndef NEW_SKINNING
	unsigned char* BoneMatrix() const;
#else
	float* BoneMatrix() const;
#endif

	void Position3f(float x, float y, float z);
	void Position3fv(const float* v);

	void Normal3f(float nx, float ny, float nz);
	void Normal3fv(const float* n);
	void NormalDelta3fv(const float* n);
	void NormalDelta3f(float nx, float ny, float nz);
	template <VertexCompressionType_t T> void CompressedNormal3f(float nx, float ny, float nz);
	template <VertexCompressionType_t T> void CompressedNormal3fv(const float* n);

	void Color3f(float r, float g, float b);
	void Color3fv(const float* rgb);
	void Color4f(float r, float g, float b, float a);
	void Color4fv(const float* rgba);

	void Color3ub(unsigned char r, unsigned char g, unsigned char b);
	void Color3ubv(unsigned char const* rgb);
	void Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
	void Color4ubv(unsigned char const* rgba);
	void Color4Packed(int packedColor);
	int PackColor4(unsigned char r, unsigned char g, unsigned char b, unsigned char a);

	void Specular3f(float r, float g, float b);
	void Specular3fv(const float* rgb);
	void Specular4f(float r, float g, float b, float a);
	void Specular4fv(const float* rgba);

	void Specular3ub(unsigned char r, unsigned char g, unsigned char b);
	void Specular3ubv(unsigned char const* c);
	void Specular4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
	void Specular4ubv(unsigned char const* c);

	void TexCoord1f(int stage, float s);
	void TexCoord2f(int stage, float s, float t);
	void TexCoord2fv(int stage, const float* st);
	void TexCoord3f(int stage, float s, float t, float u);
	void TexCoord3fv(int stage, const float* stu);
	void TexCoord4f(int stage, float s, float t, float u, float w);
	void TexCoord4fv(int stage, const float* stuv);

	void TexCoordSubRect2f(int stage, float s, float t, float offsetS, float offsetT, float scaleS, float scaleT);
	void TexCoordSubRect2fv(int stage, const float* st, const float* offset, const float* scale);

	void TangentS3f(float sx, float sy, float sz);
	void TangentS3fv(const float* s);

	void TangentT3f(float tx, float ty, float tz);
	void TangentT3fv(const float* t);

	void Wrinkle1f(float flWrinkle);

	void BoneWeight(int idx, float weight);
	void BoneWeights2(float weight1, float weight2);

	template <VertexCompressionType_t T> void CompressedBoneWeight3fv(const float* pWeights);

	void BoneMatrix(int idx, int matrixIndex);
	void BoneMatrices4(int matrixIdx0, int matrixIdx1, int matrixIdx2, int matrixIdx3);

	void UserData(const float* pData);
	template <VertexCompressionType_t T> void CompressedUserData(const float* pData);

	void FastVertex(const ModelVertexDX8_t& vertex);
	void FastVertexSSE(const ModelVertexDX8_t& vertex);
	void FastQuadVertexSSE(const QuadTessVertex_t& vertex);

	void FastAdvanceNVertices(int n);

#if defined( _X360 )
	void VertexDX8ToX360(const ModelVertexDX8_t& vertex);
#endif

	void AttachBegin(IMesh* pMesh, int nMaxVertexCount, const MeshDesc_t& desc);
	void AttachEnd();
	void AttachBeginModify(IMesh* pMesh, int nFirstVertex, int nVertexCount, const MeshDesc_t& desc);
	void AttachEndModify();

private:
	IVertexBuffer* m_pVertexBuffer;

	bool m_bModify;

	int m_nMaxVertexCount;

	int m_nVertexCount;

	mutable int m_nCurrentVertex;

	mutable float* m_pCurrPosition;
	mutable float* m_pCurrNormal;
	mutable unsigned char* m_pCurrColor;
	mutable float* m_pCurrTexCoord[VERTEX_MAX_TEXTURE_COORDINATES];

	int m_nTotalVertexCount;

	unsigned int m_nBufferOffset;
	unsigned int m_nBufferFirstVertex;

#if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
	bool m_bWrittenNormal : 1;
	bool m_bWrittenUserData : 1;
#endif

	friend class CMeshBuilder;
};


inline CVertexBuilder::CVertexBuilder()
{
	m_pVertexBuffer = NULL;
	m_nBufferOffset = INVALID_BUFFER_OFFSET;
	m_nBufferFirstVertex = 0;
	m_nVertexCount = 0;
	m_nCurrentVertex = 0;
	m_nMaxVertexCount = 0;
	m_nTotalVertexCount = 0;
	m_CompressionType = VERTEX_COMPRESSION_INVALID;

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	m_bModify = false;
#endif
}

inline CVertexBuilder::CVertexBuilder(IVertexBuffer* pVertexBuffer, VertexFormat_t fmt)
{
	m_pVertexBuffer = pVertexBuffer;
	m_nBufferOffset = INVALID_BUFFER_OFFSET;
	m_nBufferFirstVertex = 0;
	m_nVertexCount = 0;
	m_nCurrentVertex = 0;
	m_nMaxVertexCount = 0;
	m_nTotalVertexCount = 0;
	m_CompressionType = VERTEX_COMPRESSION_INVALID;

	if (m_pVertexBuffer->IsDynamic())
	{
		m_pVertexBuffer->BeginCastBuffer(fmt);
	}
	else
	{
		Assert(m_pVertexBuffer->GetVertexFormat() == fmt);
	}

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	m_bModify = false;
#endif
}

inline CVertexBuilder::~CVertexBuilder()
{
	if (m_pVertexBuffer && m_pVertexBuffer->IsDynamic())
	{
		m_pVertexBuffer->EndCastBuffer();
	}
}

inline bool CVertexBuilder::Lock(int nMaxVertexCount, bool bAppend)
{
	Assert(m_pVertexBuffer);
	m_bModify = false;
	m_nMaxVertexCount = nMaxVertexCount;
	bool bFirstLock = (m_nBufferOffset == INVALID_BUFFER_OFFSET);
	if (bFirstLock)
	{
		bAppend = false;
	}
	if (!bAppend)
	{
		m_nTotalVertexCount = 0;
	}

	if (!m_pVertexBuffer->Lock(m_nMaxVertexCount, bAppend, *this))
	{
		m_nMaxVertexCount = 0;
		return false;
	}

	Reset();

	if (bFirstLock)
	{
		m_nBufferOffset = m_nOffset;
		m_nBufferFirstVertex = m_nFirstVertex;
	}

	return true;
}

inline void CVertexBuilder::Unlock()
{
	Assert(!m_bModify && m_pVertexBuffer);

#ifdef _DEBUG
	m_pVertexBuffer->ValidateData(m_nVertexCount, *this);
#endif

	m_pVertexBuffer->Unlock(m_nVertexCount, *this);
	m_nTotalVertexCount += m_nVertexCount;

	m_nMaxVertexCount = 0;

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	memset(static_cast<VertexDesc_t*>(this), 0, sizeof(VertexDesc_t));
#endif
}

inline void CVertexBuilder::SpewData()
{
	m_pVertexBuffer->Spew(m_nVertexCount, *this);
}


inline void CVertexBuilder::Bind(IMatRenderContext* pContext, int nStreamID, VertexFormat_t usage)
{
	if (m_pVertexBuffer && (m_nBufferOffset != INVALID_BUFFER_OFFSET))
	{
		pContext->BindVertexBuffer(nStreamID, m_pVertexBuffer, m_nBufferOffset,
			m_nFirstVertex, m_nTotalVertexCount, usage ? usage : m_pVertexBuffer->GetVertexFormat());
	}
	else
	{
		pContext->BindVertexBuffer(nStreamID, NULL, 0, 0, 0, 0);
	}
}


inline int CVertexBuilder::Offset() const
{
	return m_nBufferOffset;
}

inline int CVertexBuilder::GetFirstVertex() const
{
	return m_nBufferFirstVertex;
}

inline void CVertexBuilder::SetCompressionType(VertexCompressionType_t compressionType)
{
	m_CompressionType = compressionType;
}

inline void CVertexBuilder::ValidateCompressionType()
{
#ifdef _DEBUG
	VertexCompressionType_t vbCompressionType = CompressionType(m_pVertexBuffer->GetVertexFormat());
	if (vbCompressionType != VERTEX_COMPRESSION_NONE)
	{
		Assert(m_CompressionType == vbCompressionType);
		if (m_CompressionType != vbCompressionType)
		{
			Warning("ERROR: CVertexBuilder::SetCompressionType() must be called to specify the same vertex compression type (%s) as the vertex buffer being modified."
				"Junk vertices will be rendered, or there will be a crash in CVertexBuilder!\n",
				vbCompressionType == VERTEX_COMPRESSION_ON ? "VERTEX_COMPRESSION_ON" : "VERTEX_COMPRESSION_NONE");
		}
		Assert(!m_pVertexBuffer->IsDynamic());
	}
#endif
}

inline void CVertexBuilder::Begin(IVertexBuffer* pVertexBuffer, int nVertexCount)
{
	Assert(pVertexBuffer && (!m_pVertexBuffer));

	m_pVertexBuffer = pVertexBuffer;
	m_bModify = false;

	m_nMaxVertexCount = nVertexCount;
	m_nVertexCount = 0;

	ValidateCompressionType();

	m_pVertexBuffer->Lock(m_nMaxVertexCount, false, *this);

	Reset();
}


inline void CVertexBuilder::End(bool bSpewData)
{
	Assert(!m_bModify);

	if (bSpewData)
	{
		m_pVertexBuffer->Spew(m_nVertexCount, *this);
	}

#ifdef _DEBUG
	m_pVertexBuffer->ValidateData(m_nVertexCount, *this);
#endif

	m_pVertexBuffer->Unlock(m_nVertexCount, *this);

	m_pVertexBuffer = 0;
	m_nMaxVertexCount = 0;

	m_CompressionType = VERTEX_COMPRESSION_INVALID;

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	memset(static_cast<VertexDesc_t*>(this), 0, sizeof(VertexDesc_t));
#endif
}


inline void CVertexBuilder::AttachBegin(IMesh* pMesh, int nMaxVertexCount, const MeshDesc_t& desc)
{
	m_pVertexBuffer = pMesh;
	memcpy(static_cast<VertexDesc_t*>(this), static_cast<const VertexDesc_t*>(&desc), sizeof(VertexDesc_t));
	m_nMaxVertexCount = nMaxVertexCount;
	m_NumBoneWeights = m_NumBoneWeights == 0 ? 0 : 2;	    
	m_nVertexCount = 0;
	m_bModify = false;

	ValidateCompressionType();

	if (m_nBufferOffset == INVALID_BUFFER_OFFSET)
	{
		m_nTotalVertexCount = 0;
		m_nBufferOffset = static_cast<const VertexDesc_t*>(&desc)->m_nOffset;
		m_nBufferFirstVertex = desc.m_nFirstVertex;
	}
}

inline void CVertexBuilder::AttachEnd()
{
	Assert(!m_bModify);

	m_nMaxVertexCount = 0;
	m_pVertexBuffer = NULL;

	m_CompressionType = VERTEX_COMPRESSION_INVALID;

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	memset(static_cast<VertexDesc_t*>(this), 0, sizeof(VertexDesc_t));
#endif
}

inline void CVertexBuilder::AttachBeginModify(IMesh* pMesh, int nFirstVertex, int nVertexCount, const MeshDesc_t& desc)
{
	Assert(pMesh && (!m_pVertexBuffer));

	m_pVertexBuffer = pMesh;
	memcpy(static_cast<VertexDesc_t*>(this), static_cast<const VertexDesc_t*>(&desc), sizeof(VertexDesc_t));
	m_nMaxVertexCount = m_nVertexCount = nVertexCount;
	m_NumBoneWeights = m_NumBoneWeights == 0 ? 0 : 2;	    
	m_bModify = true;

	ValidateCompressionType();
}

inline void CVertexBuilder::AttachEndModify()
{
	Assert(m_pVertexBuffer);
	Assert(m_bModify);	     

	m_pVertexBuffer = 0;
	m_nMaxVertexCount = 0;

	m_CompressionType = VERTEX_COMPRESSION_INVALID;

#ifdef _DEBUG
	m_pCurrPosition = NULL;
	m_pCurrNormal = NULL;
	m_pCurrColor = NULL;
	memset(m_pCurrTexCoord, 0, sizeof(m_pCurrTexCoord));
	memset(static_cast<VertexDesc_t*>(this), 0, sizeof(VertexDesc_t));
#endif
}


inline unsigned char* FindMinAddress(void* pAddress1, void* pAddress2, int nAddress2Size)
{
	if (nAddress2Size == 0)
		return (unsigned char*)pAddress1;
	if (!pAddress1)
		return (unsigned char*)pAddress2;
	return (pAddress1 < pAddress2) ? (unsigned char*)pAddress1 : (unsigned char*)pAddress2;
}

inline void CVertexBuilder::Reset()
{
	m_nCurrentVertex = 0;

	m_pCurrPosition = m_pPosition;
	m_pCurrNormal = m_pNormal;
	for (size_t i = 0; i < NELEMS(m_pCurrTexCoord); i++)
	{
		m_pCurrTexCoord[i] = m_pTexCoord[i];
	}
	m_pCurrColor = m_pColor;

#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif

#ifdef DEBUG_WRITE_COMBINE
	m_nLastWrittenField = MB_FIELD_NONE;
	m_pLastWrittenAddress = NULL;
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pPosition, m_VertexSize_Position);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pBoneWeight, m_VertexSize_BoneWeight);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pBoneMatrixIndex, m_VertexSize_BoneMatrixIndex);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pNormal, m_VertexSize_Normal);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pColor, m_VertexSize_Color);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pSpecular, m_VertexSize_Specular);
	for (int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i)
	{
		m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pTexCoord[i], m_VertexSize_TexCoord[i]);
	}
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pTangentS, m_VertexSize_TangentS);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pTangentT, m_VertexSize_TangentT);
	m_pLastWrittenAddress = FindMinAddress(m_pLastWrittenAddress, m_pUserData, m_VertexSize_UserData);
#endif
}


inline int CVertexBuilder::VertexCount() const
{
	return m_nVertexCount;
}


inline int CVertexBuilder::TotalVertexCount() const
{
	return m_nTotalVertexCount;
}


inline void* CVertexBuilder::BaseVertexData()
{
	Assert(m_pPosition);
	return m_pPosition;
}


inline void CVertexBuilder::SelectVertex(int nIndex)
{
	Assert((nIndex >= 0) && (nIndex < m_nMaxVertexCount));
	m_nCurrentVertex = nIndex;

	m_pCurrPosition = OffsetFloatPointer(m_pPosition, m_nCurrentVertex, m_VertexSize_Position);
	m_pCurrNormal = OffsetFloatPointer(m_pNormal, m_nCurrentVertex, m_VertexSize_Normal);

	COMPILE_TIME_ASSERT(VERTEX_MAX_TEXTURE_COORDINATES == 8);
	m_pCurrTexCoord[0] = OffsetFloatPointer(m_pTexCoord[0], m_nCurrentVertex, m_VertexSize_TexCoord[0]);
	m_pCurrTexCoord[1] = OffsetFloatPointer(m_pTexCoord[1], m_nCurrentVertex, m_VertexSize_TexCoord[1]);
	m_pCurrTexCoord[2] = OffsetFloatPointer(m_pTexCoord[2], m_nCurrentVertex, m_VertexSize_TexCoord[2]);
	m_pCurrTexCoord[3] = OffsetFloatPointer(m_pTexCoord[3], m_nCurrentVertex, m_VertexSize_TexCoord[3]);
	m_pCurrTexCoord[4] = OffsetFloatPointer(m_pTexCoord[4], m_nCurrentVertex, m_VertexSize_TexCoord[4]);
	m_pCurrTexCoord[5] = OffsetFloatPointer(m_pTexCoord[5], m_nCurrentVertex, m_VertexSize_TexCoord[5]);
	m_pCurrTexCoord[6] = OffsetFloatPointer(m_pTexCoord[6], m_nCurrentVertex, m_VertexSize_TexCoord[6]);
	m_pCurrTexCoord[7] = OffsetFloatPointer(m_pTexCoord[7], m_nCurrentVertex, m_VertexSize_TexCoord[7]);
	m_pCurrColor = m_pColor + m_nCurrentVertex * m_VertexSize_Color;

#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}


template<int nFlags, int nNumTexCoords> FORCEINLINE void CVertexBuilder::AdvanceVertexF()
{
	if (++m_nCurrentVertex > m_nVertexCount)
	{
		m_nVertexCount = m_nCurrentVertex;
	}

	if (nFlags & VTX_HAVEPOS)
		IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position);
	if (nFlags & VTX_HAVENORMAL)
		IncrementFloatPointer(m_pCurrNormal, m_VertexSize_Normal);
	if (nFlags & VTX_HAVECOLOR)
		m_pCurrColor += m_VertexSize_Color;

	COMPILE_TIME_ASSERT(VERTEX_MAX_TEXTURE_COORDINATES == 8);
	if (nNumTexCoords > 0)
		IncrementFloatPointer(m_pCurrTexCoord[0], m_VertexSize_TexCoord[0]);
	if (nNumTexCoords > 1)
		IncrementFloatPointer(m_pCurrTexCoord[1], m_VertexSize_TexCoord[1]);
	if (nNumTexCoords > 2)
		IncrementFloatPointer(m_pCurrTexCoord[2], m_VertexSize_TexCoord[2]);
	if (nNumTexCoords > 3)
		IncrementFloatPointer(m_pCurrTexCoord[3], m_VertexSize_TexCoord[3]);
	if (nNumTexCoords > 4)
		IncrementFloatPointer(m_pCurrTexCoord[4], m_VertexSize_TexCoord[4]);
	if (nNumTexCoords > 5)
		IncrementFloatPointer(m_pCurrTexCoord[5], m_VertexSize_TexCoord[5]);
	if (nNumTexCoords > 6)
		IncrementFloatPointer(m_pCurrTexCoord[6], m_VertexSize_TexCoord[6]);
	if (nNumTexCoords > 7)
		IncrementFloatPointer(m_pCurrTexCoord[7], m_VertexSize_TexCoord[7]);

#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}

inline void CVertexBuilder::AdvanceVertex()
{
	AdvanceVertexF<VTX_HAVEALL, 8>();
}


inline void CVertexBuilder::AdvanceVertices(int nVerts)
{
	m_nCurrentVertex += nVerts;
	if (m_nCurrentVertex > m_nVertexCount)
	{
		m_nVertexCount = m_nCurrentVertex;
	}

	IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position * nVerts);
	IncrementFloatPointer(m_pCurrNormal, m_VertexSize_Normal * nVerts);

	COMPILE_TIME_ASSERT(VERTEX_MAX_TEXTURE_COORDINATES == 8);
	IncrementFloatPointer(m_pCurrTexCoord[0], m_VertexSize_TexCoord[0] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[1], m_VertexSize_TexCoord[1] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[2], m_VertexSize_TexCoord[2] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[3], m_VertexSize_TexCoord[3] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[4], m_VertexSize_TexCoord[4] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[5], m_VertexSize_TexCoord[5] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[6], m_VertexSize_TexCoord[6] * nVerts);
	IncrementFloatPointer(m_pCurrTexCoord[7], m_VertexSize_TexCoord[7] * nVerts);
	m_pCurrColor += m_VertexSize_Color * nVerts;

#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}


inline void CVertexBuilder::FastAdvanceNVertices(int n)
{
	m_nCurrentVertex += n;
	m_nVertexCount = m_nCurrentVertex;
}

inline void CVertexBuilder::FastVertex(const ModelVertexDX8_t& vertex)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);       
	Assert(m_nCurrentVertex < m_nMaxVertexCount);

#if defined( _WIN32 ) && !defined( _X360 )
	const void* pRead = &vertex;
	void* pCurrPos = m_pCurrPosition;
	__asm
	{
		mov esi, pRead
		mov edi, pCurrPos

		movq mm0, [esi + 0]
		movq mm1, [esi + 8]
		movq mm2, [esi + 16]
		movq mm3, [esi + 24]
		movq mm4, [esi + 32]
		movq mm5, [esi + 40]

		movntq[edi + 0], mm0
		movntq[edi + 8], mm1
		movntq[edi + 16], mm2
		movntq[edi + 24], mm3
		movntq[edi + 32], mm4
		movntq[edi + 40], mm5

		emms
	}
#elif defined(GNUC)
	const void* pRead = &vertex;
	void* pCurrPos = m_pCurrPosition;
	__asm__ __volatile__(
		"movq (%0), %%mm0\n"
		"movq 8(%0), %%mm1\n"
		"movq 16(%0), %%mm2\n"
		"movq 24(%0), %%mm3\n"
		"movq 32(%0), %%mm4\n"
		"movq 40(%0), %%mm5\n"
		"movq 48(%0), %%mm6\n"
		"movq 56(%0), %%mm7\n"
		"movntq %%mm0, (%1)\n"
		"movntq %%mm1, 8(%1)\n"
		"movntq %%mm2, 16(%1)\n"
		"movntq %%mm3, 24(%1)\n"
		"movntq %%mm4, 32(%1)\n"
		"movntq %%mm5, 40(%1)\n"
		"movntq %%mm6, 48(%1)\n"
		"movntq %%mm7, 56(%1)\n"
		"emms\n"
		:: "r" (pRead), "r" (pCurrPos) : "memory");
#else
	Error("Implement CMeshBuilder::FastVertex(dx8)");
#endif

	IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position);
#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}

inline void CVertexBuilder::FastVertexSSE(const ModelVertexDX8_t& vertex)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);       
	Assert(m_nCurrentVertex < m_nMaxVertexCount);

#if defined( _WIN32 ) && !defined( _X360 )
	const void* pRead = &vertex;
	void* pCurrPos = m_pCurrPosition;
	__asm
	{
		mov esi, pRead
		mov edi, pCurrPos

		movaps xmm0, [esi + 0]
		movaps xmm1, [esi + 16]
		movaps xmm2, [esi + 32]

		movntps[edi + 0], xmm0
		movntps[edi + 16], xmm1
		movntps[edi + 32], xmm2
	}
#elif defined(GNUC)
	const void* pRead = &vertex;
	void* pCurrPos = m_pCurrPosition;
	__asm__ __volatile__(
		"movaps (%0), %%xmm0\n"
		"movaps 16(%0), %%xmm1\n"
		"movaps 32(%0), %%xmm2\n"
		"movaps 48(%0), %%xmm3\n"
		"movntps %%xmm0, (%1)\n"
		"movntps %%xmm1, 16(%1)\n"
		"movntps %%xmm2, 32(%1)\n"
		"movntps %%xmm3, 48(%1)\n"
		:: "r" (pRead), "r" (pCurrPos) : "memory");
#else
	Error("Implement CMeshBuilder::FastVertexSSE((dx8)");
#endif

	IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position);
#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}


inline void CVertexBuilder::FastQuadVertexSSE(const QuadTessVertex_t& vertex)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);       
	Assert(m_nCurrentVertex < m_nMaxVertexCount);

#if defined( _WIN32 ) && !defined( _X360 )
	const void* pRead = &vertex;
	void* pCurrPos = m_pCurrPosition;
	__asm
	{
		mov esi, pRead
		mov edi, pCurrPos

		movaps xmm0, [esi + 0]
		movaps xmm1, [esi + 16]
		movaps xmm2, [esi + 32]

		movntps[edi + 0], xmm0
		movntps[edi + 16], xmm1
		movntps[edi + 32], xmm2
	}
#endif

	IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position);
#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}



inline int CVertexBuilder::GetCurrentVertex() const
{
	return m_nCurrentVertex;
}


#if defined( _X360 )
inline void CVertexBuilder::VertexDX8ToX360(const ModelVertexDX8_t& vertex)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);       
	Assert(m_nCurrentVertex < m_nMaxVertexCount);

	unsigned char* pDst = (unsigned char*)m_pCurrPosition;

	Assert(m_VertexSize_Position > 0);      
	Assert(GetVertexElementSize(VERTEX_ELEMENT_POSITION, VERTEX_COMPRESSION_NONE) == sizeof(vertex.m_vecPosition));
	memcpy(pDst, vertex.m_vecPosition.Base(), sizeof(vertex.m_vecPosition));
	pDst += sizeof(vertex.m_vecPosition);

	if (m_VertexSize_Normal)
	{
		Assert(GetVertexElementSize(VERTEX_ELEMENT_NORMAL, VERTEX_COMPRESSION_NONE) == sizeof(vertex.m_vecNormal));
		memcpy(pDst, vertex.m_vecNormal.Base(), sizeof(vertex.m_vecNormal));
		pDst += sizeof(vertex.m_vecNormal);
	}

	if (m_VertexSize_TexCoord[0])
	{
		Assert(GetVertexElementSize(VERTEX_ELEMENT_TEXCOORD2D_0, VERTEX_COMPRESSION_NONE) == sizeof(vertex.m_vecTexCoord));
		memcpy(pDst, vertex.m_vecTexCoord.Base(), sizeof(vertex.m_vecTexCoord));
		pDst += sizeof(vertex.m_vecTexCoord);
	}

	if (m_VertexSize_UserData)
	{
		Assert(GetVertexElementSize(VERTEX_ELEMENT_USERDATA4, VERTEX_COMPRESSION_NONE) == sizeof(vertex.m_vecUserData));
		memcpy(pDst, vertex.m_vecUserData.Base(), sizeof(vertex.m_vecUserData));
		pDst += sizeof(vertex.m_vecUserData);
	}

	Assert(pDst - (unsigned char*)m_pCurrPosition == m_VertexSize_Position);

	IncrementFloatPointer(m_pCurrPosition, m_VertexSize_Position);

#if ( defined( _DEBUG ) && ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 ) )
	m_bWrittenNormal = false;
	m_bWrittenUserData = false;
#endif
}
#endif


inline const float* CVertexBuilder::Position() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pCurrPosition;
}

inline const float* CVertexBuilder::Normal() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pCurrNormal;
}

inline unsigned int CVertexBuilder::Color() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	unsigned int color;
	if (IsPC() || !IsX360())
	{
		color = (m_pCurrColor[3] << 24) | (m_pCurrColor[0] << 16) | (m_pCurrColor[1] << 8) | (m_pCurrColor[2]);
	}
	else
	{
		color = (m_pCurrColor[1] << 24) | (m_pCurrColor[2] << 16) | (m_pCurrColor[3] << 8) | (m_pCurrColor[0]);
	}
	return color;
}

inline unsigned char* CVertexBuilder::Specular() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pSpecular + m_nCurrentVertex * m_VertexSize_Specular;
}

inline const float* CVertexBuilder::TexCoord(int stage) const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pCurrTexCoord[stage];
}

inline const float* CVertexBuilder::TangentS() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return OffsetFloatPointer(m_pTangentS, m_nCurrentVertex, m_VertexSize_TangentS);
}

inline const float* CVertexBuilder::TangentT() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return OffsetFloatPointer(m_pTangentT, m_nCurrentVertex, m_VertexSize_TangentT);
}

inline float CVertexBuilder::Wrinkle() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return *OffsetFloatPointer(m_pWrinkle, m_nCurrentVertex, m_VertexSize_Wrinkle);
}

inline const float* CVertexBuilder::BoneWeight() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return OffsetFloatPointer(m_pBoneWeight, m_nCurrentVertex, m_VertexSize_BoneWeight);
}

inline int CVertexBuilder::NumBoneWeights() const
{
	return m_NumBoneWeights;
}

#ifndef NEW_SKINNING
inline unsigned char* CVertexBuilder::BoneMatrix() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pBoneMatrixIndex + m_nCurrentVertex * m_VertexSize_BoneMatrixIndex;
}
#else
inline float* CVertexBuilder::BoneMatrix() const
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);
	Assert(m_nCurrentVertex < m_nMaxVertexCount);
	return m_pBoneMatrixIndex + m_nCurrentVertex * m_VertexSize_BoneMatrixIndex;
}
#endif


inline void	CVertexBuilder::Position3f(float x, float y, float z)
{
	Assert(m_pPosition && m_pCurrPosition);
	Assert(IsFinite(x) && IsFinite(y) && IsFinite(z));
	float* pDst = m_pCurrPosition;
	*pDst++ = x;
	*pDst++ = y;
	*pDst = z;
}

inline void	CVertexBuilder::Position3fv(const float* v)
{
	Assert(v);
	Assert(m_pPosition && m_pCurrPosition);

	float* pDst = m_pCurrPosition;
	*pDst++ = *v++;
	*pDst++ = *v++;
	*pDst = *v;
}


inline void	CVertexBuilder::Normal3f(float nx, float ny, float nz)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);           
	Assert(m_pNormal);
	Assert(IsFinite(nx) && IsFinite(ny) && IsFinite(nz));
	Assert(nx >= -1.05f && nx <= 1.05f);
	Assert(ny >= -1.05f && ny <= 1.05f);
	Assert(nz >= -1.05f && nz <= 1.05f);

	float* pDst = m_pCurrNormal;
	*pDst++ = nx;
	*pDst++ = ny;
	*pDst = nz;
}

inline void	CVertexBuilder::Normal3fv(const float* n)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);           
	Assert(n);
	Assert(m_pNormal && m_pCurrNormal);
	Assert(IsFinite(n[0]) && IsFinite(n[1]) && IsFinite(n[2]));
	Assert(n[0] >= -1.05f && n[0] <= 1.05f);
	Assert(n[1] >= -1.05f && n[1] <= 1.05f);
	Assert(n[2] >= -1.05f && n[2] <= 1.05f);

	float* pDst = m_pCurrNormal;
	*pDst++ = *n++;
	*pDst++ = *n++;
	*pDst = *n;
}

inline void	CVertexBuilder::NormalDelta3f(float nx, float ny, float nz)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);           
	Assert(m_pNormal);
	Assert(IsFinite(nx) && IsFinite(ny) && IsFinite(nz));

	float* pDst = m_pCurrNormal;
	*pDst++ = nx;
	*pDst++ = ny;
	*pDst = nz;
}

inline void	CVertexBuilder::NormalDelta3fv(const float* n)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);           
	Assert(n);
	Assert(m_pNormal && m_pCurrNormal);
	Assert(IsFinite(n[0]) && IsFinite(n[1]) && IsFinite(n[2]));

	float* pDst = m_pCurrNormal;
	*pDst++ = *n++;
	*pDst++ = *n++;
	*pDst = *n;
}

template <VertexCompressionType_t T> inline void CVertexBuilder::CompressedNormal3f(float nx, float ny, float nz)
{
	Assert(T == m_CompressionType);
	Assert(m_pNormal && m_pCurrNormal);
	Assert(IsFinite(nx) && IsFinite(ny) && IsFinite(nz));
	Assert(nx >= -1.05f && nx <= 1.05f);
	Assert(ny >= -1.05f && ny <= 1.05f);
	Assert(nz >= -1.05f && nz <= 1.05f);
	if (T == VERTEX_COMPRESSION_ON)
	{
#if		( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
		PackNormal_SHORT2(nx, ny, nz, (unsigned int*)m_pCurrNormal);

#else     
#ifdef _DEBUG
		Assert(m_bWrittenUserData == false);
		m_bWrittenNormal = true;
#endif
		PackNormal_UBYTE4(nx, ny, nz, (unsigned int*)m_pCurrNormal);
#endif
	}
	else
	{
		float* pDst = m_pCurrNormal;
		*pDst++ = nx;
		*pDst++ = ny;
		*pDst = nz;
	}
}

template <VertexCompressionType_t T> inline void CVertexBuilder::CompressedNormal3fv(const float* n)
{
	Assert(n);
	CompressedNormal3f<T>(n[0], n[1], n[2]);
}


inline void	CVertexBuilder::Color3f(float r, float g, float b)
{
	Assert(m_pColor && m_pCurrColor);
	Assert(IsFinite(r) && IsFinite(g) && IsFinite(b));
	Assert((r >= 0.0) && (g >= 0.0) && (b >= 0.0));
	Assert((r <= 1.0) && (g <= 1.0) && (b <= 1.0));

	int col = (FastFToC(b)) | (FastFToC(g) << 8) | (FastFToC(r) << 16) | 0xFF000000;
	*(int*)m_pCurrColor = col;
}

inline void	CVertexBuilder::Color3fv(const float* rgb)
{
	Assert(rgb);
	Assert(m_pColor && m_pCurrColor);
	Assert(IsFinite(rgb[0]) && IsFinite(rgb[1]) && IsFinite(rgb[2]));
	Assert((rgb[0] >= 0.0) && (rgb[1] >= 0.0) && (rgb[2] >= 0.0));
	Assert((rgb[0] <= 1.0) && (rgb[1] <= 1.0) && (rgb[2] <= 1.0));

	int col = (FastFToC(rgb[2])) | (FastFToC(rgb[1]) << 8) | (FastFToC(rgb[0]) << 16) | 0xFF000000;
	*(int*)m_pCurrColor = col;
}

inline void	CVertexBuilder::Color4f(float r, float g, float b, float a)
{
	Assert(m_pColor && m_pCurrColor);
	Assert(IsFinite(r) && IsFinite(g) && IsFinite(b) && IsFinite(a));
	Assert((r >= 0.0) && (g >= 0.0) && (b >= 0.0) && (a >= 0.0));
	Assert((r <= 1.0) && (g <= 1.0) && (b <= 1.0) && (a <= 1.0));

	int col = (FastFToC(b)) | (FastFToC(g) << 8) | (FastFToC(r) << 16) | (FastFToC(a) << 24);
	*(int*)m_pCurrColor = col;
}

inline void	CVertexBuilder::Color4fv(const float* rgba)
{
	Assert(rgba);
	Assert(m_pColor && m_pCurrColor);
	Assert(IsFinite(rgba[0]) && IsFinite(rgba[1]) && IsFinite(rgba[2]) && IsFinite(rgba[3]));
	Assert((rgba[0] >= 0.0) && (rgba[1] >= 0.0) && (rgba[2] >= 0.0) && (rgba[3] >= 0.0));
	Assert((rgba[0] <= 1.0) && (rgba[1] <= 1.0) && (rgba[2] <= 1.0) && (rgba[3] <= 1.0));

	int col = (FastFToC(rgba[2])) | (FastFToC(rgba[1]) << 8) | (FastFToC(rgba[0]) << 16) | (FastFToC(rgba[3]) << 24);
	*(int*)m_pCurrColor = col;
}


inline void CVertexBuilder::Color3ub(unsigned char r, unsigned char g, unsigned char b)
{
	Assert(m_pColor && m_pCurrColor);
#ifdef OPENGL_SWAP_COLORS
	int col = r | (g << 8) | (b << 16) | 0xFF000000;	      
#else
	int col = b | (g << 8) | (r << 16) | 0xFF000000;
#endif

	* (int*)m_pCurrColor = col;
}

inline void CVertexBuilder::Color3ubv(unsigned char const* rgb)
{
	Assert(rgb);
	Assert(m_pColor && m_pCurrColor);
#ifdef OPENGL_SWAP_COLORS
	int col = rgb[0] | (rgb[1] << 8) | (rgb[2] << 16) | 0xFF000000;	      
#else
	int col = rgb[2] | (rgb[1] << 8) | (rgb[0] << 16) | 0xFF000000;
#endif

	* (int*)m_pCurrColor = col;
}

inline void CVertexBuilder::Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	Assert(m_pColor && m_pCurrColor);
#ifdef OPENGL_SWAP_COLORS
	int col = r | (g << 8) | (b << 16) | (a << 24);	      
#else
	int col = b | (g << 8) | (r << 16) | (a << 24);
#endif

	* (int*)m_pCurrColor = col;
}

inline void CVertexBuilder::Color4ubv(unsigned char const* rgba)
{
	Assert(rgba);
	Assert(m_pColor && m_pCurrColor);
#ifdef OPENGL_SWAP_COLORS
	int col = rgba[0] | (rgba[1] << 8) | (rgba[2] << 16) | (rgba[3] << 24);	      
#else
	int col = rgba[2] | (rgba[1] << 8) | (rgba[0] << 16) | (rgba[3] << 24);
#endif
	* (int*)m_pCurrColor = col;
}

FORCEINLINE void CVertexBuilder::Color4Packed(int packedColor)
{
	*(int*)m_pCurrColor = packedColor;
}

FORCEINLINE int CVertexBuilder::PackColor4(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	return b | (g << 8) | (r << 16) | (a << 24);
}


inline void	CVertexBuilder::Specular3f(float r, float g, float b)
{
	Assert(m_pSpecular);
	Assert(IsFinite(r) && IsFinite(g) && IsFinite(b));
	Assert((r >= 0.0) && (g >= 0.0) && (b >= 0.0));
	Assert((r <= 1.0) && (g <= 1.0) && (b <= 1.0));

	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];
	int col = (FastFToC(b)) | (FastFToC(g) << 8) | (FastFToC(r) << 16) | 0xFF000000;
	*(int*)pSpecular = col;
}

inline void	CVertexBuilder::Specular3fv(const float* rgb)
{
	Assert(rgb);
	Assert(m_pSpecular);
	Assert(IsFinite(rgb[0]) && IsFinite(rgb[1]) && IsFinite(rgb[2]));
	Assert((rgb[0] >= 0.0) && (rgb[1] >= 0.0) && (rgb[2] >= 0.0));
	Assert((rgb[0] <= 1.0) && (rgb[1] <= 1.0) && (rgb[2] <= 1.0));

	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];
	int col = (FastFToC(rgb[2])) | (FastFToC(rgb[1]) << 8) | (FastFToC(rgb[0]) << 16) | 0xFF000000;
	*(int*)pSpecular = col;
}

inline void	CVertexBuilder::Specular4f(float r, float g, float b, float a)
{
	Assert(m_pSpecular);
	Assert(IsFinite(r) && IsFinite(g) && IsFinite(b) && IsFinite(a));
	Assert((r >= 0.0) && (g >= 0.0) && (b >= 0.0) && (a >= 0.0));
	Assert((r <= 1.0) && (g <= 1.0) && (b <= 1.0) && (a <= 1.0f));

	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];
	int col = (FastFToC(b)) | (FastFToC(g) << 8) | (FastFToC(r) << 16) | (FastFToC(a) << 24);
	*(int*)pSpecular = col;
}

inline void	CVertexBuilder::Specular4fv(const float* rgb)
{
	Assert(rgb);
	Assert(m_pSpecular);
	Assert(IsFinite(rgb[0]) && IsFinite(rgb[1]) && IsFinite(rgb[2]) && IsFinite(rgb[3]));
	Assert((rgb[0] >= 0.0) && (rgb[1] >= 0.0) && (rgb[2] >= 0.0) && (rgb[3] >= 0.0));
	Assert((rgb[0] <= 1.0) && (rgb[1] <= 1.0) && (rgb[2] <= 1.0) && (rgb[3] <= 1.0));

	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];
	int col = (FastFToC(rgb[2])) | (FastFToC(rgb[1]) << 8) | (FastFToC(rgb[0]) << 16) | (FastFToC(rgb[3]) << 24);
	*(int*)pSpecular = col;
}

inline void CVertexBuilder::Specular3ub(unsigned char r, unsigned char g, unsigned char b)
{
	Assert(m_pSpecular);
	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];

#ifdef OPENGL_SWAP_COLORS
	int col = r | (g << 8) | (b << 16) | 0xFF000000;	      
#else
	int col = b | (g << 8) | (r << 16) | 0xFF000000;
#endif

	* (int*)pSpecular = col;
}

inline void CVertexBuilder::Specular3ubv(unsigned char const* c)
{
	Assert(m_pSpecular);
	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];

#ifdef OPENGL_SWAP_COLORS
	int col = c[0] | (c[1] << 8) | (c[2] << 16) | 0xFF000000;	      
#else
	int col = c[2] | (c[1] << 8) | (c[0] << 16) | 0xFF000000;
#endif

	* (int*)pSpecular = col;
}

inline void CVertexBuilder::Specular4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	Assert(m_pSpecular);
	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];

#ifdef OPENGL_SWAP_COLORS
	int col = r | (g << 8) | (b << 16) | (a << 24);	      
#else
	int col = b | (g << 8) | (r << 16) | (a << 24);
#endif

	* (int*)pSpecular = col;
}

inline void CVertexBuilder::Specular4ubv(unsigned char const* c)
{
	Assert(m_pSpecular);
	unsigned char* pSpecular = &m_pSpecular[m_nCurrentVertex * m_VertexSize_Specular];

#ifdef OPENGL_SWAP_COLORS
	int col = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);
#else
	int col = c[2] | (c[1] << 8) | (c[0] << 16) | (c[3] << 24);
#endif

	* (int*)pSpecular = col;
}


inline void CVertexBuilder::TexCoord1f(int nStage, float s)
{
	Assert(m_pTexCoord[nStage] && m_pCurrTexCoord[nStage]);
	Assert(IsFinite(s));

	float* pDst = m_pCurrTexCoord[nStage];
	*pDst = s;
}

inline void	CVertexBuilder::TexCoord2f(int nStage, float s, float t)
{
	Assert(m_pTexCoord[nStage] && m_pCurrTexCoord[nStage]);
	Assert(IsFinite(s) && IsFinite(t));

	float* pDst = m_pCurrTexCoord[nStage];
	*pDst++ = s;
	*pDst = t;
}

inline void	CVertexBuilder::TexCoord2fv(int nStage, const float* st)
{
	Assert(st);
	Assert(m_pTexCoord[nStage] && m_pCurrTexCoord[nStage]);
	Assert(IsFinite(st[0]) && IsFinite(st[1]));

	float* pDst = m_pCurrTexCoord[nStage];
	*pDst++ = *st++;
	*pDst = *st;
}

inline void	CVertexBuilder::TexCoord3f(int stage, float s, float t, float u)
{
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(s) && IsFinite(t) && IsFinite(u));
	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = s;
	*pDst++ = t;
	*pDst = u;
}

inline void	CVertexBuilder::TexCoord3fv(int stage, const float* stu)
{
	Assert(stu);
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(stu[0]) && IsFinite(stu[1]) && IsFinite(stu[2]));

	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = *stu++;
	*pDst++ = *stu++;
	*pDst = *stu;
}

inline void	CVertexBuilder::TexCoord4f(int stage, float s, float t, float u, float v)
{
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(s) && IsFinite(t) && IsFinite(u));
	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = s;
	*pDst++ = t;
	*pDst++ = u;
	*pDst = v;
}

inline void	CVertexBuilder::TexCoord4fv(int stage, const float* stuv)
{
	Assert(stuv);
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(stuv[0]) && IsFinite(stuv[1]) && IsFinite(stuv[2]));

	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = *stuv++;
	*pDst++ = *stuv++;
	*pDst++ = *stuv++;
	*pDst = *stuv;
}


inline void CVertexBuilder::TexCoordSubRect2f(int stage, float s, float t, float offsetS, float offsetT, float scaleS, float scaleT)
{
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(s) && IsFinite(t));

	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = (s * scaleS) + offsetS;
	*pDst = (t * scaleT) + offsetT;
}

inline void CVertexBuilder::TexCoordSubRect2fv(int stage, const float* st, const float* offset, const float* scale)
{
	Assert(st);
	Assert(m_pTexCoord[stage] && m_pCurrTexCoord[stage]);
	Assert(IsFinite(st[0]) && IsFinite(st[1]));

	float* pDst = m_pCurrTexCoord[stage];
	*pDst++ = (*st++ * *scale++) + *offset++;
	*pDst = (*st * *scale) + *offset;
}


inline void CVertexBuilder::TangentS3f(float sx, float sy, float sz)
{
	Assert(m_pTangentS);
	Assert(IsFinite(sx) && IsFinite(sy) && IsFinite(sz));

	float* pTangentS = OffsetFloatPointer(m_pTangentS, m_nCurrentVertex, m_VertexSize_TangentS);
	*pTangentS++ = sx;
	*pTangentS++ = sy;
	*pTangentS = sz;
}

inline void CVertexBuilder::TangentS3fv(const float* s)
{
	Assert(s);
	Assert(m_pTangentS);
	Assert(IsFinite(s[0]) && IsFinite(s[1]) && IsFinite(s[2]));

	float* pTangentS = OffsetFloatPointer(m_pTangentS, m_nCurrentVertex, m_VertexSize_TangentS);
	*pTangentS++ = *s++;
	*pTangentS++ = *s++;
	*pTangentS = *s;
}

inline void CVertexBuilder::TangentT3f(float tx, float ty, float tz)
{
	Assert(m_pTangentT);
	Assert(IsFinite(tx) && IsFinite(ty) && IsFinite(tz));

	float* pTangentT = OffsetFloatPointer(m_pTangentT, m_nCurrentVertex, m_VertexSize_TangentT);
	*pTangentT++ = tx;
	*pTangentT++ = ty;
	*pTangentT = tz;
}

inline void CVertexBuilder::TangentT3fv(const float* t)
{
	Assert(t);
	Assert(m_pTangentT);
	Assert(IsFinite(t[0]) && IsFinite(t[1]) && IsFinite(t[2]));

	float* pTangentT = OffsetFloatPointer(m_pTangentT, m_nCurrentVertex, m_VertexSize_TangentT);
	*pTangentT++ = *t++;
	*pTangentT++ = *t++;
	*pTangentT = *t;
}


inline void CVertexBuilder::Wrinkle1f(float flWrinkle)
{
	Assert(m_pWrinkle);
	Assert(IsFinite(flWrinkle));

	float* pWrinkle = OffsetFloatPointer(m_pWrinkle, m_nCurrentVertex, m_VertexSize_Wrinkle);
	*pWrinkle = flWrinkle;
}


inline void CVertexBuilder::BoneWeight(int idx, float weight)
{
	Assert(m_pBoneWeight);
	Assert(IsFinite(weight));
	Assert(idx >= 0);
	Assert(m_NumBoneWeights == 2);

	if (idx < m_NumBoneWeights)
	{
		float* pBoneWeight = OffsetFloatPointer(m_pBoneWeight, m_nCurrentVertex, m_VertexSize_BoneWeight);
		pBoneWeight[idx] = weight;
	}
}

inline void CVertexBuilder::BoneWeights2(float weight1, float weight2)
{
	Assert(m_pBoneWeight);
	Assert(IsFinite(weight1) && IsFinite(weight2));
	AssertOnce(m_NumBoneWeights == 2);

	float* pBoneWeight = OffsetFloatPointer(m_pBoneWeight, m_nCurrentVertex, m_VertexSize_BoneWeight);
	pBoneWeight[0] = weight1;
	pBoneWeight[1] = weight2;
}

inline void CVertexBuilder::BoneMatrix(int idx, int matrixIdx)
{
	Assert(m_pBoneMatrixIndex);
	Assert(idx >= 0);
	Assert(idx < 4);

	if (matrixIdx == BONE_MATRIX_INDEX_INVALID)
	{
		matrixIdx = 0;
	}
	Assert((matrixIdx >= 0) && (matrixIdx < 53));

#ifndef NEW_SKINNING
	unsigned char* pBoneMatrix = &m_pBoneMatrixIndex[m_nCurrentVertex * m_VertexSize_BoneMatrixIndex];
	if (IsX360())
	{
		idx = 3 - idx;
	}
	pBoneMatrix[idx] = (unsigned char)matrixIdx;
#else
	float* pBoneMatrix = &m_pBoneMatrixIndex[m_nCurrentVertex * m_VertexSize_BoneMatrixIndex];
	pBoneMatrix[idx] = matrixIdx;
#endif
}

inline void CVertexBuilder::BoneMatrices4(int matrixIdx0, int matrixIdx1, int matrixIdx2, int matrixIdx3)
{
	Assert(m_pBoneMatrixIndex);

	Assert(matrixIdx0 != BONE_MATRIX_INDEX_INVALID);
	Assert(matrixIdx1 != BONE_MATRIX_INDEX_INVALID);
	Assert(matrixIdx2 != BONE_MATRIX_INDEX_INVALID);
	Assert(matrixIdx3 != BONE_MATRIX_INDEX_INVALID);

#ifndef NEW_SKINNING
	int nVal;
	if (IsX360())
	{
		nVal = matrixIdx3 | (matrixIdx2 << 8) | (matrixIdx1 << 16) | (matrixIdx0 << 24);
	}
	else
	{
		nVal = matrixIdx0 | (matrixIdx1 << 8) | (matrixIdx2 << 16) | (matrixIdx3 << 24);
	}
	int* pBoneMatrix = (int*)(&m_pBoneMatrixIndex[m_nCurrentVertex * m_VertexSize_BoneMatrixIndex]);
	*pBoneMatrix = nVal;
#else
	float* pBoneMatrix = &m_pBoneMatrixIndex[m_nCurrentVertex * m_VertexSize_BoneMatrixIndex];
	pBoneMatrix[0] = matrixIdx0;
	pBoneMatrix[1] = matrixIdx1;
	pBoneMatrix[2] = matrixIdx2;
	pBoneMatrix[3] = matrixIdx3;
#endif
}

template <VertexCompressionType_t T> inline void CVertexBuilder::CompressedBoneWeight3fv(const float* pWeights)
{
	Assert(T == m_CompressionType);
	Assert(m_pBoneWeight);
	Assert(pWeights);

	float* pDestWeights = OffsetFloatPointer(m_pBoneWeight, m_nCurrentVertex, m_VertexSize_BoneWeight);

	if (T == VERTEX_COMPRESSION_ON)
	{
		Assert(m_NumBoneWeights <= 2);

		const int WEIGHT0_SHIFT = IsX360() ? 16 : 0;
		const int WEIGHT1_SHIFT = IsX360() ? 0 : 16;
		unsigned int* weights = (unsigned int*)pDestWeights;

		Assert(IsFinite(pWeights[0]) && (pWeights[0] >= 0.0f) && (pWeights[0] <= 1.0f));
		unsigned int weight0 = Float2Int(pWeights[0] * 32768.0f);
		*weights = (0x0000FFFF & (weight0 - 1)) << WEIGHT0_SHIFT;

#ifdef DEBUG
		if (m_NumBoneWeights == 1)
		{
			Assert(IsFinite(pWeights[1]) && (pWeights[1] >= 0.0f) && (pWeights[1] <= 1.0f));
			unsigned int weight1 = Float2Int(pWeights[1] * 32768.0f);
			Assert((weight0 + weight1) <= 32768);
		}
#endif

		if (m_NumBoneWeights > 1)
		{
			Assert(m_NumBoneWeights == 2);
			Assert(IsFinite(pWeights[1]) && (pWeights[1] >= 0.0f) && (pWeights[1] <= 1.0f));
			Assert(IsFinite(pWeights[2]) && (pWeights[2] >= 0.0f) && (pWeights[2] <= 1.0f));
			unsigned int weight1 = Float2Int(pWeights[1] * 32768.0f);
			unsigned int weight2 = Float2Int(pWeights[2] * 32768.0f);
			Assert((weight0 + weight1 + weight2) <= 32768);
			unsigned int residual = 32768 - (weight0 + weight1 + weight2);
			weight1 += residual;  
			*weights |= (0x0000FFFF & (weight1 - 1)) << WEIGHT1_SHIFT;
		}
	}
	else	  
	{
		pDestWeights[0] = pWeights[0];
		pDestWeights[1] = pWeights[1];
	}
}

inline void CVertexBuilder::UserData(const float* pData)
{
	Assert(m_CompressionType == VERTEX_COMPRESSION_NONE);           
	Assert(pData);

	int userDataSize = 4;  
	float* pUserData = OffsetFloatPointer(m_pUserData, m_nCurrentVertex, m_VertexSize_UserData);
	memcpy(pUserData, pData, sizeof(float) * userDataSize);
}

template <VertexCompressionType_t T> inline void CVertexBuilder::CompressedUserData(const float* pData)
{
	Assert(T == m_CompressionType);
	Assert(pData);
	Assert(IsFinite(pData[0]) && IsFinite(pData[1]) && IsFinite(pData[2]));
	Assert(pData[0] >= -1.05f && pData[0] <= 1.05f);
	Assert(pData[1] >= -1.05f && pData[1] <= 1.05f);
	Assert(pData[2] >= -1.05f && pData[2] <= 1.05f);
	Assert(pData[3] == +1.0f || pData[3] == -1.0f);
	if (T == VERTEX_COMPRESSION_ON)
	{
		float binormalSign = pData[3];

#if		( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
		float* pUserData = OffsetFloatPointer(m_pUserData, m_nCurrentVertex, m_VertexSize_UserData);
		PackNormal_SHORT2(pData, (unsigned int*)pUserData, binormalSign);
#else      
		unsigned int existingNormalData = *(unsigned int*)m_pCurrNormal;
		Assert((existingNormalData & 0xFFFF0000) == 0);
#ifdef _DEBUG
		Assert(m_bWrittenNormal == true);
		m_bWrittenUserData = true;
#endif
		bool bIsTangent = true;
		unsigned int tangentData = 0;
		PackNormal_UBYTE4(pData, &tangentData, bIsTangent, binormalSign);
		*(unsigned int*)m_pCurrNormal = existingNormalData | tangentData;
#endif
	}
	else
	{
		int userDataSize = 4;  
		float* pUserData = OffsetFloatPointer(m_pUserData, m_nCurrentVertex, m_VertexSize_UserData);
		memcpy(pUserData, pData, sizeof(float) * userDataSize);
	}
}


class CIndexBuilder : private IndexDesc_t
{
public:
	CIndexBuilder();
	CIndexBuilder(IIndexBuffer* pIndexBuffer, MaterialIndexFormat_t fmt = MATERIAL_INDEX_FORMAT_UNKNOWN);
	~CIndexBuilder();

	bool Lock(int nMaxIndexCount, int nIndexOffset, bool bAppend = false);
	void Unlock();

	void SpewData();

	int GetRoomRemaining() const;

	void Bind(IMatRenderContext* pContext);

	int Offset() const;

	void Begin(IIndexBuffer* pIndexBuffer, int nMaxIndexCount, int nIndexOffset = 0);
	void End(bool bSpewData = false);

	void BeginModify(IIndexBuffer* pIndexBuffer, int firstIndex = 0, int numIndices = 0, int nIndexOffset = 0);
	void EndModify(bool bSpewData = false);

	int	IndexCount() const;

	int TotalIndexCount() const;

	void Reset();

	void SelectIndex(int nBufferIndex);

	void AdvanceIndex();
	void AdvanceIndices(int numIndices);

	int GetCurrentIndex();
	int GetFirstIndex() const;

	unsigned short const* Index() const;

	void Index(unsigned short nIndex);

	void FastIndex(unsigned short nIndex);

	void FastIndex2(unsigned short nIndex1, unsigned short nIndex2);

	void GenerateIndices(MaterialPrimitiveType_t primitiveType, int numIndices);

	void AttachBegin(IMesh* pMesh, int nMaxIndexCount, const MeshDesc_t& desc);
	void AttachEnd();
	void AttachBeginModify(IMesh* pMesh, int firstIndex, int numIndices, const MeshDesc_t& desc);
	void AttachEndModify();

	void FastTriangle(int startVert);
	void FastQuad(int startVert);
	void FastPolygon(int startVert, int numTriangles);
	void FastPolygonList(int startVert, int* pVertexCount, int polygonCount);
	void FastIndexList(const unsigned short* pIndexList, int startVert, int indexCount);

private:
	IIndexBuffer* m_pIndexBuffer;

	int				m_nMaxIndexCount;

	int				m_nIndexCount;

	int				m_nIndexOffset;

	mutable int		m_nCurrentIndex;

	int				m_nTotalIndexCount;

	unsigned int	m_nBufferOffset;
	unsigned int	m_nBufferFirstIndex;

	bool			m_bModify;
};


inline CIndexBuilder::CIndexBuilder() : m_pIndexBuffer(0), m_nMaxIndexCount(0),
m_nIndexCount(0), m_nCurrentIndex(0)
{
	m_nTotalIndexCount = 0;
	m_nBufferOffset = INVALID_BUFFER_OFFSET;
	m_nBufferFirstIndex = 0;
#ifdef _DEBUG
	m_bModify = false;
#endif
}

inline CIndexBuilder::CIndexBuilder(IIndexBuffer* pIndexBuffer, MaterialIndexFormat_t fmt)
{
	m_pIndexBuffer = pIndexBuffer;
	m_nBufferOffset = INVALID_BUFFER_OFFSET;
	m_nBufferFirstIndex = 0;
	m_nIndexCount = 0;
	m_nCurrentIndex = 0;
	m_nMaxIndexCount = 0;
	m_nTotalIndexCount = 0;
	if (m_pIndexBuffer->IsDynamic())
	{
		m_pIndexBuffer->BeginCastBuffer(fmt);
	}
	else
	{
		Assert(m_pIndexBuffer->IndexFormat() == fmt);
	}
#ifdef _DEBUG
	m_bModify = false;
#endif
}

inline CIndexBuilder::~CIndexBuilder()
{
	if (m_pIndexBuffer && m_pIndexBuffer->IsDynamic())
	{
		m_pIndexBuffer->EndCastBuffer();
	}
}


inline bool CIndexBuilder::Lock(int nMaxIndexCount, int nIndexOffset, bool bAppend)
{
	Assert(m_pIndexBuffer);
	m_bModify = false;
	m_nIndexOffset = nIndexOffset;
	m_nMaxIndexCount = nMaxIndexCount;
	m_nIndexCount = 0;
	bool bFirstLock = (m_nBufferOffset == INVALID_BUFFER_OFFSET);
	if (bFirstLock)
	{
		bAppend = false;
	}
	if (!bAppend)
	{
		m_nTotalIndexCount = 0;
	}
	Reset();

	if (!m_pIndexBuffer->Lock(m_nMaxIndexCount, bAppend, *this))
	{
		m_nMaxIndexCount = 0;
		return false;
	}

	if (bFirstLock)
	{
		m_nBufferOffset = m_nOffset;
		m_nBufferFirstIndex = m_nFirstIndex;
	}

	return true;
}

inline void CIndexBuilder::Unlock()
{
	Assert(!m_bModify && m_pIndexBuffer);

	m_pIndexBuffer->Unlock(m_nIndexCount, *this);
	m_nTotalIndexCount += m_nIndexCount;

	m_nMaxIndexCount = 0;

#ifdef _DEBUG
	memset((IndexDesc_t*)this, 0, sizeof(IndexDesc_t));
#endif
}

inline void CIndexBuilder::SpewData()
{
	m_pIndexBuffer->Spew(m_nIndexCount, *this);
}


inline void CIndexBuilder::Bind(IMatRenderContext* pContext)
{
	if (m_pIndexBuffer && (m_nBufferOffset != INVALID_BUFFER_OFFSET))
	{
		pContext->BindIndexBuffer(m_pIndexBuffer, m_nBufferOffset);
	}
	else
	{
		pContext->BindIndexBuffer(NULL, 0);
	}
}


inline int CIndexBuilder::Offset() const
{
	return m_nBufferOffset;
}

inline int CIndexBuilder::GetFirstIndex() const
{
	return m_nBufferFirstIndex;
}


inline void CIndexBuilder::Begin(IIndexBuffer* pIndexBuffer, int nMaxIndexCount, int nIndexOffset)
{
	Assert(pIndexBuffer && (!m_pIndexBuffer));

	m_pIndexBuffer = pIndexBuffer;
	m_nIndexCount = 0;
	m_nMaxIndexCount = nMaxIndexCount;
	m_nIndexOffset = nIndexOffset;

	m_bModify = false;

	m_pIndexBuffer->Lock(m_nMaxIndexCount, false, *this);

	Reset();
}

inline void CIndexBuilder::End(bool bSpewData)
{
	Assert(!m_bModify);

	if (bSpewData)
	{
		m_pIndexBuffer->Spew(m_nIndexCount, *this);
	}

	m_pIndexBuffer->Unlock(m_nIndexCount, *this);

	m_pIndexBuffer = 0;
	m_nMaxIndexCount = 0;

#ifdef _DEBUG
	memset((IndexDesc_t*)this, 0, sizeof(IndexDesc_t));
#endif
}


inline void CIndexBuilder::BeginModify(IIndexBuffer* pIndexBuffer, int nFirstIndex, int nIndexCount, int nIndexOffset)
{
	m_pIndexBuffer = pIndexBuffer;
	m_nIndexCount = nIndexCount;
	m_nMaxIndexCount = nIndexCount;
	m_nIndexOffset = nIndexOffset;
	m_bModify = true;

	m_pIndexBuffer->ModifyBegin(false, nFirstIndex, nIndexCount, *this);

	Reset();
}

inline void CIndexBuilder::EndModify(bool bSpewData)
{
	Assert(m_pIndexBuffer);
	Assert(m_bModify);	     

	if (bSpewData)
	{
		m_pIndexBuffer->Spew(m_nIndexCount, *this);
	}

	m_pIndexBuffer->ModifyEnd(*this);

	m_pIndexBuffer = 0;
	m_nMaxIndexCount = 0;

#ifdef _DEBUG
	memset((IndexDesc_t*)this, 0, sizeof(IndexDesc_t));
#endif
}


inline void CIndexBuilder::AttachBegin(IMesh* pMesh, int nMaxIndexCount, const MeshDesc_t& desc)
{
	m_pIndexBuffer = pMesh;
	m_nIndexCount = 0;
	m_nMaxIndexCount = nMaxIndexCount;

	m_bModify = false;

	m_nIndexOffset = desc.m_nFirstVertex;
	m_pIndices = desc.m_pIndices;
	m_nIndexSize = desc.m_nIndexSize;

	Reset();
}

inline void CIndexBuilder::AttachEnd()
{
	Assert(m_pIndexBuffer);
	Assert(!m_bModify);	     

	m_pIndexBuffer = 0;
	m_nMaxIndexCount = 0;

#ifdef _DEBUG
	memset((IndexDesc_t*)this, 0, sizeof(IndexDesc_t));
#endif
}

inline void CIndexBuilder::AttachBeginModify(IMesh* pMesh, int nFirstIndex, int nIndexCount, const MeshDesc_t& desc)
{
	m_pIndexBuffer = pMesh;
	m_nIndexCount = nIndexCount;
	m_nMaxIndexCount = nIndexCount;
	m_bModify = true;

	m_nIndexOffset = desc.m_nFirstVertex;
	m_pIndices = desc.m_pIndices;
	m_nIndexSize = desc.m_nIndexSize;

	Reset();
}

inline void CIndexBuilder::AttachEndModify()
{
	Assert(m_pIndexBuffer);
	Assert(m_bModify);	     

	m_pIndexBuffer = 0;
	m_nMaxIndexCount = 0;

#ifdef _DEBUG
	memset((IndexDesc_t*)this, 0, sizeof(IndexDesc_t));
#endif
}


inline void CIndexBuilder::Reset()
{
	m_nCurrentIndex = 0;
}


inline int CIndexBuilder::IndexCount() const
{
	return m_nIndexCount;
}


inline int CIndexBuilder::TotalIndexCount() const
{
	return m_nTotalIndexCount;
}


inline void CIndexBuilder::AdvanceIndex()
{
	m_nCurrentIndex += m_nIndexSize;
	if (m_nCurrentIndex > m_nIndexCount)
	{
		m_nIndexCount = m_nCurrentIndex;
	}
}

inline void CIndexBuilder::AdvanceIndices(int nIndices)
{
	m_nCurrentIndex += nIndices * m_nIndexSize;
	if (m_nCurrentIndex > m_nIndexCount)
	{
		m_nIndexCount = m_nCurrentIndex;
	}
}


inline int CIndexBuilder::GetCurrentIndex()
{
	return m_nCurrentIndex;
}

inline unsigned short const* CIndexBuilder::Index() const
{
	Assert(m_nCurrentIndex < m_nMaxIndexCount);
	return &m_pIndices[m_nCurrentIndex];
}

inline void CIndexBuilder::SelectIndex(int nIndex)
{
	Assert((nIndex >= 0) && (nIndex < m_nIndexCount));
	m_nCurrentIndex = nIndex * m_nIndexSize;
}


inline void CIndexBuilder::Index(unsigned short nIndex)
{
	Assert(m_pIndices);
	Assert(m_nCurrentIndex < m_nMaxIndexCount);
	m_pIndices[m_nCurrentIndex] = (unsigned short)(m_nIndexOffset + nIndex);
}

inline void CIndexBuilder::FastIndex(unsigned short nIndex)
{
	Assert(m_pIndices);
	Assert(m_nCurrentIndex < m_nMaxIndexCount);
	m_pIndices[m_nCurrentIndex] = (unsigned short)(m_nIndexOffset + nIndex);
	m_nCurrentIndex += m_nIndexSize;
	m_nIndexCount = m_nCurrentIndex;
}

FORCEINLINE void CIndexBuilder::FastTriangle(int startVert)
{
	startVert += m_nIndexOffset;
	unsigned short* pIndices = &m_pIndices[m_nCurrentIndex];
	*pIndices++ = startVert++;
	*pIndices++ = startVert++;
	*pIndices++ = startVert;
	AdvanceIndices(3);
}

FORCEINLINE void CIndexBuilder::FastQuad(int startVert)
{
	startVert += m_nIndexOffset;
	unsigned short* pIndices = &m_pIndices[m_nCurrentIndex];
	*pIndices++ = startVert++;
	*pIndices++ = startVert++;
	*pIndices++ = startVert;

	*pIndices++ = startVert - 2;
	*pIndices++ = startVert++;
	*pIndices++ = startVert;
	AdvanceIndices(6);
}

inline void CIndexBuilder::FastPolygon(int startVert, int triangleCount)
{
	unsigned short* pIndex = &m_pIndices[m_nCurrentIndex];
	startVert += m_nIndexOffset;
	if (!IsX360())
	{
		Assert(m_nIndexSize == 0 || m_nIndexSize == 1);
		triangleCount *= m_nIndexSize;
	}
	for (int v = 0; v < triangleCount; ++v)
	{
		*pIndex++ = startVert;
		*pIndex++ = startVert + v + 1;
		*pIndex++ = startVert + v + 2;
	}
	AdvanceIndices(triangleCount * 3);
}

inline void CIndexBuilder::FastPolygonList(int startVert, int* pVertexCount, int polygonCount)
{
	unsigned short* pIndex = &m_pIndices[m_nCurrentIndex];
	startVert += m_nIndexOffset;
	int indexOut = 0;

	if (!IsX360())
	{
		Assert(m_nIndexSize == 0 || m_nIndexSize == 1);
		polygonCount *= m_nIndexSize;
	}

	for (int i = 0; i < polygonCount; i++)
	{
		int vertexCount = pVertexCount[i];
		int triangleCount = vertexCount - 2;
		for (int v = 0; v < triangleCount; ++v)
		{
			*pIndex++ = startVert;
			*pIndex++ = startVert + v + 1;
			*pIndex++ = startVert + v + 2;
		}
		startVert += vertexCount;
		indexOut += triangleCount * 3;
	}
	AdvanceIndices(indexOut);
}

inline void CIndexBuilder::FastIndexList(const unsigned short* pIndexList, int startVert, int indexCount)
{
	unsigned short* pIndexOut = &m_pIndices[m_nCurrentIndex];
	startVert += m_nIndexOffset;
	if (!IsX360())
	{
		Assert(m_nIndexSize == 0 || m_nIndexSize == 1);
		indexCount *= m_nIndexSize;
	}
	for (int i = 0; i < indexCount; ++i)
	{
		pIndexOut[i] = startVert + pIndexList[i];
	}
	AdvanceIndices(indexCount);
}


inline void CIndexBuilder::FastIndex2(unsigned short nIndex1, unsigned short nIndex2)
{
	Assert(m_pIndices);
	Assert(m_nCurrentIndex < m_nMaxIndexCount - 1);
#ifndef _X360
	unsigned int nIndices = ((unsigned int)nIndex1 + m_nIndexOffset) | (((unsigned int)nIndex2 + m_nIndexOffset) << 16);
#else
	unsigned int nIndices = ((unsigned int)nIndex2 + m_nIndexOffset) | (((unsigned int)nIndex1 + m_nIndexOffset) << 16);
#endif

	* (int*)(&m_pIndices[m_nCurrentIndex]) = nIndices;
	m_nCurrentIndex += m_nIndexSize + m_nIndexSize;
	m_nIndexCount = m_nCurrentIndex;
}


inline void CIndexBuilder::GenerateIndices(MaterialPrimitiveType_t primitiveType, int nIndexCount)
{
	if (m_nIndexSize == 0)
		return;

	int nMaxIndices = m_nMaxIndexCount - m_nCurrentIndex;
	nIndexCount = MIN(nMaxIndices, nIndexCount);
	if (nIndexCount == 0)
		return;

	unsigned short* pIndices = &m_pIndices[m_nCurrentIndex];

	switch (primitiveType)
	{
	case MATERIAL_INSTANCED_QUADS:
		Assert(0);        
		break;
	case MATERIAL_QUADS:
		GenerateQuadIndexBuffer(pIndices, nIndexCount, m_nIndexOffset);
		break;
	case MATERIAL_POLYGON:
		GeneratePolygonIndexBuffer(pIndices, nIndexCount, m_nIndexOffset);
		break;
	case MATERIAL_LINE_STRIP:
		GenerateLineStripIndexBuffer(pIndices, nIndexCount, m_nIndexOffset);
		break;
	case MATERIAL_LINE_LOOP:
		GenerateLineLoopIndexBuffer(pIndices, nIndexCount, m_nIndexOffset);
		break;
	case MATERIAL_POINTS:
		Assert(0);        
		break;
	case MATERIAL_SUBD_QUADS_EXTRA:
	case MATERIAL_SUBD_QUADS_REG:
	default:
		GenerateSequentialIndexBuffer(pIndices, nIndexCount, m_nIndexOffset);
		break;
	}

	AdvanceIndices(nIndexCount);
}


class CMeshBuilder : public MeshDesc_t
{
public:
	CMeshBuilder();
	~CMeshBuilder() { Assert(!m_pMesh); }		          

	operator CIndexBuilder& () { return m_IndexBuilder; }

	void SetCompressionType(VertexCompressionType_t compressionType);

	void Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int numPrimitives);

	void Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount, int* nFirstVertex);
	void Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount);

	void Begin(IVertexBuffer* pVertexBuffer, MaterialPrimitiveType_t type, int numPrimitives);
	void Begin(IVertexBuffer* pVertexBuffer, IIndexBuffer* pIndexBuffer, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount, int* nFirstVertex);
	void Begin(IVertexBuffer* pVertexBuffer, IIndexBuffer* pIndexBuffer, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount);

	void End(bool bSpewData = false, bool bDraw = false);

	void BeginModify(IMesh* pMesh, int nFirstVertex = 0, int nVertexCount = -1, int nFirstIndex = 0, int nIndexCount = 0);
	void EndModify(bool bSpewData = false);

	void DrawQuad(IMesh* pMesh, const float* v1, const float* v2,
		const float* v3, const float* v4, unsigned char const* pColor, bool wireframe = false);

	int VertexCount() const;
	int	IndexCount() const;

	void Reset();

	int VertexSize() { return m_ActualVertexSize; }

	int TextureCoordinateSize(int nTexCoordNumber) { return m_VertexSize_TexCoord[nTexCoordNumber]; }

	void* BaseVertexData();

	void SelectVertex(int idx);
	void SelectIndex(int idx);

	void SelectVertexFromIndex(int idx);

	void AdvanceVertex();
	template<int nFlags, int nNumTexCoords> void AdvanceVertexF();
	void AdvanceVertices(int nVerts);
	void AdvanceIndex();
	void AdvanceIndices(int nIndices);

	int GetCurrentVertex();
	int GetCurrentIndex();

	const float* Position() const;

	const float* Normal() const;

	unsigned int Color() const;

	unsigned char* Specular() const;

	const float* TexCoord(int stage) const;

	const float* TangentS() const;
	const float* TangentT() const;

	const float* BoneWeight() const;
	float Wrinkle() const;

	int NumBoneWeights() const;
#ifndef NEW_SKINNING
	unsigned char* BoneMatrix() const;
#else
	float* BoneMatrix() const;
#endif
	unsigned short const* Index() const;

	void Position3f(float x, float y, float z);
	void Position3fv(const float* v);

	void Normal3f(float nx, float ny, float nz);
	void Normal3fv(const float* n);
	void NormalDelta3fv(const float* n);
	void NormalDelta3f(float nx, float ny, float nz);

	template <VertexCompressionType_t T> void CompressedNormal3f(float nx, float ny, float nz);
	template <VertexCompressionType_t T> void CompressedNormal3fv(const float* n);

	void Color3f(float r, float g, float b);
	void Color3fv(const float* rgb);
	void Color4f(float r, float g, float b, float a);
	void Color4fv(const float* rgba);

	void Color3ub(unsigned char r, unsigned char g, unsigned char b);
	void Color3ubv(unsigned char const* rgb);
	void Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
	void Color4ubv(unsigned char const* rgba);
	void Color4Packed(int packedColor);
	int PackColor4(unsigned char r, unsigned char g, unsigned char b, unsigned char a);

	void Specular3f(float r, float g, float b);
	void Specular3fv(const float* rgb);
	void Specular4f(float r, float g, float b, float a);
	void Specular4fv(const float* rgba);

	void Specular3ub(unsigned char r, unsigned char g, unsigned char b);
	void Specular3ubv(unsigned char const* c);
	void Specular4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
	void Specular4ubv(unsigned char const* c);

	void TexCoord1f(int stage, float s);
	void TexCoord2f(int stage, float s, float t);
	void TexCoord2fv(int stage, const float* st);
	void TexCoord3f(int stage, float s, float t, float u);
	void TexCoord3fv(int stage, const float* stu);
	void TexCoord4f(int stage, float s, float t, float u, float w);
	void TexCoord4fv(int stage, const float* stuv);

	void TexCoordSubRect2f(int stage, float s, float t, float offsetS, float offsetT, float scaleS, float scaleT);
	void TexCoordSubRect2fv(int stage, const float* st, const float* offset, const float* scale);

	void TangentS3f(float sx, float sy, float sz);
	void TangentS3fv(const float* s);

	void TangentT3f(float tx, float ty, float tz);
	void TangentT3fv(const float* t);

	void Wrinkle1f(float flWrinkle);

	void BoneWeight(int idx, float weight);
	void BoneWeights2(float weight1, float weight2);

	template <VertexCompressionType_t T> void CompressedBoneWeight3fv(const float* pWeights);

	void BoneMatrix(int idx, int matrixIndex);
	void BoneMatrices4(int matrixIdx0, int matrixIdx1, int matrixIdx2, int matrixIdx3);

	void UserData(const float* pData);
	template <VertexCompressionType_t T> void CompressedUserData(const float* pData);

	void Index(unsigned short index);

	void FastIndex2(unsigned short nIndex1, unsigned short nIndex2);

	void FastIndex(unsigned short index);
	void FastQuad(int index);

	void FastVertex(const ModelVertexDX8_t& vertex);
	void FastVertexSSE(const ModelVertexDX8_t& vertex);
	void FastQuadVertexSSE(const QuadTessVertex_t& vertex);

	void FastAdvanceNVertices(int n);

#if defined( _X360 )
	void VertexDX8ToX360(const ModelVertexDX8_t& vertex);
#endif

	FORCEINLINE void* GetVertexDataPtr(int nWhatSizeIThinkItIs)
	{
		if (m_VertexBuilder.m_VertexSize_Position != nWhatSizeIThinkItIs)
			return NULL;
		return m_VertexBuilder.m_pCurrPosition;
	}


private:
	void ComputeNumVertsAndIndices(int* pMaxVertices, int* pMaxIndices,
		MaterialPrimitiveType_t type, int nPrimitiveCount);
	int IndicesFromVertices(MaterialPrimitiveType_t type, int nVertexCount);

	IMesh* m_pMesh;

	MaterialPrimitiveType_t m_Type;

	bool m_bGenerateIndices;

	CIndexBuilder	m_IndexBuilder;
	CVertexBuilder	m_VertexBuilder;
};


inline void CMeshBuilder::Begin(IVertexBuffer* pVertexBuffer, MaterialPrimitiveType_t type, int numPrimitives)
{
	Assert(0);
}

inline void CMeshBuilder::Begin(IVertexBuffer* pVertexBuffer, IIndexBuffer* pIndexBuffer, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount, int* nFirstVertex)
{
	Assert(0);
}

inline void CMeshBuilder::Begin(IVertexBuffer* pVertexBuffer, IIndexBuffer* pIndexBuffer, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount)
{
	Assert(0);
}


inline CMeshBuilder::CMeshBuilder() : m_pMesh(0), m_bGenerateIndices(false)
{
}


inline void CMeshBuilder::ComputeNumVertsAndIndices(int* pMaxVertices, int* pMaxIndices,
	MaterialPrimitiveType_t type, int nPrimitiveCount)
{
	switch (type)
	{
	case MATERIAL_POINTS:
		*pMaxVertices = *pMaxIndices = nPrimitiveCount;
		break;

	case MATERIAL_LINES:
		*pMaxVertices = *pMaxIndices = nPrimitiveCount * 2;
		break;

	case MATERIAL_LINE_STRIP:
		*pMaxVertices = nPrimitiveCount + 1;
		*pMaxIndices = nPrimitiveCount * 2;
		break;

	case MATERIAL_LINE_LOOP:
		*pMaxVertices = nPrimitiveCount;
		*pMaxIndices = nPrimitiveCount * 2;
		break;

	case MATERIAL_TRIANGLES:
		*pMaxVertices = *pMaxIndices = nPrimitiveCount * 3;
		break;

	case MATERIAL_TRIANGLE_STRIP:
		*pMaxVertices = *pMaxIndices = nPrimitiveCount + 2;
		break;

	case MATERIAL_QUADS:
		*pMaxVertices = nPrimitiveCount * 4;
		*pMaxIndices = nPrimitiveCount * 6;
		break;

	case MATERIAL_INSTANCED_QUADS:
		*pMaxVertices = nPrimitiveCount;
		*pMaxIndices = 0;     
		break;

	case MATERIAL_POLYGON:
		*pMaxVertices = nPrimitiveCount;
		*pMaxIndices = (nPrimitiveCount - 2) * 3;
		break;

	default:
		Assert(0);
	}

	Assert(*pMaxVertices <= 32768);
	Assert(*pMaxIndices <= 32768);
}


inline int CMeshBuilder::IndicesFromVertices(MaterialPrimitiveType_t type, int nVertexCount)
{
	switch (type)
	{
	case MATERIAL_QUADS:
		Assert((nVertexCount & 0x3) == 0);
		return (nVertexCount * 6) / 4;

	case MATERIAL_INSTANCED_QUADS:
		return 0;

	case MATERIAL_POLYGON:
		Assert(nVertexCount >= 3);
		return (nVertexCount - 2) * 3;

	case MATERIAL_LINE_STRIP:
		Assert(nVertexCount >= 2);
		return (nVertexCount - 1) * 2;

	case MATERIAL_LINE_LOOP:
		Assert(nVertexCount >= 3);
		return nVertexCount * 2;

	default:
		return nVertexCount;
	}
}

inline void CMeshBuilder::SetCompressionType(VertexCompressionType_t vertexCompressionType)
{
	m_CompressionType = vertexCompressionType;
	m_VertexBuilder.SetCompressionType(vertexCompressionType);
}

inline void CMeshBuilder::Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int numPrimitives)
{
	Assert(pMesh && (!m_pMesh));
	Assert(type != MATERIAL_HETEROGENOUS);

	m_pMesh = pMesh;
	m_bGenerateIndices = true;
	m_Type = type;

	int nMaxVertexCount, nMaxIndexCount;
	ComputeNumVertsAndIndices(&nMaxVertexCount, &nMaxIndexCount, type, numPrimitives);

	switch (type)
	{
	case MATERIAL_INSTANCED_QUADS:
		m_pMesh->SetPrimitiveType(MATERIAL_INSTANCED_QUADS);
		break;

	case MATERIAL_QUADS:
	case MATERIAL_POLYGON:
		m_pMesh->SetPrimitiveType(MATERIAL_TRIANGLES);
		break;

	case MATERIAL_LINE_STRIP:
	case MATERIAL_LINE_LOOP:
		m_pMesh->SetPrimitiveType(MATERIAL_LINES);
		break;

	default:
		m_pMesh->SetPrimitiveType(type);
	}

	m_pMesh->LockMesh(nMaxVertexCount, nMaxIndexCount, *this, NULL);

	m_IndexBuilder.AttachBegin(pMesh, nMaxIndexCount, *this);
	m_VertexBuilder.AttachBegin(pMesh, nMaxVertexCount, *this);

	Reset();
}

inline void CMeshBuilder::Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount, int* nFirstVertex)
{
	Begin(pMesh, type, nVertexCount, nIndexCount);

	*nFirstVertex = m_VertexBuilder.m_nFirstVertex * m_VertexBuilder.VertexSize();
}

inline void CMeshBuilder::Begin(IMesh* pMesh, MaterialPrimitiveType_t type, int nVertexCount, int nIndexCount)
{
	Assert(pMesh && (!m_pMesh));

	Assert((type != MATERIAL_QUADS) && (type != MATERIAL_INSTANCED_QUADS) && (type != MATERIAL_POLYGON) &&
		(type != MATERIAL_LINE_STRIP) && (type != MATERIAL_LINE_LOOP));

	Assert(type != MATERIAL_POINTS);

	m_pMesh = pMesh;
	m_bGenerateIndices = false;
	m_Type = type;

	m_pMesh->SetPrimitiveType(type);

	m_pMesh->LockMesh(nVertexCount, nIndexCount, *this, NULL);

	m_IndexBuilder.AttachBegin(pMesh, nIndexCount, *this);
	m_VertexBuilder.AttachBegin(pMesh, nVertexCount, *this);

	Reset();
}


inline void CMeshBuilder::End(bool bSpewData, bool bDraw)
{
	if (m_bGenerateIndices)
	{
		int nIndexCount = IndicesFromVertices(m_Type, m_VertexBuilder.VertexCount());
		m_IndexBuilder.GenerateIndices(m_Type, nIndexCount);
	}

	if (bSpewData)
	{
		m_pMesh->Spew(m_VertexBuilder.VertexCount(), m_IndexBuilder.IndexCount(), *this);
	}

#ifdef _DEBUG
	m_pMesh->ValidateData(m_VertexBuilder.VertexCount(), m_IndexBuilder.IndexCount(), *this);
#endif

	m_pMesh->UnlockMesh(m_VertexBuilder.VertexCount(), m_IndexBuilder.IndexCount(), *this);

	m_IndexBuilder.AttachEnd();
	m_VertexBuilder.AttachEnd();

	if (bDraw)
	{
		m_pMesh->Draw();
	}

	m_pMesh = 0;

#ifdef _DEBUG
	memset((MeshDesc_t*)this, 0, sizeof(MeshDesc_t));
#endif
}


inline void CMeshBuilder::BeginModify(IMesh* pMesh, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount)
{
	Assert(pMesh && (!m_pMesh));

	if (nVertexCount < 0)
	{
		nVertexCount = pMesh->VertexCount();
	}

	m_pMesh = pMesh;
	m_bGenerateIndices = false;

	pMesh->ModifyBeginEx(false, nFirstVertex, nVertexCount, nFirstIndex, nIndexCount, *this);

	m_IndexBuilder.AttachBeginModify(pMesh, nFirstIndex, nIndexCount, *this);
	m_VertexBuilder.AttachBeginModify(pMesh, nFirstVertex, nVertexCount, *this);

	Reset();
}

inline void CMeshBuilder::EndModify(bool bSpewData)
{
	Assert(m_pMesh);

	if (bSpewData)
	{
		m_pMesh->Spew(m_VertexBuilder.VertexCount(), m_IndexBuilder.IndexCount(), *this);
	}
#ifdef _DEBUG
	m_pMesh->ValidateData(m_VertexBuilder.VertexCount(), m_IndexBuilder.IndexCount(), *this);
#endif

	m_pMesh->ModifyEnd(*this);
	m_pMesh = 0;

	m_IndexBuilder.AttachEndModify();
	m_VertexBuilder.AttachEndModify();

#ifdef _DEBUG
	memset((MeshDesc_t*)this, 0, sizeof(MeshDesc_t));
#endif
}


inline void CMeshBuilder::Reset()
{
	m_IndexBuilder.Reset();
	m_VertexBuilder.Reset();
}


FORCEINLINE void CMeshBuilder::SelectVertex(int nIndex)
{
	m_VertexBuilder.SelectVertex(nIndex);
}

inline void CMeshBuilder::SelectVertexFromIndex(int idx)
{
	int vertIdx = idx - m_nFirstVertex;
	SelectVertex(vertIdx);
}

FORCEINLINE void CMeshBuilder::SelectIndex(int idx)
{
	m_IndexBuilder.SelectIndex(idx);
}


template<int nFlags, int nNumTexCoords> FORCEINLINE void CMeshBuilder::AdvanceVertexF()
{
	m_VertexBuilder.AdvanceVertexF<nFlags, nNumTexCoords>();
}
FORCEINLINE void CMeshBuilder::AdvanceVertex()
{
	m_VertexBuilder.AdvanceVertex();
}

FORCEINLINE void CMeshBuilder::AdvanceVertices(int nVertexCount)
{
	m_VertexBuilder.AdvanceVertices(nVertexCount);
}

FORCEINLINE void CMeshBuilder::AdvanceIndex()
{
	m_IndexBuilder.AdvanceIndex();
}

FORCEINLINE void CMeshBuilder::AdvanceIndices(int nIndices)
{
	m_IndexBuilder.AdvanceIndices(nIndices);
}

FORCEINLINE int CMeshBuilder::GetCurrentVertex()
{
	return m_VertexBuilder.GetCurrentVertex();
}

FORCEINLINE int CMeshBuilder::GetCurrentIndex()
{
	return m_IndexBuilder.GetCurrentIndex();
}


inline void CMeshBuilder::DrawQuad(IMesh* pMesh, const float* v1, const float* v2,
	const float* v3, const float* v4, unsigned char const* pColor, bool wireframe)
{
	if (!wireframe)
	{
		Begin(pMesh, MATERIAL_TRIANGLE_STRIP, 2);

		Position3fv(v1);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v2);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v4);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v3);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();
	}
	else
	{
		Begin(pMesh, MATERIAL_LINE_LOOP, 4);
		Position3fv(v1);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v2);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v3);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();

		Position3fv(v4);
		Color4ubv(pColor);
		AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>();
	}

	End();
	pMesh->Draw();
}


FORCEINLINE int CMeshBuilder::VertexCount() const
{
	return m_VertexBuilder.VertexCount();
}

FORCEINLINE int CMeshBuilder::IndexCount() const
{
	return m_IndexBuilder.IndexCount();
}


FORCEINLINE void* CMeshBuilder::BaseVertexData()
{
	return m_VertexBuilder.BaseVertexData();
}

FORCEINLINE const float* CMeshBuilder::Position() const
{
	return m_VertexBuilder.Position();
}

FORCEINLINE const float* CMeshBuilder::Normal()	const
{
	return m_VertexBuilder.Normal();
}

FORCEINLINE unsigned int CMeshBuilder::Color() const
{
	return m_VertexBuilder.Color();
}

FORCEINLINE unsigned char* CMeshBuilder::Specular() const
{
	return m_VertexBuilder.Specular();
}

FORCEINLINE const float* CMeshBuilder::TexCoord(int nStage) const
{
	return m_VertexBuilder.TexCoord(nStage);
}

FORCEINLINE const float* CMeshBuilder::TangentS() const
{
	return m_VertexBuilder.TangentS();
}

FORCEINLINE const float* CMeshBuilder::TangentT() const
{
	return m_VertexBuilder.TangentT();
}

FORCEINLINE float CMeshBuilder::Wrinkle() const
{
	return m_VertexBuilder.Wrinkle();
}

FORCEINLINE const float* CMeshBuilder::BoneWeight() const
{
	return m_VertexBuilder.BoneWeight();
}

FORCEINLINE int CMeshBuilder::NumBoneWeights() const
{
	return m_VertexBuilder.NumBoneWeights();
}

FORCEINLINE unsigned short const* CMeshBuilder::Index() const
{
	return m_IndexBuilder.Index();
}


FORCEINLINE void CMeshBuilder::Index(unsigned short idx)
{
	m_IndexBuilder.Index(idx);
}


FORCEINLINE void CMeshBuilder::FastIndex(unsigned short idx)
{
	m_IndexBuilder.FastIndex(idx);
}

FORCEINLINE void CMeshBuilder::FastIndex2(unsigned short nIndex1, unsigned short nIndex2)
{
	m_IndexBuilder.FastIndex2(nIndex1, nIndex2);
}

FORCEINLINE void CMeshBuilder::FastQuad(int nIndex)
{
	m_IndexBuilder.FastQuad(nIndex);
}

FORCEINLINE void CMeshBuilder::FastAdvanceNVertices(int nVertexCount)
{
	m_VertexBuilder.FastAdvanceNVertices(nVertexCount);
}


FORCEINLINE void CMeshBuilder::FastVertex(const ModelVertexDX8_t& vertex)
{
	m_VertexBuilder.FastVertex(vertex);
}

FORCEINLINE void CMeshBuilder::FastVertexSSE(const ModelVertexDX8_t& vertex)
{
	m_VertexBuilder.FastVertexSSE(vertex);
}

FORCEINLINE void CMeshBuilder::FastQuadVertexSSE(const QuadTessVertex_t& vertex)
{
	m_VertexBuilder.FastQuadVertexSSE(vertex);
}


#if defined( _X360 )
inline void CMeshBuilder::VertexDX8ToX360(const ModelVertexDX8_t& vertex)
{
	m_VertexBuilder.VertexDX8ToX360(vertex);
}
#endif

FORCEINLINE void CMeshBuilder::Position3f(float x, float y, float z)
{
	m_VertexBuilder.Position3f(x, y, z);
}

FORCEINLINE void CMeshBuilder::Position3fv(const float* v)
{
	m_VertexBuilder.Position3fv(v);
}

FORCEINLINE void CMeshBuilder::Normal3f(float nx, float ny, float nz)
{
	m_VertexBuilder.Normal3f(nx, ny, nz);
}

FORCEINLINE void CMeshBuilder::Normal3fv(const float* n)
{
	m_VertexBuilder.Normal3fv(n);
}

FORCEINLINE void CMeshBuilder::NormalDelta3f(float nx, float ny, float nz)
{
	m_VertexBuilder.NormalDelta3f(nx, ny, nz);
}

FORCEINLINE void CMeshBuilder::NormalDelta3fv(const float* n)
{
	m_VertexBuilder.NormalDelta3fv(n);
}

FORCEINLINE void CMeshBuilder::Color3f(float r, float g, float b)
{
	m_VertexBuilder.Color3f(r, g, b);
}

FORCEINLINE void CMeshBuilder::Color3fv(const float* rgb)
{
	m_VertexBuilder.Color3fv(rgb);
}

FORCEINLINE void CMeshBuilder::Color4f(float r, float g, float b, float a)
{
	m_VertexBuilder.Color4f(r, g, b, a);
}

FORCEINLINE void CMeshBuilder::Color4fv(const float* rgba)
{
	m_VertexBuilder.Color4fv(rgba);
}

FORCEINLINE void CMeshBuilder::Color3ub(unsigned char r, unsigned char g, unsigned char b)
{
	m_VertexBuilder.Color3ub(r, g, b);
}

FORCEINLINE void CMeshBuilder::Color3ubv(unsigned char const* rgb)
{
	m_VertexBuilder.Color3ubv(rgb);
}

FORCEINLINE void CMeshBuilder::Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	m_VertexBuilder.Color4ub(r, g, b, a);
}

FORCEINLINE void CMeshBuilder::Color4ubv(unsigned char const* rgba)
{
	m_VertexBuilder.Color4ubv(rgba);
}

FORCEINLINE void CMeshBuilder::Color4Packed(int packedColor)
{
	m_VertexBuilder.Color4Packed(packedColor);
}

FORCEINLINE int CMeshBuilder::PackColor4(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	return m_VertexBuilder.PackColor4(r, g, b, a);
}

FORCEINLINE void CMeshBuilder::Specular3f(float r, float g, float b)
{
	m_VertexBuilder.Specular3f(r, g, b);
}

FORCEINLINE void CMeshBuilder::Specular3fv(const float* rgb)
{
	m_VertexBuilder.Specular3fv(rgb);
}

FORCEINLINE void CMeshBuilder::Specular4f(float r, float g, float b, float a)
{
	m_VertexBuilder.Specular4f(r, g, b, a);
}

FORCEINLINE void CMeshBuilder::Specular4fv(const float* rgba)
{
	m_VertexBuilder.Specular4fv(rgba);
}

FORCEINLINE void CMeshBuilder::Specular3ub(unsigned char r, unsigned char g, unsigned char b)
{
	m_VertexBuilder.Specular3ub(r, g, b);
}

FORCEINLINE void CMeshBuilder::Specular3ubv(unsigned char const* c)
{
	m_VertexBuilder.Specular3ubv(c);
}

FORCEINLINE void CMeshBuilder::Specular4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	m_VertexBuilder.Specular4ub(r, g, b, a);
}

FORCEINLINE void CMeshBuilder::Specular4ubv(unsigned char const* c)
{
	m_VertexBuilder.Specular4ubv(c);
}

FORCEINLINE void CMeshBuilder::TexCoord1f(int nStage, float s)
{
	m_VertexBuilder.TexCoord1f(nStage, s);
}

FORCEINLINE void CMeshBuilder::TexCoord2f(int nStage, float s, float t)
{
	m_VertexBuilder.TexCoord2f(nStage, s, t);
}

FORCEINLINE void CMeshBuilder::TexCoord2fv(int nStage, const float* st)
{
	m_VertexBuilder.TexCoord2fv(nStage, st);
}

FORCEINLINE void CMeshBuilder::TexCoord3f(int nStage, float s, float t, float u)
{
	m_VertexBuilder.TexCoord3f(nStage, s, t, u);
}

FORCEINLINE void CMeshBuilder::TexCoord3fv(int nStage, const float* stu)
{
	m_VertexBuilder.TexCoord3fv(nStage, stu);
}

FORCEINLINE void CMeshBuilder::TexCoord4f(int nStage, float s, float t, float u, float v)
{
	m_VertexBuilder.TexCoord4f(nStage, s, t, u, v);
}

FORCEINLINE void CMeshBuilder::TexCoord4fv(int nStage, const float* stuv)
{
	m_VertexBuilder.TexCoord4fv(nStage, stuv);
}

FORCEINLINE void CMeshBuilder::TexCoordSubRect2f(int nStage, float s, float t, float offsetS, float offsetT, float scaleS, float scaleT)
{
	m_VertexBuilder.TexCoordSubRect2f(nStage, s, t, offsetS, offsetT, scaleS, scaleT);
}

FORCEINLINE void CMeshBuilder::TexCoordSubRect2fv(int nStage, const float* st, const float* offset, const float* scale)
{
	m_VertexBuilder.TexCoordSubRect2fv(nStage, st, offset, scale);
}

FORCEINLINE void CMeshBuilder::TangentS3f(float sx, float sy, float sz)
{
	m_VertexBuilder.TangentS3f(sx, sy, sz);
}

FORCEINLINE void CMeshBuilder::TangentS3fv(const float* s)
{
	m_VertexBuilder.TangentS3fv(s);
}

FORCEINLINE void CMeshBuilder::TangentT3f(float tx, float ty, float tz)
{
	m_VertexBuilder.TangentT3f(tx, ty, tz);
}

FORCEINLINE void CMeshBuilder::TangentT3fv(const float* t)
{
	m_VertexBuilder.TangentT3fv(t);
}

FORCEINLINE void CMeshBuilder::Wrinkle1f(float flWrinkle)
{
	m_VertexBuilder.Wrinkle1f(flWrinkle);
}

FORCEINLINE void CMeshBuilder::BoneWeight(int nIndex, float flWeight)
{
	m_VertexBuilder.BoneWeight(nIndex, flWeight);
}

FORCEINLINE void CMeshBuilder::BoneWeights2(float weight1, float weight2)
{
	m_VertexBuilder.BoneWeights2(weight1, weight2);
}

template <VertexCompressionType_t T> FORCEINLINE void CMeshBuilder::CompressedBoneWeight3fv(const float* pWeights)
{
	m_VertexBuilder.CompressedBoneWeight3fv<T>(pWeights);
}

FORCEINLINE void CMeshBuilder::BoneMatrix(int nIndex, int nMatrixIdx)
{
	m_VertexBuilder.BoneMatrix(nIndex, nMatrixIdx);
}

FORCEINLINE void CMeshBuilder::BoneMatrices4(int matrixIdx0, int matrixIdx1, int matrixIdx2, int matrixIdx3)
{
	m_VertexBuilder.BoneMatrices4(matrixIdx0, matrixIdx1, matrixIdx2, matrixIdx3);
}

FORCEINLINE void CMeshBuilder::UserData(const float* pData)
{
	m_VertexBuilder.UserData(pData);
}

template <VertexCompressionType_t T> FORCEINLINE void CMeshBuilder::CompressedUserData(const float* pData)
{
	m_VertexBuilder.CompressedUserData<T>(pData);
}

template <VertexCompressionType_t T> FORCEINLINE void CMeshBuilder::CompressedNormal3f(float nx, float ny, float nz)
{
	m_VertexBuilder.CompressedNormal3f<T>(nx, ny, nz);
}

template <VertexCompressionType_t T> FORCEINLINE void CMeshBuilder::CompressedNormal3fv(const float* n)
{
	m_VertexBuilder.CompressedNormal3fv<T>(n);
}

#endif