vertexbuffermanager.cpp from NeoEngineNG at Krugle

Show vertexbuffermanager.cpp syntax highlighted

/***************************************************************************
     vertexbuffermanager.cpp  -  Base vertex buffer allocation manager
                             -------------------
    begin                : Sat May 10 2003
    copyright            : (C) 2003 by Reality Rift Studios
    email                : mattias@realityrift.com
 ***************************************************************************

 The contents of this file are subject to the Mozilla Public License Version
 1.1 (the "License"); you may not use this file except in compliance with
 the License. You may obtain a copy of the License at 
 http://www.mozilla.org/MPL/

 Software distributed under the License is distributed on an "AS IS" basis,
 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 for the specific language governing rights and limitations under the
 License.

 The Original Code is the NeoEngine, NeoDevOpenGL, vertexbuffermanager.cpp

 The Initial Developer of the Original Code is Mattias Jansson.
 Portions created by Mattias Jansson are Copyright (C) 2003
 Reality Rift Studios. All Rights Reserved.

 ***************************************************************************/

#include "vertexbuffermanager.h"
#include "textureunit.h"
#include "texture.h"
#include "shader.h"

#include <neoengine/vertex.h>

using namespace NeoEngine;


namespace NeoOGL
{


VertexBufferPtr Device::CreateVertexBuffer( unsigned int uiType, unsigned int uiNumVertices, const VertexDeclaration *pkFormat, const void *pData )
{
	return m_pkVertexBufferManager->CreateVertexBuffer( uiType, uiNumVertices, pkFormat, pData );
}






VertexBufferManager::VertexBufferManager( Device *pkDevice ) :
	m_pkDevice( pkDevice )
{
	glDisableClientState( GL_NORMAL_ARRAY );
	glDisableClientState( GL_COLOR_ARRAY );

	m_bNormalArrayEnabled   = false;
	m_bDiffuseArrayEnabled  = false;
	
	//State set by initialize method
	for( int i = 0; i < 8; ++i )
		m_bTexCoordArrayEnabled[i] = false;

	m_bTangentArrayEnabled  = false;
	m_bBinormalArrayEnabled = false;
}


VertexBufferManager::~VertexBufferManager()
{
}


void VertexBufferManager::SetBasePointers( VertexBufferGL *pkVertexBuffer, unsigned int uiUVLayer )
{
	const unsigned char *pucPtr  = (const unsigned char*)pkVertexBuffer->GetRenderData();
	int                  iStride = pkVertexBuffer->GetVertexSize();

	glVertexPointer( 3, GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkPositionElement->m_uiOffset );

	if( pkVertexBuffer->m_pkNormalElement )
	{
		glNormalPointer( GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkNormalElement->m_uiOffset );

		if( !m_bNormalArrayEnabled )
		{
			glEnableClientState( GL_NORMAL_ARRAY );
			m_bNormalArrayEnabled = true;
		}
	}
	else if( m_bNormalArrayEnabled )
	{
		glDisableClientState( GL_NORMAL_ARRAY );
		m_bNormalArrayEnabled = false;
	}

	if( pkVertexBuffer->m_pkDiffuseElement )
	{
		if( pkVertexBuffer->m_pkDiffuseElement->m_uiType == VertexElement::COLOR32 )
			glColorPointer( 4, GL_UNSIGNED_BYTE, iStride, pucPtr + pkVertexBuffer->m_pkDiffuseElement->m_uiOffset );
		else
			glColorPointer( pkVertexBuffer->m_pkDiffuseElement->m_uiType + 1, GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkDiffuseElement->m_uiOffset );

		if( !m_bDiffuseArrayEnabled )
		{
			glEnableClientState( GL_COLOR_ARRAY );
			m_bDiffuseArrayEnabled = true;
		}
	}
	else if( m_bDiffuseArrayEnabled )
	{
		glDisableClientState( GL_COLOR_ARRAY );
		m_bDiffuseArrayEnabled = false;
	}

	if( pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ] )
	{
		glTexCoordPointer( pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ]->m_uiType + 1, GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ]->m_uiOffset );

		if( !m_bTexCoordArrayEnabled[ uiUVLayer ] )
		{
			glEnableClientState( GL_TEXTURE_COORD_ARRAY );
			m_bTexCoordArrayEnabled[ uiUVLayer ] = true;
		}
	}
	else if( m_bTexCoordArrayEnabled[ uiUVLayer ] )
	{
		glDisableClientState( GL_TEXTURE_COORD_ARRAY );
		m_bTexCoordArrayEnabled[ uiUVLayer ] = false;
	}

	if( pkVertexBuffer->m_pkTangentElement )
	{
		switch( Shader::s_eVSTarget )
		{
			case Shader::NEPT_GL_ARBVP_1:
			{
				if( pkVertexBuffer->m_pkTangentElement->m_uiType == VertexElement::COLOR32 )
					neoglVertexAttribPointerARB( 14, 4, GL_UNSIGNED_BYTE, GL_TRUE, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				else
					neoglVertexAttribPointerARB( 14, pkVertexBuffer->m_pkTangentElement->m_uiType + 1, GL_FLOAT, GL_FALSE, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				neoglEnableVertexAttribArrayARB( 14 );
                break;
			}
/*
			case NEPT_NVVP_30:
			{
				neoglVertexAttribPointerNV( 14, pkVertexBuffer->m_pkTangentElement->m_uiType + 1, GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				glEnableClientState( GL_VERTEX_ATTRIB_ARRAY14_NV );
				break;
			}
*/
			default:
				break;
		}

		m_bTangentArrayEnabled = true;
	}
	else if( m_bTangentArrayEnabled )
	{
		switch( Shader::s_eVSTarget )
		{
			case Shader::NEPT_GL_ARBVP_1:
			{
				neoglDisableVertexAttribArrayARB( 14 );
				break;
			}
/*
			case CG_PROFILE_VP20:
			case CG_PROFILE_VP30:
				glDisableClientState( GL_VERTEX_ATTRIB_ARRAY14_NV );
				break;
*/
			default:
				break;
		}

		m_bTangentArrayEnabled = false;
	}

	if( pkVertexBuffer->m_pkBinormalElement )
	{
		switch( Shader::s_eVSTarget )
		{
			case Shader::NEPT_GL_ARBVP_1:
			{
				if( pkVertexBuffer->m_pkTangentElement->m_uiType == VertexElement::COLOR32 )
					neoglVertexAttribPointerARB( 15, 4, GL_UNSIGNED_BYTE, GL_TRUE, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				else
					neoglVertexAttribPointerARB( 15, pkVertexBuffer->m_pkTangentElement->m_uiType + 1, GL_FLOAT, GL_FALSE, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				neoglEnableVertexAttribArrayARB( 15 );
                break;
			}
/*
			case NEPT_NVVP_30:
			{
				neoglVertexAttribPointerNV( 15, pkVertexBuffer->m_pkTangentElement->m_uiType + 1, GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkTangentElement->m_uiOffset );
				glEnableClientState( GL_VERTEX_ATTRIB_ARRAY15_NV );
				break;
			}
*/
			default:
				break;
		}

		m_bBinormalArrayEnabled = true;
	}
	else if( m_bBinormalArrayEnabled )
	{
		switch( Shader::s_eVSTarget )
		{
			case Shader::NEPT_GL_ARBVP_1:
			{
				neoglDisableVertexAttribArrayARB( 15 );
				break;
			}
/*
			case CG_PROFILE_VP20:
			case CG_PROFILE_VP30:
				glDisableClientState( GL_VERTEX_ATTRIB_ARRAY15_NV );
				break;
*/
			default:
				break;
		}

		m_bBinormalArrayEnabled = false;
	}

	if( pkVertexBuffer->m_pkFogElement )
	{
		neoglFogCoordPointerEXT( GL_FLOAT, iStride, pucPtr + pkVertexBuffer->m_pkFogElement->m_uiOffset );

		if( !m_bFogCoordArrayEnabled )
		{
			glEnableClientState( GL_FOG_COORDINATE_ARRAY_EXT );
			m_bFogCoordArrayEnabled = true;
		}
	}
	else if( m_bFogCoordArrayEnabled )
	{
		glDisableClientState( GL_FOG_COORDINATE_ARRAY_EXT );
		m_bFogCoordArrayEnabled = false;
	}
}


void VertexBufferManager::SetTexLayerPointer( VertexBufferGL *pkVertexBuffer, unsigned int uiTexUnit, unsigned int uiUVLayer, bool bDisable )
{
	if( !bDisable && pkVertexBuffer && pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ] )
	{
		TextureUnit::SetActiveTextureUnit( uiTexUnit );
		glTexCoordPointer( pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ]->m_uiType + 1, GL_FLOAT, pkVertexBuffer->GetVertexSize(), ((const unsigned char*)pkVertexBuffer->GetRenderData()) + pkVertexBuffer->m_pkTexCoordElement[ uiUVLayer ]->m_uiOffset );

		if( !m_bTexCoordArrayEnabled[ uiTexUnit ] )
		{
			glEnableClientState( GL_TEXTURE_COORD_ARRAY );
			m_bTexCoordArrayEnabled[ uiTexUnit ] = true;
		}
	}
	else if( m_bTexCoordArrayEnabled[ uiTexUnit ] )
	{
		TextureUnit::SetActiveTextureUnit( uiTexUnit );
		glDisableClientState( GL_TEXTURE_COORD_ARRAY );
		m_bTexCoordArrayEnabled[ uiTexUnit ] = false;
	}
}


};
See more files for this project here