//===========================================================================
// Copyright (C) 2002 Radical Entertainment Ltd.  All rights reserved.
//
// Component:   AnimDynaPhysLoader
//
// Description: Loader for instanced, animated, dynaphys DSG objects
//
// Authors:     Michael Riegger
//
//===========================================================================

//---------------------------------------------------------------------------
// Includes
//===========================================================================
#include <constants/chunks.h>
#include <constants/chunkids.hpp>
#include <render/Loaders/AnimDynaPhysLoader.h>
#include <render/DSG/InstAnimDynaPhysDSG.h>
#include <atc/atcmanager.h>
#include <constants/srrchunks.h>
#include <memory/srrmemory.h>
#include <simcollision/collisionobject.hpp>
#include <simphysics/physicsobject.hpp>
#include <render/Loaders/GeometryWrappedLoader.h>
#include <p3d/anim/multicontroller.hpp>
#include <render/Loaders/AllWrappers.h>
#include <render/Loaders/BillboardWrappedLoader.h>
#include <p3d/anim/skeleton.hpp>
#include <p3d/anim/animate.hpp>
#include <p3d/anim/compositedrawable.hpp>
#include <p3d/chunkfile.hpp>
#include <p3d/inventory.hpp>
#include <render/AnimEntityDSGManager/AnimEntityDSGManager.h>
#include <render/DSG/StatePropDSG.h>
#include <stateprop/statepropdata.hpp>
#include <p3d/anim/animatedobject.hpp>
#include <constants/physprop.h>
#include <data/persistentworldmanager.h>
#include <main/game.h>
#include <radmath/random.hpp>
#ifndef RAD_RELEASE
#include <memory/propstats.h>
#endif

//===========================================================================
// Local Constants, Typedefs, and Macros
//===========================================================================

Map< tUID, tUID > AnimDynaPhysLoader::s_ShadowList;


//===========================================================================
// Global Data, Local Data, Local Classes
//===========================================================================



//===========================================================================
// Member Functions
//===========================================================================

//===========================================================================
// AnimDynaPhysLoader::AnimDynaPhysLoader
//===========================================================================
// Description:
//		AnimDynaPhysLoader ctor
//
// Constraints:
//
// Parameters:
//	
//
// Return:
//
//===========================================================================

AnimDynaPhysLoader::AnimDynaPhysLoader() : tSimpleChunkHandler(SRR2::ChunkID::INSTA_ANIM_DYNA_PHYS_DSG)
{

    mpListenerCB  = NULL;
    mUserData     = -1;

    if ( s_ShadowList.capacity() == 0 )
    {
        s_ShadowList.reserve( 20 );
    }
}

//===========================================================================
// AnimDynaPhysLoader::~AnimDynaPhysLoader
//===========================================================================
// Description:
//		AnimDynaPhysLoader dtor
//
// Constraints:
//
// Parameters:
//	
//
// Return:
//
//===========================================================================

AnimDynaPhysLoader::~AnimDynaPhysLoader()
{

}

//===========================================================================
// AnimDynaPhysLoader::LoadObject
//===========================================================================
// Description:
//		Loads an InstAnimDynaPhysDSG chunk and creates all the instances
//
// Constraints:
//		Expecting file format to be:
//		string name (max size 255)
//		long version
//		long hasalpha flag	
//			
//
// Parameters:
//		Chunk file, and store
//
// Return:
//		NULL, no final chunk going specifically into the inventory via return
//
//===========================================================================

tEntity* AnimDynaPhysLoader::LoadObject(tChunkFile* file, tEntityStore* store)
{
    IEntityDSG::msDeletionsSafe=true;
	// Grab the name
    char typeName[255];
    file->GetPString(typeName);

    // Quick test to see if we are dealing with an animated BV object
    int simAnimJoint = -1;
    if ( strstr ( typeName, "crate" ) != NULL )
        simAnimJoint = 3;
    else if ( strstr ( typeName, "vending" ) != NULL )
        simAnimJoint = 1;   
    else if ( strstr ( typeName, "l2_monkiesgag" ) != NULL )
        simAnimJoint = 1;
    else if ( strstr ( typeName, "l7_spider" ) != NULL )
        simAnimJoint = 1;


#ifndef RAD_RELEASE
    PropStats::StartTracking(typeName);
#endif

    int instanceCount = 0;

	// Grab version info
    int version = file->GetLong();
	// Grab the flag that tell us whether or not the object has alpha or not
    int hasAlpha = file->GetLong();

    // Does this chunk contain a subchunk for instances
    bool foundInstances = false;
    bool persistance = true;

    // Is this object a global entity (i.e. is it loaded once at level startup and
    // all subsequent instances are cloned off this thing?)
    StatePropDSG* globalStatepropEntity = static_cast<StatePropDSG*>(GetAllWrappers()->GetGlobalEntity(tName::MakeUID(typeName)));
    if(strstr(typeName, "phonestop_Shape"))
    {
        persistance = false;
    }
    bool haveGlobal = globalStatepropEntity != 0;
#ifndef RAD_RELEASE
    if ( haveGlobal )
    {
        rAssert( dynamic_cast< StatePropDSG* >( globalStatepropEntity ) != NULL );
    }
#endif
    CollisionAttributes*    pCollAttr   = NULL;
	AnimDynaPhysWrapper*	pWrappedObject = NULL;

    // Is this a mission prop?
    
    bool isMissionProp = IsMissionProp( typeName );


    while( file->ChunksRemaining() )
	{
		file->BeginChunk();
		switch(file->GetCurrentID())
		{
        case SRR2::ChunkID::ANIM_OBJ_DSG_WRAPPER:
            // We are loading a stateprop
            {
                if(!haveGlobal)
                {
                    HeapMgr()->PushHeap( GMA_TEMP );
                    AnimObjDSGWrapperLoader* pObjWrapperLoader = new AnimObjDSGWrapperLoader;
                    HeapMgr()->PopHeap( GMA_TEMP );
                    pWrappedObject = (AnimDynaPhysWrapper*) pObjWrapperLoader->LoadObject( file, store );
                    pWrappedObject->AddRef ();
                    pObjWrapperLoader->ReleaseVerified();
                }
                m_IsStateProp = true;
            }
            break;

		case SRR2::ChunkID::ANIM_DSG_WRAPPER:
			{
                if(!haveGlobal)
                {
				    // This is the wrapped object and contains a whole load of crap, meshes, comp drawables, billboards
				    // load them all
				    // Format of the wrapped object is 
				    // string name
				    // ULONG version
				    // ULONG hasalpha
			    //	pWrappedObject = new (GMA_TEMP ) WrappedObject;
			    //	LoadAnimWrapper( file, store, pWrappedObject );				
    				
                    HeapMgr()->PushHeap( GMA_TEMP );
				    AnimDynaPhysWrapperLoader* pWrapperLoader = new AnimDynaPhysWrapperLoader;
                    HeapMgr()->PopHeap( GMA_TEMP );

				    pWrappedObject = (AnimDynaPhysWrapper*) pWrapperLoader->LoadObject( file, store );
                    pWrappedObject->AddRef ();
				    pWrapperLoader->Release();
                }
                m_IsStateProp = false;
			}
			break;
			// Relies on ObjectAttributes and the Wrapped DSG object being loaded first

   		case SRR2::ChunkID::OBJECT_ATTRIBUTES:
			{
                if(!haveGlobal)
                {
                    rAssert( pWrappedObject != NULL );
                    // Relies on the Wrapped Object being loaded first
                    int classType = file->GetLong();
                    int physPropID = file->GetLong();
                    char tempsound [64];

                    file->GetString(tempsound); //Chuck: Reading the new sound properties since we dont use the sound returned from the ATC manager.

                    float volume;
                    if ( classType == PROP_MOVEABLE || 
                        classType == PROP_BREAKABLE ||
                        classType == PROP_ONETIME_MOVEABLE ||
                        classType == 8 )
                    {
                        volume = pWrappedObject->GetVolume();
                    }
                    else 
                    {
                        volume = 0.0f;
                    }
                    pCollAttr = GetATCManager()->CreateCollisionAttributes(classType, physPropID, volume);
                    pCollAttr->AddRef ();
                    pCollAttr->SetSound(tempsound); //Chuck: Setting the CollAttr to use the correct sound from the OTC chunk.
                }
			}
			break;

		case SRR2::ChunkID::INSTANCES:
            {
                foundInstances = true;

                //Instances >> Scenegraph
                file->BeginChunk();
                //Scenegraph >> ScenegraphRoot
                file->BeginChunk();
                //ScenegraphRoot >> ScenegraphBranch
                file->BeginChunk();
                //ScenegraphBranch >> ScenegraphTransform
                file->BeginChunk();

                //ScenegraphTransform >> real ScenegraphTransform
                //f->BeginChunk();

                while( file->ChunksRemaining() )
                {
                    instanceCount++;


                    file->BeginChunk();
                    char name[256];
                    file->GetPString(name);
                    int numChild = file->GetLong();

					rmt::Matrix matrix;
                    file->GetData( &matrix,16, tFile::DWORD );

                    if ( m_IsStateProp ) 
                    {
                        short persistentID = -1;
                        if(persistance && ((haveGlobal && globalStatepropEntity->GetCollisionAttributes()->GetClasstypeid()) || (!haveGlobal && ((pCollAttr->GetClasstypeid() == PROP_BREAKABLE) || (pCollAttr->GetClasstypeid() == PROP_MOVEABLE)))))
                        {
                            if ( isMissionProp == false )
                                persistentID = GetPersistentWorldManager()->GetPersistentObjectID( tEntity::MakeUID( file->GetFilename() ),tEntity::MakeUID(typeName) );
                            else
                                persistentID = -1;
                        }
                        if( persistentID >= -1 )
                        {
                            StatePropDSG* pStatePropDSG = NULL;

                            // Should we clone off the global entity (if it exists?)
                            if (haveGlobal)
                            {
                                pStatePropDSG = globalStatepropEntity->Clone( name, matrix );
                            }
                            else
                            {
                                rAssert( pCollAttr != NULL );
                                rAssert( pWrappedObject != NULL );
                                bool useSharedtPose = pWrappedObject->HasAnimation() ? false : true;                                                           
                                pStatePropDSG = new StatePropDSG(); 
                                pStatePropDSG->LoadSetup( pWrappedObject->GetStatePropData(), 0, matrix, pCollAttr, true, store, useSharedtPose, pWrappedObject->GetCollisionObject(), pWrappedObject->GetPhysicsObject() );
                                pStatePropDSG->SetName( name );
                                pStatePropDSG->SetSimJoint( simAnimJoint );
                            }

                

                            #ifndef FINAL
                            if( !haveGlobal && (pWrappedObject->GetStatePropData() == NULL))
                                {
                                    char outbuffer [255];
                                    sprintf(outbuffer,"Error: %s is missing a StateProp Chunk \n",pWrappedObject->GetName()); 
                                    rTuneAssertMsg( 0,outbuffer );
                                }
                            #endif


                            mpListenerCB->OnChunkLoaded( pStatePropDSG, mUserData, _id );
                            pStatePropDSG->mPersistentObjectID = persistentID;

                            // Check to see if there is a shadow associated with this object                           
                            tUID compDrawUID = pStatePropDSG->GetDrawableUID();

                            tUID shadowElementName = GetShadowElement( compDrawUID );
                            if ( shadowElementName != static_cast< tUID >( 0 ) )
                            {
                                pStatePropDSG->SetShadowElement( shadowElementName );
                            }

                            // place it into the inventory so that locators can access it by name
                            bool collision = store->TestCollision( pStatePropDSG->GetUID(), pStatePropDSG );
                            if( !collision )
                            {
                                store->Store( pStatePropDSG );
                            }
                            else
                            {
                                HandleCollision( pStatePropDSG );
                            }
                            // Lets offset the animation so that every crate or vending machine
                            // instance isn't jumping together
                            // Make the stateprop instances each start at a different point in time
                            static rmt::Randomizer randomizer( Game::GetRandomSeed () );
                            const float RANDOM_TIME_MS = 10000.0f;
                            // Advance animations by 0 - 10 seconds
                            float randomUpdateTime = randomizer.Float() * RANDOM_TIME_MS;
                            pStatePropDSG->AdvanceAnimation( randomUpdateTime );

                        }
                    }
                    else
                    {
                        InstAnimDynaPhysDSG* pAnimDSG = new InstAnimDynaPhysDSG();
                        // Make sure that each name is unique
                        // things like the powerboxes are set via lookup
                        pAnimDSG->SetName( name );

                        if( hasAlpha || pWrappedObject->HasAlpha() )
                        {
                            pAnimDSG->mTranslucent = true;
                        }
					    else
					    {
						    pAnimDSG->mTranslucent = false;
					    }
    
                        rAssert( pCollAttr != NULL );
                        pAnimDSG->LoadSetUp( pCollAttr, matrix, pWrappedObject->GetDrawable(), pWrappedObject->GetController(), store );
                        mpListenerCB->OnChunkLoaded( static_cast< InstDynaPhysDSG*> (pAnimDSG), mUserData, _id );
                            
                        // place it into the inventory so that locators can access it by name
                        store->Store( pAnimDSG );
                    }
                    file->EndChunk();  

#ifndef RAD_RELEASE
                    if ( instanceCount == 1 )
                    {
                        PropStats::StopTracking( typeName, 1 );
                        PropStats::StartTracking( typeName );
                        instanceCount = 0;
                    }
#endif


                }
                //ScenegraphBranch >> ScenegraphTransform
                file->EndChunk();
                //ScenegraphRoot >> ScenegraphBranch
                file->EndChunk();
                //Scenegraph >> ScenegraphRoot
                file->EndChunk();
                //Instances >> Scenegraph
                file->EndChunk();
            }
            break;


		default:
			rAssertMsg( false, "Unknown chunk in AnimatedDynaPhysDSG file");
			break;
		};
        file->EndChunk();
	}

    if(0&&!foundInstances && !haveGlobal )
    {
        // No instance chunk!
        // Therefore this MUST be a global entity
        // Dump it into the global entity list
        // so that subsequent instances of this type
        // will get cloned off the global entity instead of loading all this crap again
        //This must be a global entity.
        StatePropDSG* globalEntityStateProp = new StatePropDSG();
        rAssert(globalEntityStateProp);
        // Give this thing the name of the type

        bool useSharedtPose = pWrappedObject->HasAnimation() ? false : true;  
        rmt::Matrix identity;
        identity.Identity();
        globalEntityStateProp->LoadSetup( pWrappedObject->GetStatePropData(), 
                                          0, 
                                          identity, 
                                          pCollAttr, 
                                          false, 
                                          NULL, 
                                          useSharedtPose, 
                                          pWrappedObject->GetCollisionObject(), 
                                          pWrappedObject->GetPhysicsObject() );
        globalEntityStateProp->SetName( typeName );
        GetAllWrappers()->AddGlobalEntity( globalEntityStateProp );
        globalEntityStateProp->SetSimJoint( simAnimJoint );
        instanceCount++;
    }

    if( pWrappedObject != NULL)
    {
        pWrappedObject->ReleaseVerified ();
    }
    if ( pCollAttr != NULL )
    {
        pCollAttr->Release ();
    }

#ifndef RAD_RELEASE
    PropStats::StopTracking( typeName, instanceCount );
#endif


    IEntityDSG::msDeletionsSafe=false;
	return NULL;
}



//===========================================================================
// AnimDynaPhysLoader::SetRegdListener
//===========================================================================
// Description:
//		Informs the loader its listener is.
//
// Constraints:
//
// Parameters:
//		Pointer to the new listener. Integer for the data it sends to it OnChunkLoaded()
//
// Return:
//
//===========================================================================
void AnimDynaPhysLoader::SetRegdListener( ChunkListenerCallback* pListenerCB,
											int iUserData )
{
	//
	// Follow protocol; notify old Listener, that it has been 
	// "disconnected".
	//
	if( mpListenerCB != NULL )
	{
	  mpListenerCB->OnChunkLoaded( NULL, iUserData, 0 );
	}
	mpListenerCB  = pListenerCB;
	mUserData     = iUserData;
}

//===========================================================================
// AnimDynaPhysLoader::ModRegdListener
//===========================================================================
// Description:
//		Changes the data that gets sent to the listener
//
// Constraints:
//		Listener must have been set already via SetRegdListener
//
// Parameters:
//		Pointer to the listener. Integer holding the new data
//
// Return:
//
//===========================================================================
void AnimDynaPhysLoader::ModRegdListener( ChunkListenerCallback* pListenerCB, int iUserData )
{
   rAssert( pListenerCB == mpListenerCB );

   mUserData = iUserData;
}

void AnimDynaPhysLoader::SetShadowElement( const char* compDrawName, 
                                    const char* drawableElementName )
{
    s_ShadowList.insert( tName::MakeUID( compDrawName ), tName::MakeUID( drawableElementName ) );
}

void AnimDynaPhysLoader::ClearShadowList()
{
    s_ShadowList.clear();
}

tUID AnimDynaPhysLoader::GetShadowElement( tUID compDrawName )
{
    tUID elementName;
    Map< tUID, tUID >::const_iterator it;
    it = s_ShadowList.find( compDrawName );
    if ( it != s_ShadowList.end() )
        elementName = it->second;
    else
        elementName = 0;

    return elementName;
}



///////////////////////////////////////////////////////////
// AnimDyaPhysWrapperLoader methods
///////////////////////////////////////////////////////////

AnimDynaPhysWrapperLoader::AnimDynaPhysWrapperLoader() : tSimpleChunkHandler(SRR2::ChunkID::ANIM_DSG_WRAPPER)
{

    mpListenerCB  = NULL;
    mUserData     = -1;

	mpCompDLoader = new tCompositeDrawableLoader;
	mpCompDLoader->AddRef();
   
	mpMCLoader    = new tMultiControllerLoader;
    mpMCLoader->AddRef();

	mpSkelLoader = new tSkeletonLoader;
	mpSkelLoader->AddRef();
    
	mpAnimationLoader = new tAnimationLoader;
	mpAnimationLoader->AddRef();

	mpCollObjLoader = new sim::CollisionObjectLoader;
	mpCollObjLoader->AddRef();

	mpPhysObjLoader = new sim::PhysicsObjectLoader;
	mpPhysObjLoader->AddRef();

    mpFCLoader    = new tFrameControllerLoader;
    mpFCLoader->AddRef();
}

AnimDynaPhysWrapperLoader::~AnimDynaPhysWrapperLoader()
{
	mpCollObjLoader->ReleaseVerified();
	mpPhysObjLoader->ReleaseVerified();
	mpCompDLoader->ReleaseVerified();
	mpMCLoader->ReleaseVerified();
	mpSkelLoader->ReleaseVerified();
	mpAnimationLoader->ReleaseVerified();
	mpFCLoader->ReleaseVerified();
}



tEntity* AnimDynaPhysWrapperLoader::LoadObject( tChunkFile* file, tEntityStore* store )
{
    HeapMgr()->PushHeap( GMA_LEVEL_OTHER );
	AnimDynaPhysWrapper* wrapper = new AnimDynaPhysWrapper;
    HeapMgr()->PopHeap( GMA_LEVEL_OTHER );
	rAssert( file != NULL );
	rAssert( store != NULL );

	// Grab the name
	char buffer[256];
	file->GetPString( buffer );

	wrapper->SetName( buffer );

	// Grab version info
	int version = file->GetLong();
	// Grab the flag that tell us whether or not the object has alpha or not
	int hasAlpha = file->GetLong();
	
	wrapper->mHasAlpha = ( hasAlpha != 0x00000000 );
    bool collisionObjectFound = false;

	while( file->ChunksRemaining() )
	{
		file->BeginChunk();
		switch( file->GetCurrentID() )
		{
		case P3D_COMPOSITE_DRAWABLE:
			{
				// We will save the composite drawable since we need it 
				// for our DSG objects
				rAssertMsg( wrapper->mCompDraw == NULL, "There must only be one composite drawable in the wrapper!" );
				wrapper->mCompDraw = (tCompositeDrawable*)mpCompDLoader->LoadObject( file, store );
				wrapper->mCompDraw->AddRef();
				store->Store( wrapper->mCompDraw );
				rAssert( wrapper->mCompDraw != NULL );
			}	
			break;
		case P3D_MULTI_CONTROLLER:
			{
				rAssert( wrapper->mMultiController == NULL );
				wrapper->mMultiController = (tMultiController*)mpMCLoader->LoadObject( file, store );
				rAssert( wrapper->mMultiController != NULL );
				// This should be inserted into the list of world render multicontrollers that
				// get advanced every frame
				wrapper->mMultiController->SetCycleMode( FORCE_CYCLIC );
				wrapper->mMultiController->AddRef();

                bool collision = store->TestCollision( wrapper->mMultiController->GetUID(), wrapper->mMultiController );
                if( !collision )
                {
                    store->Store( wrapper->mMultiController );
                }
                else
                {
                    HandleCollision( wrapper->mMultiController );
                }
			}
			break;
		case Pure3D::Animation::FrameControllerData::FRAME_CONTROLLER:
			{
				tFrameController* pFC = static_cast< tFrameController* >( mpFCLoader->LoadObject( file, store ) );
				rAssert( pFC != NULL );
				store->Store( pFC );
			}
			break;
		case Simulation::Collision::OBJECT:
			{
                collisionObjectFound = true;
                rAssert( wrapper->mCollisionObject == NULL );
				wrapper->mCollisionObject = static_cast< sim::CollisionObject* > (mpCollObjLoader->LoadObject( file, store ));
                rAssert( wrapper->mCollisionObject != NULL );
                wrapper->mCollisionObject->AddRef();
				store->Store( wrapper->mCollisionObject );
			}
			break;
		case Pure3D::BillboardObject::QUAD_GROUP:
			{
				// Remember that we have our own billboard loader
				// make sure that these don't get dumped into the DSG, override first

				// Grab the loader
				BillboardWrappedLoader::OverrideLoader( true );
                BillboardWrappedLoader* pBBQLoader = static_cast<BillboardWrappedLoader*>(AllWrappers::GetInstance()->mpLoader(AllWrappers::msBillboard));

                tBillboardQuadGroup* pGroup = static_cast<tBillboardQuadGroup*>( pBBQLoader->LoadObject( file, store ) );
				rAssert( pGroup != NULL );
				store->Store( pGroup );	

				// Set the loader back to its normal state
				BillboardWrappedLoader::OverrideLoader( false );
			}
			break;
		case Pure3D::Mesh::MESH:
			{
				GeometryWrappedLoader* pGeoLoader = (GeometryWrappedLoader*)AllWrappers::GetInstance()->mpLoader( AllWrappers::msGeometry );
				tGeometry* pGeo = static_cast<tGeometry*>(pGeoLoader->LoadObject( file, store ) );			
				rAssert( pGeo != NULL );
				store->Store( pGeo );
			}
			break;
		case Pure3D::Animation::AnimationData::ANIMATION:
			{
				tAnimation* pAnimation = static_cast< tAnimation*> ( mpAnimationLoader->LoadObject( file, store ) );
				rAssert( pAnimation != NULL );
				store->Store( pAnimation );
                wrapper->SetHasAnimation( true );
			}
			break;
		case Simulation::Physics::OBJECT:

			rAssert( wrapper->mPhysicsObject == NULL );
			wrapper->mPhysicsObject = (sim::PhysicsObject*)mpPhysObjLoader->LoadObject( file,store );
			rAssert( wrapper->mPhysicsObject != NULL );
			store->Store( wrapper->mPhysicsObject );
            wrapper->mPhysicsObject->AddRef ();

			break;
		case P3D_SKELETON:		
			{

				tSkeleton* pSkeleton = static_cast< tSkeleton* > (mpSkelLoader->LoadObject( file, store ) );
				rAssert( pSkeleton != NULL );
				store->Store( pSkeleton );
			}
			break;
		default:
			rAssertMsg( false, "Unknown chunk in animated wrapper chunk file");
			break;
		};
        file->EndChunk();
	}
    if ( collisionObjectFound == false )
    {
        rReleasePrintf("WARNING - Stateprop %s is missing a collision volume!\n", buffer );
    }
	return wrapper;
}
//===========================================================================
// AnimDynaPhysWrapperLoader::SetRegdListener
//===========================================================================
// Description:
//		Informs the loader its listener is.
//
// Constraints:
//
// Parameters:
//		Pointer to the new listener. Integer for the data it sends to it OnChunkLoaded()
//
// Return:
//
//===========================================================================
void AnimDynaPhysWrapperLoader::SetRegdListener( ChunkListenerCallback* pListenerCB,
											int iUserData )
{
	//
	// Follow protocol; notify old Listener, that it has been 
	// "disconnected".
	//
	if( mpListenerCB != NULL )
	{
	  mpListenerCB->OnChunkLoaded( NULL, iUserData, 0 );
	}
	mpListenerCB  = pListenerCB;
	mUserData     = iUserData;
}

//===========================================================================
// AnimDynaPhysWrapperLoader::ModRegdListener
//===========================================================================
// Description:
//		Changes the data that gets sent to the listener
//
// Constraints:
//		Listener must have been set already via SetRegdListener
//
// Parameters:
//		Pointer to the listener. Integer holding the new data
//
// Return:
//
//===========================================================================
void AnimDynaPhysWrapperLoader::ModRegdListener( ChunkListenerCallback* pListenerCB, int iUserData )
{
   rAssert( pListenerCB == mpListenerCB );

   mUserData = iUserData;
}


///////////////////////////////////////////////////////////
// ANIM_OBJ_DSG_WRAPPER methods
///////////////////////////////////////////////////////////

AnimObjDSGWrapperLoader::AnimObjDSGWrapperLoader() : tSimpleChunkHandler(SRR2::ChunkID::ANIM_OBJ_DSG_WRAPPER)
{

    mpListenerCB  = NULL;
    mUserData     = -1;

	mpCompDLoader = new tCompositeDrawableLoader;
	mpCompDLoader->AddRef();
   
	mpMCLoader    = new tMultiControllerLoader;
    mpMCLoader->AddRef();

	mpSkelLoader = new tSkeletonLoader;
	mpSkelLoader->AddRef();
    
	mpAnimationLoader = new tAnimationLoader;
	mpAnimationLoader->AddRef();

	mpCollObjLoader = new sim::CollisionObjectLoader;
	mpCollObjLoader->AddRef();

	mpPhysObjLoader = new sim::PhysicsObjectLoader;
	mpPhysObjLoader->AddRef();

    mpFCLoader    = new tFrameControllerLoader;
    mpFCLoader->AddRef();

    mpStatePropLoader = new CStatePropDataLoader;
    mpStatePropLoader->AddRef();

    mpFactoryLoader = new tAnimatedObjectFactoryLoader;
 	mpAnimObjectLoader = new tAnimatedObjectLoader;

}

AnimObjDSGWrapperLoader::~AnimObjDSGWrapperLoader()
{
	mpCollObjLoader->ReleaseVerified();
	mpPhysObjLoader->ReleaseVerified();
	mpCompDLoader->ReleaseVerified();
	mpMCLoader->ReleaseVerified();
	mpSkelLoader->ReleaseVerified();
	mpAnimationLoader->ReleaseVerified();
	mpFCLoader->ReleaseVerified();
    mpStatePropLoader->ReleaseVerified();
    mpFactoryLoader->ReleaseVerified();
 	mpAnimObjectLoader->ReleaseVerified();
}



tEntity* AnimObjDSGWrapperLoader::LoadObject( tChunkFile* file, tEntityStore* store )
{
    HeapMgr()->PushHeap( GMA_LEVEL_OTHER );
	AnimDynaPhysWrapper* wrapper = new AnimDynaPhysWrapper;
    HeapMgr()->PopHeap( GMA_LEVEL_OTHER );
	rAssert( file != NULL );
	rAssert( store != NULL );

	// Grab the name
	char buffer[256];
	file->GetPString( buffer );

	wrapper->SetName( buffer );



	// Grab version info
    int version = file->GetUChar();
	// Grab the flag that tell us whether or not the object has alpha or not
    int hasAlpha = file->GetUChar();
	
	wrapper->mHasAlpha = ( hasAlpha != 0x00000000 );

	while( file->ChunksRemaining() )
	{
		file->BeginChunk();
        unsigned int id = file->GetCurrentID();
		switch( id )
		{
		case P3D_COMPOSITE_DRAWABLE:
			{
				// We will save the composite drawable since we need it 
				// for our DSG objects
				rAssertMsg( wrapper->mCompDraw == NULL, "There must only be one composite drawable in the wrapper!" );
				wrapper->mCompDraw = (tCompositeDrawable*)mpCompDLoader->LoadObject( file, store );
				wrapper->mCompDraw->AddRef();
				store->Store( wrapper->mCompDraw );
				rAssert( wrapper->mCompDraw != NULL );
			}	
			break;
		case P3D_MULTI_CONTROLLER:
			{
				rAssert( wrapper->mMultiController == NULL );
				wrapper->mMultiController = (tMultiController*)mpMCLoader->LoadObject( file, store );
				rAssert( wrapper->mMultiController != NULL );
				// This should be inserted into the list of world render multicontrollers that
				// get advanced every frame
				wrapper->mMultiController->SetCycleMode( FORCE_CYCLIC );
				wrapper->mMultiController->AddRef();
                bool collision = store->TestCollision( wrapper->mMultiController->GetUID(), wrapper->mMultiController );
                if( !collision )
                {
                    store->Store( wrapper->mMultiController );
                }
                else
                {
                    HandleCollision( wrapper->mMultiController );
                }
			}
			break;
		case Pure3D::Animation::FrameControllerData::FRAME_CONTROLLER:
			{
				tFrameController* pFC = static_cast< tFrameController* >( mpFCLoader->LoadObject( file, store ) );
				rAssert( pFC != NULL );
				store->Store( pFC );
			}
			break;
		case Simulation::Collision::OBJECT:
			{

                rAssert( wrapper->mCollisionObject == NULL );
				wrapper->mCollisionObject = static_cast< sim::CollisionObject* > (mpCollObjLoader->LoadObject( file, store ));
                rAssert( wrapper->mCollisionObject != NULL );
                wrapper->mCollisionObject->AddRef();
				store->Store( wrapper->mCollisionObject );
                //wrapper->mCollisionObject->AddRef ();
			}
			break;
		case Pure3D::BillboardObject::QUAD_GROUP:
			{
				// Remember that we have our own billboard loader
				// make sure that these don't get dumped into the DSG, override first

				// Grab the loader
				BillboardWrappedLoader::OverrideLoader( true );
                BillboardWrappedLoader* pBBQLoader = static_cast<BillboardWrappedLoader*>(AllWrappers::GetInstance()->mpLoader(AllWrappers::msBillboard));

                tBillboardQuadGroup* pGroup = static_cast<tBillboardQuadGroup*>( pBBQLoader->LoadObject( file, store ) );
				rAssert( pGroup != NULL );
				store->Store( pGroup );	

				// Set the loader back to its normal state
				BillboardWrappedLoader::OverrideLoader( false );
			}
			break;
		case Pure3D::Mesh::MESH:
			{
				GeometryWrappedLoader* pGeoLoader = (GeometryWrappedLoader*)AllWrappers::GetInstance()->mpLoader( AllWrappers::msGeometry );
				tGeometry* pGeo = static_cast<tGeometry*>(pGeoLoader->LoadObject( file, store ) );			
				rAssert( pGeo != NULL );
				store->Store( pGeo );
			}
			break;
		case Pure3D::Animation::AnimationData::ANIMATION:
			{
				tAnimation* pAnimation = static_cast< tAnimation*> ( mpAnimationLoader->LoadObject( file, store ) );
				rAssert( pAnimation != NULL );
				store->Store( pAnimation );
			}
			break;
		case Simulation::Physics::OBJECT:

			rAssert( wrapper->mPhysicsObject == NULL );
			wrapper->mPhysicsObject = (sim::PhysicsObject*)mpPhysObjLoader->LoadObject( file,store );
			rAssert( wrapper->mPhysicsObject != NULL );
			store->Store( wrapper->mPhysicsObject );
            wrapper->mPhysicsObject->AddRef ();

			break;
		case P3D_SKELETON:		
			{

				tSkeleton* pSkeleton = static_cast< tSkeleton* > (mpSkelLoader->LoadObject( file, store ) );
				rAssert( pSkeleton != NULL );
				store->Store( pSkeleton );
			}
			break;
        case StateProp::STATEPROP:
            {
                CStatePropData* pPropData = static_cast< CStatePropData* > (mpStatePropLoader->LoadObject( file, store ) );
                rAssert( dynamic_cast< CStatePropData* >( pPropData ) != NULL );
                rAssert( pPropData != NULL );
                tRefCounted::Assign(wrapper->mStatePropData, pPropData);
                store->Store( pPropData );
            }
            break;
        case Pure3D::AnimatedObject::FACTORY:
            {

                tEntity* entity = mpFactoryLoader->LoadObject( file, store );
                rAssert( dynamic_cast< tAnimatedObjectFactory* >(entity) != NULL );
                store->Store( entity );
            }
            break;
		case Pure3D::AnimatedObject::OBJECT:
			{
				tEntity* pEntity = mpAnimObjectLoader->LoadObject( file, store );
				rAssert( pEntity != NULL );
				store->Store( pEntity );
			}
			break;
		default:
			rAssertMsg( false, "Unknown chunk in animated wrapper chunk file");
			break;
		};
        file->EndChunk();
	}

	return wrapper;
}
//===========================================================================
// AnimObjDSGWrapperLoader::SetRegdListener
//===========================================================================
// Description:
//		Informs the loader its listener is.
//
// Constraints:
//
// Parameters:
//		Pointer to the new listener. Integer for the data it sends to it OnChunkLoaded()
//
// Return:
//
//===========================================================================
void AnimObjDSGWrapperLoader::SetRegdListener( ChunkListenerCallback* pListenerCB,
											int iUserData )
{
	//
	// Follow protocol; notify old Listener, that it has been 
	// "disconnected".
	//
	if( mpListenerCB != NULL )
	{
	  mpListenerCB->OnChunkLoaded( NULL, iUserData, 0 );
	}
	mpListenerCB  = pListenerCB;
	mUserData     = iUserData;
}

//===========================================================================
// AnimObjDSGWrapperLoader::ModRegdListener
//===========================================================================
// Description:
//		Changes the data that gets sent to the listener
//
// Constraints:
//		Listener must have been set already via SetRegdListener
//
// Parameters:
//		Pointer to the listener. Integer holding the new data
//
// Return:
//
//===========================================================================
void AnimObjDSGWrapperLoader::ModRegdListener( ChunkListenerCallback* pListenerCB, int iUserData )
{
   rAssert( pListenerCB == mpListenerCB );

   mUserData = iUserData;
}

//===========================================================================
// AnimObjDSGWrapperLoader::IsMissionProp
//===========================================================================
// Description:
//		Returns boolean indicating if the prop is used in a mission
//
// Constraints:
//		Only one stateprop mission prop - the powerbox
//
// Parameters:
//		none
//
// Return:
//      bool indicating if this prop is used in a mission
//
//===========================================================================
bool AnimDynaPhysLoader::IsMissionProp( const char* name )const
{
    if ( strcmp( name, "l1z6_powerbox_Shape" ) == 0 )
        return true;
    else
        return false;
}