CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPipeline/plTransitionMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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 3 of the License, or
(at your option) any later version.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  plTransitionMgr - Class to handle fullscreen transitions (fades, etc)   //
//                                                                          //
//  Note: eventually, I would like to drive these transitions on material   //
//  animations (it's just a big screen-covering plate with a material,      //
//  after all). This would allow the artists to specify their own           //
//  transitions and do really cool effects. However, that would require     //
//  somehow loading the materials in, and I'm not sure exactly how to do    //
//  that....                                                                //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#include "hsWindows.h"
#include "hsTypes.h"
#include "plTransitionMgr.h"
#include "plPlates.h"

#include "plGImage/plMipmap.h"
#include "plSurface/plLayer.h"
#include "plSurface/hsGMaterial.h"
#include "plMessage/plLayRefMsg.h"
#include "pnMessage/plRefMsg.h"
#include "plMessage/plTransitionMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnMessage/plEventCallbackMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "plgDispatch.h"
#include "hsGDeviceRef.h"
#include "hsResMgr.h"
#include "hsTimer.h"

#include "plAudio/plAudioSystem.h"
#include "pnNetCommon/plNetApp.h"
#include "plNetClient/plLinkEffectsMgr.h"
#include "pnNetCommon/plNetApp.h"

#include "plStatusLog/plStatusLog.h"

//// Constructor/Destructor //////////////////////////////////////////////////

plTransitionMgr::plTransitionMgr()
{
    fEffectPlate = nil;
    fCurrentEffect = kIdle;
    fPlaying = false;
}

void    plTransitionMgr::Init( void )
{
    ICreatePlate();
    plgDispatch::Dispatch()->RegisterForExactType( plTransitionMsg::Index(), GetKey() );
    plgDispatch::Dispatch()->RegisterForExactType( plLinkEffectBCMsg::Index(), GetKey() );
}

plTransitionMgr::~plTransitionMgr()
{
    int     i;


    for( i = 0; i < fCallbacks.GetCount(); i++ )
        hsRefCnt_SafeUnRef( fCallbacks[ i ] );

    if( fEffectPlate != nil )
        plPlateManager::Instance().DestroyPlate( fEffectPlate );

    if( fRegisteredForTime )
        plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );

    plgDispatch::Dispatch()->UnRegisterForExactType( plTransitionMsg::Index(), GetKey() );
    plgDispatch::Dispatch()->UnRegisterForExactType( plLinkEffectBCMsg::Index(), GetKey() );
}

//// ICreatePlate ////////////////////////////////////////////////////////////

void    plTransitionMgr::ICreatePlate( void )
{
    int     x, y;


    fEffectPlate = nil;

    // +0.01 to deal with the half-pixel antialiasing stuff
    plPlateManager::Instance().CreatePlate( &fEffectPlate, 0, 0, 2.01, 2.01 );
    fEffectPlate->SetDepth(2);

    // hack for now--create a black layer that we will animate the opacity on
    plMipmap *ourMip = fEffectPlate->CreateMaterial( 16, 16, true );
    for( y = 0; y < ourMip->GetHeight(); y++ )
    {
        UInt32  *pixels = ourMip->GetAddr32( 0, y );
        for( x = 0; x < ourMip->GetWidth(); x++ )
            pixels[ x ] = 0xff000000;
    }

    fEffectPlate->SetVisible( false );
}

//// IStartFadeOut ///////////////////////////////////////////////////////////

void    plTransitionMgr::IStartFadeOut( hsScalar lengthInSecs, UInt8 effect )
{
    fCurrentEffect = effect; // default - kFadeOut;
    fEffectLength = lengthInSecs;

    // Special case for length 0--just jump straight to fadeout
    if( lengthInSecs == 0.f )
    {
        fCurrOpacity = 1.f;
        fLastTime = -1.f;
        fPlaying = false;
        plgAudioSys::SetGlobalFadeVolume( 0.f );
    }
    else
    {
        fCurrOpacity = 0;
        fOpacDelta = 1.f / lengthInSecs;
        fLastTime = -1.f;
        fPlaying = true;

        // Register for time message
        plgDispatch::Dispatch()->RegisterForExactType( plTimeMsg::Index(), GetKey() );
        fRegisteredForTime = true;
    }

    if( fEffectPlate == nil )
        ICreatePlate();
    fEffectPlate->SetVisible( true );

    plLayer *layer = (plLayer *)fEffectPlate->GetMaterial()->GetLayer( 0 );
    if( layer != nil )
    {
        layer->SetOpacity( fCurrOpacity );
    }
}

//// IStartFadeIn ////////////////////////////////////////////////////////////

void    plTransitionMgr::IStartFadeIn( hsScalar lengthInSecs, UInt8 effect )
{
    fCurrentEffect = effect; // default - kFadeIn;
    fEffectLength = lengthInSecs;
    fCurrOpacity = 1.f;
    fOpacDelta = -1.f / lengthInSecs;
    fLastTime = -1.f;
    fPlaying = true;

    // Register for time message
    plgDispatch::Dispatch()->RegisterForExactType( plTimeMsg::Index(), GetKey() );
    fRegisteredForTime = true;

    if( fEffectPlate == nil )
        ICreatePlate();
    fEffectPlate->SetVisible( true );

    plLayer *layer = (plLayer *)fEffectPlate->GetMaterial()->GetLayer( 0 );
    if( layer != nil )
    {
        layer->SetOpacity( fCurrOpacity );
    }
}

//// IStop ///////////////////////////////////////////////////////////////////

void    plTransitionMgr::IStop( hsBool aboutToStartAgain /*= false*/ )
{
    int     i;

    plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
    fRegisteredForTime = false;

    if( fPlaying )
    {
        if( !fHoldAtEnd && fEffectPlate != nil && !aboutToStartAgain )
            fEffectPlate->SetVisible( false );

        // finish the opacity to the end opacity
        if( fEffectPlate != nil )
        {
            plLayer *layer = (plLayer *)fEffectPlate->GetMaterial()->GetLayer( 0 );
            if( layer != nil )
            {
                layer->SetOpacity( (fCurrentEffect == kFadeIn || fCurrentEffect == kTransitionFadeIn) ? 0.f : 1.f );
            }
        }

        if( !aboutToStartAgain )
        {
            if (!fNoSoundFade)
                plgAudioSys::SetGlobalFadeVolume( (fCurrentEffect == kFadeIn || fCurrentEffect == kTransitionFadeIn) ? 1.f : 0.f );
        }

        for( i = 0; i < fCallbacks.GetCount(); i++ )
        {
            fCallbacks[ i ]->SetSender( GetKey() );
            plgDispatch::MsgSend( fCallbacks[ i ] );
        }
        fCallbacks.Reset();

        fPlaying = false;
    }
}

//// MsgReceive //////////////////////////////////////////////////////////////

hsBool  plTransitionMgr::MsgReceive( plMessage* msg )
{
    int         i;


    plTimeMsg   *time = plTimeMsg::ConvertNoRef( msg );
    if( time != nil )
    {
        if( !fPlaying )
            return false;

        if (fLastTime < 0)
        {
            // Semi-hack. We trigger transitions after we've finished loading.
            // Problem is the loading all happens in one really long frame, so that
            // if we record the time we started, we'll instantly be done next frame,
            // even though we triggered just at the "end" of the last frame.
            // 
            // So instead we don't start the clock until we get our first plTimeMsg.

            
            fLastTime = (hsScalar)(time->DSeconds());
            return false;
        }

        fEffectLength -= (hsScalar)( time->DSeconds() - fLastTime );//*/time->DelSeconds();
        if( fEffectLength < 0 )
            IStop();
        else
        {
            // Grab the layer so we can set the opacity
            fCurrOpacity += (hsScalar)(fOpacDelta * ( time->DSeconds() - fLastTime ));//*/time->DelSeconds();
            if( fEffectPlate == nil )
                ICreatePlate();

            plLayer *layer = (plLayer *)fEffectPlate->GetMaterial()->GetLayer( 0 );
            if( layer != nil )
            {
                layer->SetOpacity( fCurrOpacity );
            }

            // Let the audiosystem handle fading in sounds
            if(!fNoSoundFade)
                plgAudioSys::SetGlobalFadeVolume( 1.f - fCurrOpacity );
            

            fLastTime = (hsScalar)(time->DSeconds());
        }
        
        return false;
    }
    
    plTransitionMsg *effect = plTransitionMsg::ConvertNoRef( msg );
    if( effect != nil )
    {
        if( fRegisteredForTime )
            IStop( true );

        for( i = 0; i < effect->GetNumCallbacks(); i++ )
        {
            plEventCallbackMsg *pMsg = effect->GetEventCallback( i );
            hsRefCnt_SafeRef( pMsg );
            fCallbacks.Append( pMsg );
        }
        
        fHoldAtEnd = effect->GetHoldState();

        fNoSoundFade = false;

        switch(effect->GetEffect())
        {
        case plTransitionMsg::kFadeInNoSound:
            fNoSoundFade = true;
        case plTransitionMsg::kFadeIn:
            IStartFadeIn( effect->GetLengthInSecs(), kTransitionFadeIn );
            break;
        case plTransitionMsg::kFadeOutNoSound:
            fNoSoundFade = true;
        case plTransitionMsg::kFadeOut:
            IStartFadeOut( effect->GetLengthInSecs(), kTransitionFadeOut );
            break;
        }

        return false;
    }

    plLinkEffectBCMsg *link = plLinkEffectBCMsg::ConvertNoRef( msg );
    if( link != nil )
    {
        const float kScreenFadeTime = 3.f; // seconds

        // Go ahead and auto-trigger based on link FX messages
        if( plNetClientApp::GetInstance() != nil && link->fLinkKey == plNetClientApp::GetInstance()->GetLocalPlayerKey() )
        {
            if( fRegisteredForTime )
                IStop( true );

            if( link->HasLinkFlag( plLinkEffectBCMsg::kLeavingAge ) )
            {
                plNetApp::GetInstance()->DebugMsg("Local player linking out, fading screen\n");

                fHoldAtEnd = true;
                IStartFadeOut( kScreenFadeTime );
            }
            else
            {
                plNetApp::GetInstance()->DebugMsg("Local player linking in, fading screen\n");

                fHoldAtEnd = false;
                IStartFadeIn( kScreenFadeTime );
            }   

            if (link->HasLinkFlag(plLinkEffectBCMsg::kSendCallback))
            {
                plLinkEffectsMgr *mgr;
                if( ( mgr = plLinkEffectsMgr::ConvertNoRef( link->GetSender()->ObjectIsLoaded() ) ) != nil )
                {
                    plEventCallbackMsg *cback = plEventCallbackMsg::ConvertNoRef( mgr->WaitForEffect( link->fLinkKey ) );
//                  hsRefCnt_SafeRef( cback ); // mgr has given us ownership, his ref is now ours. No need for another. -mf-
                    fCallbacks.Append( cback );
                }
            }
        }
        return true;
    }
    return hsKeyedObject::MsgReceive( msg );
}