//=============================================================================
// Copyright (C) 2002 Radical Entertainment Ltd.  All rights reserved.
//
// File:        AnimatedIcon.cpp
//
// Description: Implement AnimatedIcon
//
// History:     10/3/2002 + Created -- Cary Brisebois
//
//=============================================================================

//========================================
// System Includes
//========================================
// Foundation Tech
#include <radtime.hpp>
#include <raddebug.hpp>
#include <p3d/anim/multicontroller.hpp>
#include <p3d/effects/particlesystem.hpp>
#include <p3d/view.hpp>

//========================================
// Project Includes
//========================================
#include <mission/AnimatedIcon.h>

#include <memory/srrmemory.h>

#include <mission/gameplaymanager.h>
#include <render/rendermanager/rendermanager.h>
#include <render/rendermanager/worldrenderlayer.h>
#include <render/culling/worldscene.h>

#include <debug/profiler.h>

#include <main/game.h>

//******************************************************************************
//
// Global Data, Local Data, Local Classes
//
//******************************************************************************
AnimatedIcon* AnimatedIcon::sAnimatedIconPool = NULL;
unsigned int AnimatedIcon::sNumAllocated = 0;

// Setup default parameters for our watcher variables
#ifdef RAD_TUNE
float AnimatedIcon::sDbgMinArrowScale = MIN_ARROW_SCALE;
float AnimatedIcon::sDbgMaxArrowScale = MAX_ARROW_SCALE;
float AnimatedIcon::sDbgMinArrowScaleDist = MIN_ARROW_SCALE_DIST;
float AnimatedIcon::sDbgMaxArrowScaleDist = MAX_ARROW_SCALE_DIST;
bool AnimatedIcon::sDbgEnableArrowScaling = false;
#endif

//******************************************************************************
//
// Public Member Functions
//
//******************************************************************************

//==============================================================================
// AnimatedIcon::AnimatedIcon
//==============================================================================
// Description: Constructor.
//
// Parameters:	None.
//
// Return:      N/A.
//
//==============================================================================
AnimatedIcon::AnimatedIcon() :
    mDSGEntity( NULL ),
    mRenderLayer( RenderEnums::LevelSlot ),
    mFlags( 0 )
{
#ifdef RAD_TUNE
    AttachWatcherVariables();
#endif
}

//==============================================================================
// AnimatedIcon::~AnimatedIcon
//==============================================================================
// Description: Destructor.
//
// Parameters:	None.
//
// Return:      N/A.
//
//==============================================================================
AnimatedIcon::~AnimatedIcon()
{
    Deallocate();
}

//=============================================================================
// AnimatedIcon::Init
//=============================================================================
// Description: Comment
//
// Parameters:  ( const char* iconName, const rmt::Matrix& mat, bool render = true, bool oneShot = false )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Init( const char* iconName, const rmt::Matrix& mat, bool render, bool oneShot )
{
    MEMTRACK_PUSH_GROUP( "Mission - Animated Icon" );
    rAssert( iconName );
    rAssertMsg( mDSGEntity == NULL, "Never call this twice on the same object!!!! LEAK, LEAK!" );

    //========================= SET UP THE ICON

    HeapMgr()->PushHeap( GetGameplayManager()->GetCurrentMissionHeap() );

    SetUpContents( iconName );

    mDSGEntity = new AnimIconDSG;

    mDSGEntity->mTranslucent = true;

    rAssert( mDSGEntity != NULL );

    mDSGEntity->AddRef();

    //
    // The entity takes overship of m, so spake Devin
    //
    rmt::Matrix* m = new rmt::Matrix;
    rAssert( m );

    *m = mat;

    mDSGEntity->LoadSetUp( m, mAnimIcon.drawable, mAnimIcon.shadowDrawable );

    mRenderLayer = static_cast<RenderEnums::LayerEnum>(GetRenderManager()->rCurWorldRenderLayer());

    if ( render )
    {
        ShouldRender( true );
    }

    SetFlag( (Flag)ONE_SHOT, oneShot );

    SetUpEffects();

    HeapMgr()->PopHeap( GetGameplayManager()->GetCurrentMissionHeap() );

    MEMTRACK_POP_GROUP( "Mission - Animated Icon" );
}

//=============================================================================
// AnimatedIcon::Init
//=============================================================================
// Description: Comment
//
// Parameters:  ( const char* iconName, const rmt::Vector& pos, bool render, bool oneShot )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Init( const char* iconName, const rmt::Vector& pos, bool render, bool oneShot )
{
MEMTRACK_PUSH_GROUP( "Mission - Animated Icon" );
    rAssert( iconName );
    rAssertMsg( mDSGEntity == NULL, "Never call this twice on the same object!!!! LEAK, LEAK!" );

    //========================= SET UP THE ICON
    
    HeapMgr()->PushHeap( GetGameplayManager()->GetCurrentMissionHeap() );

    SetUpContents( iconName );

   	mDSGEntity = new AnimIconDSG;

    mDSGEntity->mTranslucent = true;

	rAssert( mDSGEntity != NULL );
    
    mDSGEntity->AddRef();

    mDSGEntity->SetName( iconName );

	//
	// The entity takes overship of m, so spake Devin
	//
	rmt::Matrix* m = new rmt::Matrix;
    rAssert( m );

    m->Identity();
	m->FillTranslate( pos );

    mDSGEntity->LoadSetUp( m, mAnimIcon.drawable, mAnimIcon.shadowDrawable );

    mRenderLayer = static_cast<RenderEnums::LayerEnum>(GetRenderManager()->rCurWorldRenderLayer());

    if ( render )
    {
        ShouldRender( true );
    }

    SetFlag( (Flag)ONE_SHOT, oneShot );

    SetUpEffects();

    HeapMgr()->PopHeap( GetGameplayManager()->GetCurrentMissionHeap() );

MEMTRACK_POP_GROUP( "Mission - Animated Icon" );
}

//=============================================================================
// AnimatedIcon::ScaleByCameraDistance
//=============================================================================
// Description: Converts all billboardquadgroups in the icon drawable to quads that are 
//              scaled by distance to camera
//
// Parameters:  (float minScale, float maxScale, float minDist, float maxDist)
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::ScaleByCameraDistance( float minScale, float maxScale, float minDist, float maxDist )
{
    // Default to no scaling
    mDSGEntity->SetScaleParameters( minScale, maxScale, minDist, maxDist ); 
}

//=============================================================================
// AnimatedIcon::Move
//=============================================================================
// Description: Comment
//
// Parameters:  ( const rmt::Vector& newPos )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Move( const rmt::Vector& newPos )
{
    if ( mRenderLayer == static_cast<RenderEnums::LayerEnum>(GetRenderManager()->rCurWorldRenderLayer()) )
    {
        rmt::Box3D oldBox;
        mDSGEntity->GetBoundingBox( &oldBox );

        mDSGEntity->pMatrix()->FillTranslate( newPos );

        if ( !GetFlag( (Flag)RENDERING ) )
        {
            ShouldRender( true );
        }

        GetRenderManager()->pWorldScene()->Move( oldBox, mDSGEntity );
        mDSGEntity->RecomputeShadowPosition();
    }
}

//=============================================================================
// AnimatedIcon::Update
//=============================================================================
// Description: Comment
//
// Parameters:  ( unsigned int elapsedMilliseconds )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Update( unsigned int elapsedMilliseconds )
{
    rmt::Sphere iconBoundingSphere;
    if ( mDSGEntity )
    {
        mDSGEntity->GetBoundingSphere( &iconBoundingSphere );
        mDSGEntity->m_Visible = false;
    }
    else
    {
        iconBoundingSphere.centre = rmt::Vector(0,0,0);
        iconBoundingSphere.radius = 1.0f;
    }

    if ( GetFlag( (Flag)RENDERING ) && GetGameplayManager()->TestPosInFrustrumOfPlayer(iconBoundingSphere.centre, 0, iconBoundingSphere.radius))
    {    
        if ( mDSGEntity )
        {
            mDSGEntity->m_Visible = true;
        }

        if ( mAnimIcon.multiController )
        {
            BEGIN_PROFILE( mAnimIcon.multiController->GetName() );
            //This allows me to ignore the extra updates caused by being part of 
            //a substep.
            unsigned int frame = GetGame()->GetFrameCount();
            if ( (mAnimIcon.multiController)->GetLastFrameUpdated() != frame )
            {
                (mAnimIcon.multiController)->Advance( (float)elapsedMilliseconds );
                (mAnimIcon.multiController)->SetLastFrameUpdated( frame );
                // Handle particle systems
                if ( mAnimIcon.effectIndex != -1 )
                {
                    tCompositeDrawable* compDraw = static_cast< tCompositeDrawable* >( mAnimIcon.drawable );
                    tCompositeDrawable::DrawableEffectElement* effectElement = static_cast< tCompositeDrawable::DrawableEffectElement* > ( compDraw->GetDrawableElement( mAnimIcon.effectIndex ) );
                    tParticleSystem* system = static_cast< tParticleSystem* >( effectElement->GetDrawable() );
                    if ( system )
                    {
                        rmt::Matrix mat;
                        mat.Identity();
                        system->Update( &mat );
                    }   
                }

                if ( GetFlag( (Flag)ONE_SHOT ) && (mAnimIcon.multiController)->LastFrameReached() > 0 )
                {
                    //This is a way to remove non-cyclic animations.  Beware,
                    //if the animation is intended to be cyclic it will disappear...
                    ShouldRender( false );
                }
            }
            END_PROFILE( mAnimIcon.multiController->GetName() );
        }
        
        if ( mAnimIcon.shadowController != NULL )
        {
            mAnimIcon.shadowController->Advance( (float)elapsedMilliseconds );
        }

#ifdef RAD_TUNE
        if ( sDbgEnableArrowScaling )
        {
            // Jeff P. wants to have watcher variables to tune the AI scaling.
            // If we are in tune mode, lets override the input parameters and set them to be
            // the values of some static watcher variables
            ScaleByCameraDistance( sDbgMinArrowScale, sDbgMaxArrowScale, sDbgMinArrowScaleDist, sDbgMaxArrowScaleDist );
        }   
#endif
    }
}

//=============================================================================
// AnimatedIcon::Reset
//=============================================================================
// Description: Comment
//
// Parameters:  ()
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Reset()
{
    if ( mAnimIcon.multiController )
    {
        (mAnimIcon.multiController)->Reset();
    }
}

//=============================================================================
// AnimatedIcon::ShouldRender
//=============================================================================
// Description: Comment
//
// Parameters:  ( bool shouldRender )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::ShouldRender( bool shouldRender )
{
    if ( shouldRender && !GetFlag( (Flag)RENDERING ) )
    {
        (reinterpret_cast<WorldRenderLayer*>(GetRenderManager()->mpLayer( mRenderLayer )))->pWorldScene()->Add( mDSGEntity );
        SetFlag( (Flag)RENDERING, true );
    }
    else if ( !shouldRender && GetFlag( (Flag)RENDERING ) )
    {
        (reinterpret_cast<WorldRenderLayer*>(GetRenderManager()->mpLayer( mRenderLayer )))->pWorldScene()->RemoveQuietFail( mDSGEntity );
        SetFlag( (Flag)RENDERING, false );
    }
}

//=============================================================================
// AnimatedIcon::GetPosition
//=============================================================================
// Description: Comment
//
// Parameters:  ( rmt::Vector& pos )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::GetPosition( rmt::Vector& pos )
{
    mDSGEntity->GetPosition( &pos );
}

//=============================================================================
// ::operator new
//=============================================================================
// Description: Comment
//
// Parameters:  ( size_t size )
//
// Return:      void
//
//=============================================================================
void* AnimatedIcon::operator new( size_t size )
{
    rAssert( sAnimatedIconPool != NULL );
    rAssert( sNumAllocated < MAX_ICONS );

    void* data = NULL;
    if ( sNumAllocated < MAX_ICONS )
    {
        unsigned int i;
        for ( i = 0; i < MAX_ICONS; ++i )
        {
            if ( !sAnimatedIconPool[ i ].mAllocated )
            {
                sAnimatedIconPool[ i ].mAllocated = true;
                data = static_cast<void*>(&sAnimatedIconPool[ i ]);
                ++sNumAllocated;
                break;
            }
        }
    }

    return data;
}

//=============================================================================
// ::operator new
//=============================================================================
// Description: Comment
//
// Parameters:  ( size_t size, GameMemoryAllocator allocator )
//
// Return:      void
//
//=============================================================================
void* AnimatedIcon::operator new( size_t size, GameMemoryAllocator allocator )
{
    return new AnimatedIcon();
}

//=============================================================================
// ::operator delete
//=============================================================================
// Description: Comment
//
// Parameters:  ( void* mem )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::operator delete( void* mem )
{
    AnimatedIcon* icon = static_cast<AnimatedIcon*>( mem );

    unsigned int i;
    for ( i = 0; i < MAX_ICONS; ++i )
    {
        if ( icon == &sAnimatedIconPool[ i ] )
        {
            icon->Deallocate();
            sNumAllocated--;
            break;
        }
    }

    rAssert( i < MAX_ICONS );
}

//=============================================================================
// void operator delete
//=============================================================================
// Description: Comment
//
// Parameters:  ( void* mem, GameMemoryAllocator allocator )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::operator delete( void* mem, GameMemoryAllocator allocator )
{
    AnimatedIcon::operator delete( mem );
}

//=============================================================================
// AnimatedIcon::InitAnimatedIcons
//=============================================================================
// Description: Comment
//
// Parameters:  ( GameMemoryAllocator allocator )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::InitAnimatedIcons( GameMemoryAllocator allocator )
{
    rAssert( sAnimatedIconPool == NULL );
    
    if ( sAnimatedIconPool == NULL )
    {
        #ifdef RAD_GAMECUBE
                HeapMgr()->PushHeap( GMA_GC_VMM );
        #else
                HeapMgr()->PushHeap( allocator );
        #endif
        sAnimatedIconPool = new AnimatedIcon[ MAX_ICONS ];

        unsigned int i;
        for ( i = 0; i < MAX_ICONS; ++i )
        {
            sAnimatedIconPool[ i ].mAllocated = false;
        }

        #ifdef RAD_GAMECUBE
                HeapMgr()->PopHeap( GMA_GC_VMM );
        #else
                HeapMgr()->PopHeap( allocator );
        #endif
    }
}

//=============================================================================
// AnimatedIcon::ShutdownAnimatedIcons
//=============================================================================
// Description: Comment
//
// Parameters:  ()
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::ShutdownAnimatedIcons()
{
    rAssert( sNumAllocated == 0 );

    //Paranoia Test
#ifdef RAD_DEBUG
    unsigned int i;
    for ( i = 0; i < MAX_ICONS; ++i )
    {
        rAssert( sAnimatedIconPool[ i ].mDSGEntity == NULL );
    }
#endif

    delete[] sAnimatedIconPool;
    sAnimatedIconPool = NULL;
}

//******************************************************************************
//
// Private Member Functions
//
//******************************************************************************

//=============================================================================
// AnimatedIcon::SetFlag
//=============================================================================
// Description: Comment
//
// Parameters:  ( Flag flag, bool value )
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::SetFlag( Flag flag, bool value )
{
    if ( value )
    {   
        mFlags |= ( 1 << flag );
    }
    else
    {
        mFlags &= ~( 1 << flag );
    }    
}

//=============================================================================
// AnimatedIcon::GetFlag
//=============================================================================
// Description: Comment
//
// Parameters:  ( Flag flag )
//
// Return:      bool 
//
//=============================================================================
bool AnimatedIcon::GetFlag( Flag flag ) const
{
    return ( (mFlags & ( 1 << flag )) > 0 );
}

//=============================================================================
// AnimatedIcon::Deallocate
//=============================================================================
// Description: Comment
//
// Parameters:  ()
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::Deallocate()
{
    if ( mDSGEntity )
    {
        //Scary, scary!
        if ( GetFlag( (Flag)RENDERING ) )
        {
            ShouldRender(false);
        }

        mDSGEntity->Release();
    }

    mFlags = 0;
    mAllocated = false;

    mDSGEntity = NULL;

    tRefCounted::Release(mAnimIcon.drawable);
    tRefCounted::Release(mAnimIcon.multiController);
    tRefCounted::Release(mAnimIcon.shadowController);
    tRefCounted::Release(mAnimIcon.shadowDrawable);
}

//=============================================================================
// AnimatedIcon::SetUpContents
//=============================================================================
// Description: Comment
//
// Parameters:  ( const char* iconName )
//
// Return:      void
//
//=============================================================================
void AnimatedIcon::SetUpContents( const char* iconName )
{
    tRefCounted::Assign(mAnimIcon.drawable, p3d::find<tDrawable>( iconName ));
    if ( mAnimIcon.drawable == NULL )
    {
        rReleasePrintf( "ERORR!!!!!  Can not init Animicon with missing (%s) drawable!!!!\n", iconName );
        tRefCounted::Assign(mAnimIcon.drawable, p3d::find<tDrawable>( "triggersphere_000" ));
    }

    rAssert( mAnimIcon.drawable != NULL );

    char controllerName[256];
    sprintf( controllerName, "%s_controller", iconName );

    tRefCounted::Assign(mAnimIcon.multiController, p3d::find<tMultiController>( controllerName ) );

    // Try and find the shadows (Collector cards have them, others are optional)
    // Append _shadow to the icon name to get the shadow name
    char shadowDrawableName[256];
    sprintf( shadowDrawableName, "%s_shadow", iconName );
    tRefCounted::Assign(mAnimIcon.shadowDrawable, p3d::find<tDrawable>( shadowDrawableName ));
    // Now try and find the shadow multicontroller
    char shadowControllerName[256];
    sprintf( shadowControllerName, "%s_controller", shadowDrawableName );
    tRefCounted::Assign(mAnimIcon.shadowController, p3d::find<tMultiController>( shadowControllerName ) );
}

//=============================================================================
// AnimatedIcon::SetUpEffects
//=============================================================================
// Description: Comment
//
// Parameters:  ()
//
// Return:      void 
//
//=============================================================================
void AnimatedIcon::SetUpEffects()
{
    //Only do this once.
    rAssert( mAnimIcon.effectIndex == -1 );

    // Try and find particle systems
    tCompositeDrawable* compDraw = dynamic_cast< tCompositeDrawable* >( mAnimIcon.drawable );
    if ( compDraw )
    {
        for ( int i = 0 ; i < compDraw->GetNumDrawableElement() ; i++ )
        {
            tCompositeDrawable::DrawableEffectElement* effectElement = dynamic_cast< tCompositeDrawable::DrawableEffectElement* > ( compDraw->GetDrawableElement( i ) );
            if (effectElement)
            {             
                tEffect* effect = static_cast< tEffect* >( effectElement->GetDrawable() );
                if ( effect != NULL )
                {
                    tParticleSystem* ps = static_cast< tParticleSystem* >( effect );
                    tParticleSystemFactory* factory = static_cast< tParticleSystemFactory* >( ps->GetFactory() );
                    factory->SetAlwaysUpdateAfterDisplay( false );
                    ps->ConvertEmittersToLocal();
                    mAnimIcon.effectIndex = i;
                    break;
                }
            }
        }
    }
}

#ifdef RAD_TUNE
void AnimatedIcon::AttachWatcherVariables()
{
    static bool sDbgArrowsAttachedToWatcher = false; // has the watcher variables been 
    // attached already ? dont attach them more than once
    if ( sDbgArrowsAttachedToWatcher == false )
    {
        const char* ANIMATED_ICON_DBG_NAMESPACE = "Animated Icons";

        radDbgWatchAddBoolean( &sDbgEnableArrowScaling, "Enable Arrow Scaling", ANIMATED_ICON_DBG_NAMESPACE );
        radDbgWatchAddFloat( &sDbgMinArrowScale, "Min Arrow Scale", ANIMATED_ICON_DBG_NAMESPACE,  NULL, NULL, 0, 20.0f );     
        radDbgWatchAddFloat( &sDbgMaxArrowScale, "Max Arrow Scale", ANIMATED_ICON_DBG_NAMESPACE,  NULL, NULL, 0, 20.0f );     
        radDbgWatchAddFloat( &sDbgMinArrowScaleDist, "Min Arrow Scale Distance", ANIMATED_ICON_DBG_NAMESPACE,  NULL, NULL, 0, 250.0f );     
        radDbgWatchAddFloat( &sDbgMaxArrowScaleDist, "Max Arrow Scale Distance", ANIMATED_ICON_DBG_NAMESPACE,  NULL, NULL, 0, 250.0f );     
    }
    sDbgArrowsAttachedToWatcher = true;
}

#endif

AnimatedIcon::AnimIconDSG::AnimIconDSG():
m_ScalingEnabled( false )
{
    
    // Default to no scaling
    SetScaleParameters( 1.0f, 1.0f, 1.0f, 1.0f );
}

AnimatedIcon::AnimIconDSG::~AnimIconDSG(){

}

float AnimatedIcon::AnimIconDSG::CalcScale()
{
    rmt::Vector objPosition;
    GetPosition( &objPosition );
    // Determine the distance to the camera
    rmt::Vector camPosition;
    p3d::context->GetView()->GetCamera()->GetWorldPosition( &camPosition );
    float distToBillboard = (camPosition - objPosition ).Magnitude();
    float billboardScale = m_Slope * ( distToBillboard - m_NearDist ) + m_MinSize;
    billboardScale = rmt::Clamp( billboardScale, m_MinSize, m_MaxSize );

    return billboardScale;
}

void AnimatedIcon::AnimIconDSG::SetScaleParameters( float minSize, float maxSize, float nearDist, float farDist )
{
    // Compute m
    // The slope of the equation determining icon scaling

    if ( ( farDist - nearDist ) > 0.01f )
    {
        // m = ( maxSize - 1.0f ) / ( far - near )
        m_MaxSize = maxSize;
        m_MinSize = minSize;
        m_NearDist = nearDist;
        m_Slope = ( maxSize - minSize ) / ( farDist - nearDist );  
        m_ScalingEnabled = true;
    }
    else
    {
        m_ScalingEnabled = false;
    }

}

// Display with scaling. 
void AnimatedIcon::AnimIconDSG::Display()
{
    if( m_Visible )
    {
        extern bool g_ParticleLOD;
        g_ParticleLOD = true;
        bool wasBBQManagerEnabled = BillboardQuadManager::sEnabled;
        BillboardQuadManager::Enable();
        if ( m_ScalingEnabled )
        {
            float scale = CalcScale();
            rmt::Matrix scaleMat;
            scaleMat.Identity();
            scaleMat.FillScale( scale );

            // Apply rotation/transform THEN scale to the local object
            rmt::Matrix origMatrix = *mpMatrix;
            mpMatrix->Mult( scaleMat, origMatrix );

            InstStatEntityDSG::Display();

            *mpMatrix = origMatrix;
        }
        else
        {
            InstStatEntityDSG::Display();
        }
        if ( wasBBQManagerEnabled == false )
        {
            BillboardQuadManager::Disable();
        }
        g_ParticleLOD = false;
    }
}