/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "model.h"
#include "globaldefs.h"

#include "picomodel.h"

#include "iarchive.h"
#include "idatastream.h"
#include "imodel.h"
#include "modelskin.h"

#include "cullable.h"
#include "renderable.h"
#include "selectable.h"

#include "math/frustum.h"
#include "string/string.h"
#include "generic/static.h"
#include "shaderlib.h"
#include "scenelib.h"
#include "instancelib.h"
#include "transformlib.h"
#include "traverselib.h"
#include "render.h"

class VectorLightList : public LightList
{
typedef std::vector<const RendererLight*> Lights;
Lights m_lights;
public:
void addLight( const RendererLight& light ){
	m_lights.push_back( &light );
}
void clear(){
	m_lights.clear();
}
void evaluateLights() const {
}
void lightsChanged() const {
}
void forEachLight( const RendererLightCallback& callback ) const {
	for ( Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i )
	{
		callback( *( *i ) );
	}
}
};

class PicoSurface :
	public OpenGLRenderable
{
AABB m_aabb_local;
CopiedString m_shader;
Shader* m_state;

Array<ArbitraryMeshVertex> m_vertices;
Array<RenderIndex> m_indices;

public:

PicoSurface(){
	constructNull();
	CaptureShader();
}
PicoSurface( picoSurface_t* surface ){
	CopyPicoSurface( surface );
	CaptureShader();
}
~PicoSurface(){
	ReleaseShader();
}

void render( RenderStateFlags state ) const {
	if ( ( state & RENDER_BUMP ) != 0 ) {
		if ( GlobalShaderCache().useShaderLanguage() ) {
			glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
			glVertexAttribPointerARB( c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
			glVertexAttribPointerARB( c_attr_Tangent, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
			glVertexAttribPointerARB( c_attr_Binormal, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
		}
		else
		{
			glVertexAttribPointerARB( 11, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
			glVertexAttribPointerARB( 8, 2, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
			glVertexAttribPointerARB( 9, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->tangent );
			glVertexAttribPointerARB( 10, 3, GL_FLOAT, 0, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->bitangent );
		}
	}
	else
	{
		glNormalPointer( GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->normal );
		glTexCoordPointer( 2, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->texcoord );
	}
	glVertexPointer( 3, GL_FLOAT, sizeof( ArbitraryMeshVertex ), &m_vertices.data()->vertex );
	glDrawElements( GL_TRIANGLES, GLsizei( m_indices.size() ), RenderIndexTypeID, m_indices.data() );

#if GDEF_DEBUG
	GLfloat modelview[16];
	glGetFloatv( GL_MODELVIEW_MATRIX, modelview ); // I know this is slow as hell, but hey - we're in _DEBUG
	Matrix4 modelview_inv(
		modelview[0], modelview[1], modelview[2], modelview[3],
		modelview[4], modelview[5], modelview[6], modelview[7],
		modelview[8], modelview[9], modelview[10], modelview[11],
		modelview[12], modelview[13], modelview[14], modelview[15] );
	matrix4_full_invert( modelview_inv );
	Matrix4 modelview_inv_transposed = matrix4_transposed( modelview_inv );

	glBegin( GL_LINES );

	for ( Array<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
	{
		Vector3 normal = normal3f_to_vector3( ( *i ).normal );
		normal = matrix4_transformed_direction( modelview_inv, vector3_normalised( matrix4_transformed_direction( modelview_inv_transposed, normal ) ) ); // do some magic
		Vector3 normalTransformed = vector3_added( vertex3f_to_vector3( ( *i ).vertex ), vector3_scaled( normal, 8 ) );
		glVertex3fv( vertex3f_to_array( ( *i ).vertex ) );
		glVertex3fv( vector3_to_array( normalTransformed ) );
	}
	glEnd();
#endif
}

VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
	return test.TestAABB( m_aabb_local, localToWorld );
}

const AABB& localAABB() const {
	return m_aabb_local;
}

void render( Renderer& renderer, const Matrix4& localToWorld, Shader* state ) const {
	renderer.SetState( state, Renderer::eFullMaterials );
	renderer.addRenderable( *this, localToWorld );
}

void render( Renderer& renderer, const Matrix4& localToWorld ) const {
	render( renderer, localToWorld, m_state );
}

void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
	test.BeginMesh( localToWorld );

	SelectionIntersection best;
	testSelect( test, best );
	if ( best.valid() ) {
		selector.addIntersection( best );
	}
}

const char* getShader() const {
	return m_shader.c_str();
}
Shader* getState() const {
	return m_state;
}

private:

void CaptureShader(){
	m_state = GlobalShaderCache().capture( m_shader.c_str() );
}
void ReleaseShader(){
	GlobalShaderCache().release( m_shader.c_str() );
}

void UpdateAABB(){
	m_aabb_local = AABB();
	for ( std::size_t i = 0; i < m_vertices.size(); ++i )
		aabb_extend_by_point_safe( m_aabb_local, reinterpret_cast<const Vector3&>( m_vertices[i].vertex ) );


	for ( Array<RenderIndex>::iterator i = m_indices.begin(); i != m_indices.end(); i += 3 )
	{
		ArbitraryMeshVertex& a = m_vertices[*( i + 0 )];
		ArbitraryMeshVertex& b = m_vertices[*( i + 1 )];
		ArbitraryMeshVertex& c = m_vertices[*( i + 2 )];

		ArbitraryMeshTriangle_sumTangents( a, b, c );
	}

	for ( Array<ArbitraryMeshVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i )
	{
		vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).tangent ) );
		vector3_normalise( reinterpret_cast<Vector3&>( ( *i ).bitangent ) );
	}
}

void testSelect( SelectionTest& test, SelectionIntersection& best ){
	test.TestTriangles(
		VertexPointer( VertexPointer::pointer( &m_vertices.data()->vertex ), sizeof( ArbitraryMeshVertex ) ),
		IndexPointer( m_indices.data(), IndexPointer::index_type( m_indices.size() ) ),
		best
		);
}

void CopyPicoSurface( picoSurface_t* surface ){
	picoShader_t* shader = PicoGetSurfaceShader( surface );
	if ( shader == 0 ) {
		m_shader = "";
	}
	else{
		m_shader = PicoGetShaderName( shader );
	}

	m_vertices.resize( PicoGetSurfaceNumVertexes( surface ) );
	m_indices.resize( PicoGetSurfaceNumIndexes( surface ) );

	for ( std::size_t i = 0; i < m_vertices.size(); ++i )
	{
		picoVec_t* xyz = PicoGetSurfaceXYZ( surface, int(i) );
		m_vertices[i].vertex = vertex3f_from_array( xyz );

		picoVec_t* normal = PicoGetSurfaceNormal( surface, int(i) );
		m_vertices[i].normal = normal3f_from_array( normal );

		picoVec_t* st = PicoGetSurfaceST( surface, 0, int(i) );
		m_vertices[i].texcoord = TexCoord2f( st[0], st[1] );

#if 0
		picoVec_t* color = PicoGetSurfaceColor( surface, 0, int(i) );
		m_vertices[i].colour = Colour4b( color[0], color[1], color[2], color[3] );
#endif
	}

	picoIndex_t* indexes = PicoGetSurfaceIndexes( surface, 0 );
	for ( std::size_t j = 0; j < m_indices.size(); ++j )
		m_indices[ j ] = indexes[ j ];

	UpdateAABB();
}

void constructQuad( std::size_t index, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal ){
	m_vertices[index * 4 + 0] = ArbitraryMeshVertex(
		vertex3f_for_vector3( a ),
		normal3f_for_vector3( normal ),
		texcoord2f_from_array( aabb_texcoord_topleft )
		);
	m_vertices[index * 4 + 1] = ArbitraryMeshVertex(
		vertex3f_for_vector3( b ),
		normal3f_for_vector3( normal ),
		texcoord2f_from_array( aabb_texcoord_topright )
		);
	m_vertices[index * 4 + 2] = ArbitraryMeshVertex(
		vertex3f_for_vector3( c ),
		normal3f_for_vector3( normal ),
		texcoord2f_from_array( aabb_texcoord_botright )
		);
	m_vertices[index * 4 + 3] = ArbitraryMeshVertex(
		vertex3f_for_vector3( d ),
		normal3f_for_vector3( normal ),
		texcoord2f_from_array( aabb_texcoord_botleft )
		);
}

void constructNull(){
	AABB aabb( Vector3( 0, 0, 0 ), Vector3( 8, 8, 8 ) );

	Vector3 points[8];
	aabb_corners( aabb, points );

	m_vertices.resize( 24 );

	constructQuad( 0, points[2], points[1], points[5], points[6], aabb_normals[0] );
	constructQuad( 1, points[1], points[0], points[4], points[5], aabb_normals[1] );
	constructQuad( 2, points[0], points[1], points[2], points[3], aabb_normals[2] );
	constructQuad( 3, points[0], points[3], points[7], points[4], aabb_normals[3] );
	constructQuad( 4, points[3], points[2], points[6], points[7], aabb_normals[4] );
	constructQuad( 5, points[7], points[6], points[5], points[4], aabb_normals[5] );

	m_indices.resize( 36 );

	RenderIndex indices[36] = {
		0,  1,  2,  0,  2,  3,
		4,  5,  6,  4,  6,  7,
		8,  9, 10,  8, 10, 11,
		12, 13, 14, 12, 14, 15,
		16, 17, 18, 16, 18, 19,
		20, 21, 22, 10, 22, 23,
	};


	Array<RenderIndex>::iterator j = m_indices.begin();
	for ( RenderIndex* i = indices; i != indices + ( sizeof( indices ) / sizeof( RenderIndex ) ); ++i )
	{
		*j++ = *i;
	}

	m_shader = "";

	UpdateAABB();
}
};


typedef std::pair<CopiedString, int> PicoModelKey;


class PicoModel :
	public Cullable,
	public Bounded
{
typedef std::vector<PicoSurface*> surfaces_t;
surfaces_t m_surfaces;

AABB m_aabb_local;
public:
Callback<void()> m_lightsChanged;

PicoModel(){
	constructNull();
}
PicoModel( picoModel_t* model ){
	CopyPicoModel( model );
}
~PicoModel(){
	for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
		delete *i;
}

typedef surfaces_t::const_iterator const_iterator;

const_iterator begin() const {
	return m_surfaces.begin();
}
const_iterator end() const {
	return m_surfaces.end();
}
std::size_t size() const {
	return m_surfaces.size();
}

VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
	return test.TestAABB( m_aabb_local, localToWorld );
}

virtual const AABB& localAABB() const {
	return m_aabb_local;
}

void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, std::vector<Shader*> states ) const {
	for ( surfaces_t::const_iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
	{
		if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
			( *i )->render( renderer, localToWorld, states[i - m_surfaces.begin()] );
		}
	}
}

void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
	for ( surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i )
	{
		if ( ( *i )->intersectVolume( test.getVolume(), localToWorld ) != c_volumeOutside ) {
			( *i )->testSelect( selector, test, localToWorld );
		}
	}
}

private:
void CopyPicoModel( picoModel_t* model ){
	m_aabb_local = AABB();

	/* each surface on the model will become a new map drawsurface */
	int numSurfaces = PicoGetModelNumSurfaces( model );
	//%  SYs_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
	for ( int s = 0; s < numSurfaces; ++s )
	{
		/* get surface */
		picoSurface_t* surface = PicoGetModelSurface( model, s );
		if ( surface == 0 ) {
			continue;
		}

		/* only handle triangle surfaces initially (fixme: support patches) */
		if ( PicoGetSurfaceType( surface ) != PICO_TRIANGLES ) {
			continue;
		}

		/* fix the surface's normals */
		PicoFixSurfaceNormals( surface );

		PicoSurface* picosurface = new PicoSurface( surface );
		aabb_extend_by_aabb_safe( m_aabb_local, picosurface->localAABB() );
		m_surfaces.push_back( picosurface );
	}
}
void constructNull(){
	PicoSurface* picosurface = new PicoSurface();
	m_aabb_local = picosurface->localAABB();
	m_surfaces.push_back( picosurface );
}
};

inline void Surface_addLight( PicoSurface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light ){
	if ( light.testAABB( aabb_for_oriented_aabb( surface.localAABB(), localToWorld ) ) ) {
		lights.addLight( light );
	}
}

class PicoModelInstance :
	public scene::Instance,
	public Renderable,
	public SelectionTestable,
	public LightCullable,
	public SkinnedModel
{
class TypeCasts
{
InstanceTypeCastTable m_casts;
public:
TypeCasts(){
	InstanceContainedCast<PicoModelInstance, Bounded>::install( m_casts );
	InstanceContainedCast<PicoModelInstance, Cullable>::install( m_casts );
	InstanceStaticCast<PicoModelInstance, Renderable>::install( m_casts );
	InstanceStaticCast<PicoModelInstance, SelectionTestable>::install( m_casts );
	InstanceStaticCast<PicoModelInstance, SkinnedModel>::install( m_casts );
}
InstanceTypeCastTable& get(){
	return m_casts;
}
};

PicoModel& m_picomodel;

const LightList* m_lightList;
typedef Array<VectorLightList> SurfaceLightLists;
SurfaceLightLists m_surfaceLightLists;

class Remap
{
public:
CopiedString first;
Shader* second;
Remap() : second( 0 ){
}
};
typedef Array<Remap> SurfaceRemaps;
SurfaceRemaps m_skins;

PicoModelInstance( const PicoModelInstance& );
PicoModelInstance operator=( const PicoModelInstance& );
public:
typedef LazyStatic<TypeCasts> StaticTypeCasts;

void* m_test;

Bounded& get( NullType<Bounded>){
	return m_picomodel;
}
Cullable& get( NullType<Cullable>){
	return m_picomodel;
}

void lightsChanged(){
	m_lightList->lightsChanged();
}
typedef MemberCaller<PicoModelInstance, void(), &PicoModelInstance::lightsChanged> LightsChangedCaller;

void constructRemaps(){
	ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
	ModelSkin* skin = NodeTypeCast<ModelSkin>::cast( path().parent() );
	if ( skin != 0 && skin->realised() ) {
		SurfaceRemaps::iterator j = m_skins.begin();
		for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j )
		{
			const char* remap = skin->getRemap( ( *i )->getShader() );
			if ( !string_empty( remap ) ) {
				( *j ).first = remap;
				( *j ).second = GlobalShaderCache().capture( remap );
			}
			else
			{
				( *j ).second = 0;
			}
		}
		SceneChangeNotify();
	}
}
void destroyRemaps(){
	ASSERT_MESSAGE( m_skins.size() == m_picomodel.size(), "ERROR" );
	for ( SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i )
	{
		if ( ( *i ).second != 0 ) {
			GlobalShaderCache().release( ( *i ).first.c_str() );
			( *i ).second = 0;
		}
	}
}
void skinChanged(){
	destroyRemaps();
	constructRemaps();
}

PicoModelInstance( const scene::Path& path, scene::Instance* parent, PicoModel& picomodel ) :
	Instance( path, parent, this, StaticTypeCasts::instance().get() ),
	m_picomodel( picomodel ),
	m_surfaceLightLists( m_picomodel.size() ),
	m_skins( m_picomodel.size() ){
	m_lightList = &GlobalShaderCache().attach( *this );
	m_picomodel.m_lightsChanged = LightsChangedCaller( *this );

	Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );

	constructRemaps();
}
~PicoModelInstance(){
	destroyRemaps();

	Instance::setTransformChangedCallback( Callback<void()>() );

	m_picomodel.m_lightsChanged = Callback<void()>();
	GlobalShaderCache().detach( *this );
}

void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
	SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
	SurfaceRemaps::const_iterator k = m_skins.begin();
	for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j, ++k )
	{
		if ( ( *i )->intersectVolume( volume, localToWorld ) != c_volumeOutside ) {
			renderer.setLights( *j );
			( *i )->render( renderer, localToWorld, ( *k ).second != 0 ? ( *k ).second : ( *i )->getState() );
		}
	}
}

void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
	m_lightList->evaluateLights();

	render( renderer, volume, Instance::localToWorld() );
}
void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
	renderSolid( renderer, volume );
}

void testSelect( Selector& selector, SelectionTest& test ){
	m_picomodel.testSelect( selector, test, Instance::localToWorld() );
}

bool testLight( const RendererLight& light ) const {
	return light.testAABB( worldAABB() );
}
void insertLight( const RendererLight& light ){
	const Matrix4& localToWorld = Instance::localToWorld();
	SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
	for ( PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i )
	{
		Surface_addLight( *( *i ), *j++, localToWorld, light );
	}
}
void clearLights(){
	for ( SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i )
	{
		( *i ).clear();
	}
}
};

class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable
{
class TypeCasts
{
NodeTypeCastTable m_casts;
public:
TypeCasts(){
	NodeStaticCast<PicoModelNode, scene::Instantiable>::install( m_casts );
}
NodeTypeCastTable& get(){
	return m_casts;
}
};


scene::Node m_node;
InstanceSet m_instances;
PicoModel m_picomodel;

public:
typedef LazyStatic<TypeCasts> StaticTypeCasts;

PicoModelNode() : m_node( this, this, StaticTypeCasts::instance().get() ){
}
PicoModelNode( picoModel_t* model ) : m_node( this, this, StaticTypeCasts::instance().get() ), m_picomodel( model ){
}

void release(){
	delete this;
}
scene::Node& node(){
	return m_node;
}

scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
	return new PicoModelInstance( path, parent, m_picomodel );
}
void forEachInstance( const scene::Instantiable::Visitor& visitor ){
	m_instances.forEachInstance( visitor );
}
void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
	m_instances.insert( observer, path, instance );
}
scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
	return m_instances.erase( observer, path );
}
};


#if 0

template<typename Key, typename Type>
class create_new
{
public:
static Type* construct( const Key& key ){
	return new Type( key );
}
static void destroy( Type* value ){
	delete value;
}
};

template<typename Key, typename Type, typename creation_policy = create_new<Key, Type> >
class cache_element : public creation_policy
{
public:
inline cache_element() : m_count( 0 ), m_value( 0 ) {}
inline ~cache_element(){
	ASSERT_MESSAGE( m_count == 0, "destroyed a reference before it was released\n" );
	if ( m_count > 0 ) {
		destroy();
	}
}
inline Type* capture( const Key& key ){
	if ( ++m_count == 1 ) {
		construct( key );
	}
	return m_value;
}
inline void release(){
	ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
	if ( --m_count == 0 ) {
		destroy();
	}
}
inline bool empty(){
	return m_count == 0;
}
inline void refresh( const Key& key ){
	m_value->refresh( key );
}
private:
inline void construct( const Key& key ){
	m_value = creation_policy::construct( key );
}
inline void destroy(){
	creation_policy::destroy( m_value );
}

std::size_t m_count;
Type* m_value;
};

class create_picomodel
{
typedef PicoModelKey key_type;
typedef PicoModel value_type;
public:
static value_type* construct( const key_type& key ){
	picoModel_t* picomodel = PicoLoadModel( const_cast<char*>( key.first.c_str() ), key.second );
	value_type* value = new value_type( picomodel );
	PicoFreeModel( picomodel );
	return value;
}
static void destroy( value_type* value ){
	delete value;
}
};

#include <map>

class ModelCache
{
typedef PicoModel value_type;

public:
typedef PicoModelKey key_type;
typedef cache_element<key_type, value_type, create_picomodel> elem_type;
typedef std::map<key_type, elem_type> cache_type;

value_type* capture( const key_type& key ){
	return m_cache[key].capture( key );
}
void release( const key_type& key ){
	m_cache[key].release();
}

private:
cache_type m_cache;
};

ModelCache g_model_cache;



typedef struct remap_s {
	char m_remapbuff[64 + 1024];
	char *original;
	char *remap;
} remap_t;

class RemapWrapper :
	public Cullable,
	public Bounded
{
public:
RemapWrapper( const char* name ){
	parse_namestr( name );

	m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );

	construct_shaders();
}
virtual ~RemapWrapper(){
	g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );

	for ( shaders_t::iterator i = m_shaders.begin(); i != m_shaders.end(); ++i )
	{
		GlobalShaderCache().release( ( *i ).c_str() );
	}

	for ( remaps_t::iterator j = m_remaps.begin(); j != m_remaps.end(); ++j )
	{
		delete ( *j );
	}
}

VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
	return m_model->intersectVolume( test, localToWorld );
}

virtual const AABB& localAABB() const {
	return m_model->localAABB();
}

void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
	m_model->render( renderer, volume, localToWorld, m_states );
}

void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
	m_model->testSelect( selector, test, localToWorld );
}

private:
void add_remap( const char *remap ){
	const char *ch;
	remap_t *pRemap;

	ch = remap;

	while ( *ch && *ch != ';' )
		ch++;

	if ( *ch == '\0' ) {
		// bad remap
		globalErrorStream() << "WARNING: Shader _remap key found in a model entity without a ; character\n";
	}
	else {
		pRemap = new remap_t;

		strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );

		pRemap->m_remapbuff[ch - remap] = '\0';

		pRemap->original = pRemap->m_remapbuff;
		pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;

		m_remaps.push_back( pRemap );
	}
}

void parse_namestr( const char *name ){
	const char *ptr, *s;
	bool hasName, hasFrame;

	hasName = hasFrame = false;

	m_frame = 0;

	for ( s = ptr = name; ; ++ptr )
	{
		if ( !hasName && ( *ptr == ':' || *ptr == '\0' ) ) {
			// model name
			hasName = true;
			m_name = CopiedString( s, ptr );
			s = ptr + 1;
		}
		else if ( *ptr == '?' || *ptr == '\0' ) {
			// model frame
			hasFrame = true;
			m_frame = atoi( CopiedString( s, ptr ).c_str() );
			s = ptr + 1;
		}
		else if ( *ptr == '&' || *ptr == '\0' ) {
			// a remap
			add_remap( CopiedString( s, ptr ).c_str() );
			s = ptr + 1;
		}

		if ( *ptr == '\0' ) {
			break;
		}
	}
}

void construct_shaders(){
	const char* global_shader = shader_for_remap( "*" );

	m_shaders.reserve( m_model->size() );
	m_states.reserve( m_model->size() );
	for ( PicoModel::iterator i = m_model->begin(); i != m_model->end(); ++i )
	{
		const char* shader = shader_for_remap( ( *i )->getShader() );
		m_shaders.push_back(
			( shader[0] != '\0' )
			? shader
			: ( global_shader[0] != '\0' )
			? global_shader
			: ( *i )->getShader() );
		m_states.push_back( GlobalShaderCache().capture( m_shaders.back().c_str() ) );
	}
}

inline const char* shader_for_remap( const char* remap ){
	for ( remaps_t::iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
	{
		if ( shader_equal( remap, ( *i )->original ) ) {
			return ( *i )->remap;
		}
	}
	return "";
}

CopiedString m_name;
int m_frame;
PicoModel* m_model;

typedef std::vector<remap_t*> remaps_t;
remaps_t m_remaps;
typedef std::vector<CopiedString> shaders_t;
shaders_t m_shaders;
typedef std::vector<Shader*> states_t;
states_t m_states;
};

class RemapWrapperInstance : public scene::Instance, public Renderable, public SelectionTestable
{
RemapWrapper& m_remapwrapper;
public:
RemapWrapperInstance( const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper ) : Instance( path, parent ), m_remapwrapper( remapwrapper ){
	scene::Instance::m_cullable = &m_remapwrapper;
	scene::Instance::m_render = this;
	scene::Instance::m_select = this;
}

void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
	m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
}
void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
	renderSolid( renderer, volume );
}

void testSelect( Selector& selector, SelectionTest& test ){
	m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
}
};

class RemapWrapperNode : public scene::Node::Symbiot, public scene::Instantiable
{
scene::Node m_node;
typedef RemapWrapperInstance instance_type;
InstanceSet m_instances;
RemapWrapper m_remapwrapper;
public:
RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
	m_node.m_instance = this;
}

void release(){
	delete this;
}
scene::Node& node(){
	return m_node;
}

scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
	return new instance_type( path, parent, m_remapwrapper );
}
void forEachInstance( const scene::Instantiable::Visitor& visitor ){
	m_instances.forEachInstance( visitor );
}
void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
	m_instances.insert( observer, path, instance );
}
scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
	return m_instances.erase( observer, path );
}
};

scene::Node& LoadRemapModel( const char* name ){
	return ( new RemapWrapperNode( name ) )->node();
}

#endif


size_t picoInputStreamReam( void* inputStream, unsigned char* buffer, size_t length ){
	return reinterpret_cast<InputStream*>( inputStream )->read( buffer, length );
}

scene::Node& loadPicoModel( const picoModule_t* module, ArchiveFile& file ){
	picoModel_t* model = PicoModuleLoadModelStream( module, &file.getInputStream(), picoInputStreamReam, file.size(), 0, file.getName() );
	PicoModelNode* modelNode = new PicoModelNode( model );
	PicoFreeModel( model );
	return modelNode->node();
}
