chunk.cpp from NeoEngineNG at Krugle

Show chunk.cpp syntax highlighted

/***************************************************************************
                        chunk.cpp  -  ABT room chunk
                             -------------------
    begin                : Thu Feb 08 2005
    copyright            : (C) 2005 by Anders Dahnielson
    email                : anderss@dahnnielson.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.

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

#include "room.h"
#include "chunk.h"

#include <neochunkio/chunktype.h>
#include <neochunkio/scenenode.h>
#include <neochunkio/polygonbuffer.h>
#include <neochunkio/vertexbuffer.h>
#include <neochunkio/material.h>
#include <neochunkio/stdstring.h>
#include <neochunkio/integer.h>
#include <neochunkio/bool.h>

#include <neoengine/logstream.h>

using namespace std;
using namespace NeoEngine;
using namespace NeoChunkIO;

namespace NeoABT
{

#ifdef HAVE_NEOCHUNKIO


int ABTGeometryChunk::ParseData( unsigned int uiFlags, FileManager *pkFileManager )
{
	Chunk *pkChunk;

	// Find vertex buffer index
	if( ( pkChunk = FindChunk( "vertexbuffer", ChunkType::INTEGER, -1 ) ) )
		m_iVertexBuffer = dynamic_cast< IntChunk* >( pkChunk )->m_iData;
	else
	{
		neolog << LogLevel( ERROR ) << "*** Invalid ABT geometry chunk: No vertex buffer index" << endl;
		return -1;
	}

	// Find polygon buffer
	if( ( pkChunk = FindChunk( "", ChunkType::POLYGONBUFFER, -1 ) ) )
		m_pkPolygonBuffer = dynamic_cast< PolygonBufferChunk* >( pkChunk )->m_pkBuffer;
	else
	{
		neolog << LogLevel( ERROR ) << "*** Invalid ABT geometry chunk: No polygon buffer" << endl;
		return -1;
	}

	// Find material
	if( ( pkChunk = FindChunk( "", ChunkType::MATERIAL, -1 ) ) )
		m_pkMaterial = dynamic_cast< MaterialChunk* >( pkChunk )->m_pkMaterial;
	else
	{
		neolog << LogLevel( ERROR ) << "*** Invalid ABT geometry chunk: No material" << endl;
		return -1;
	}

	return 1;
}


int ABTRoomChunk::ParseData( unsigned int uiFlags, FileManager *pkFileManager )
{
	RoomChunk::ParseData( uiFlags, pkFileManager );

	ABTRoom *pkRoom = new ABTRoom;
	m_pkRoom          = pkRoom;

	// Find room name
	Chunk *pkChunk;

	if( ( pkChunk = FindChunk( "name", ChunkType::STRING, -1 ) ) )
		pkRoom->SetName( dynamic_cast< StringChunk* >( pkChunk )->m_strData );

	// Find vertex buffer chunks
	vector<Chunk*> vpkVBufChunks;

	FindChunks( "", ChunkType::VERTEXBUFFER, &vpkVBufChunks, false );

	vector<Chunk*>::iterator ppkChunk = vpkVBufChunks.begin();
	vector<Chunk*>::iterator ppkEnd   = vpkVBufChunks.end();

	if( ppkChunk == ppkEnd )
	{
		neolog << LogLevel( ERROR ) << "*** Invalid ABT room chunk: No vertex buffers" << endl;
		return -1;
	}

	m_vpkVertexBuffers.resize( vpkVBufChunks.size() );
	
	for( unsigned int uiVertexBuffer = 0; ppkChunk != ppkEnd; ++ppkChunk, ++uiVertexBuffer )
		m_vpkVertexBuffers[ uiVertexBuffer ] = dynamic_cast< VertexBufferChunk* >( *ppkChunk )->m_pkBuffer;

	// Find ABT geometry chunks
	vector<Chunk*> vpkChunks;
	vector<ABTGeometryChunk*> vpkGeometryChunks;

	FindChunks( "", ChunkType::ABTGEOM, &vpkChunks, false );

	unsigned int uiGeom;
	unsigned int uiNumGeoms  = vpkChunks.size();

	vpkGeometryChunks.resize( uiNumGeoms );

	for( uiGeom = 0; uiGeom < uiNumGeoms; ++uiGeom )
		vpkGeometryChunks[ uiGeom ] = dynamic_cast< ABTGeometryChunk* >( vpkChunks[ uiGeom ] );

	vpkChunks.clear();

	// Add geometry
 	for( uiGeom = 0; uiGeom < uiNumGeoms; ++uiGeom )
 	{
 		unsigned int uiVBuff = vpkGeometryChunks[ uiGeom ]->m_iVertexBuffer;

		VertexBufferPtr pkVert = m_vpkVertexBuffers[ uiVBuff ];
		PolygonBufferPtr pkPoly = vpkGeometryChunks[ uiGeom ]->m_pkPolygonBuffer;
 		MaterialPtr pkMat = vpkGeometryChunks[ uiGeom ]->m_pkMaterial;

		pkRoom->AddGeometry(pkPoly, pkVert, pkMat);
 	}

	// Find scene nodes
	vector<Chunk*> vpkSceneNodeChunks;

	FindChunks( "", ChunkType::SCENENODE, &vpkSceneNodeChunks, false );

	unsigned int uiNode;
	unsigned int uiEnd = vpkSceneNodeChunks.size();

	for( uiNode = 0; uiNode < uiEnd; ++uiNode )
	{
		SceneNodeChunk *pkNodeChunk = dynamic_cast< SceneNodeChunk* >( vpkSceneNodeChunks[ uiNode ] );

		bool bGlobal = false;

		if( ( pkChunk = pkNodeChunk->FindChunk( "global", ChunkType::BOOL, -1 ) ) )
			bGlobal = dynamic_cast< BoolChunk* >( pkChunk )->m_bData;

		if( bGlobal )
			pkRoom->AttachGlobalNode( pkNodeChunk->m_pkNode );
		else
			pkRoom->AttachNode( pkNodeChunk->m_pkNode );

		pkNodeChunk->m_pkNode = 0;
	}

	return 1;
}


#endif


};
See more files for this project here