CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/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 );
}