CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.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==*/

#include "hsTypes.h"
#include "plLineFollowMod.h"
#include "plStereizer.h"
#include "../plInterp/plAnimPath.h"
#include "hsResMgr.h"
#include "../pnMessage/plRefMsg.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pnSceneObject/plDrawInterface.h"
#include "plgDispatch.h"
#include "../plMessage/plListenerMsg.h"
#include "../plMessage/plRenderMsg.h"
#include "../pnMessage/plTimeMsg.h"
#include "hsBounds.h"
#include "plPipeline.h"
#include "hsFastMath.h"
#include "../pnMessage/plPlayerPageMsg.h"
#include "../pnNetCommon/plNetApp.h"
#include "../plNetClient/plNetClientMgr.h"
#include "hsTimer.h"

plLineFollowMod::plLineFollowMod()
:	fPath(nil),
	fPathParent(nil),
	fRefObj(nil),
	fFollowMode(kFollowListener),
	fFollowFlags(kNone),
	fOffset(0),
	fOffsetClamp(0),
	fSpeedClamp(0)
{
	fSearchPos.Set(0,0,0);
}

plLineFollowMod::~plLineFollowMod()
{
	delete fPath;
}

void plLineFollowMod::SetSpeedClamp(hsScalar fps)
{
	fSpeedClamp = fps;
	if( fSpeedClamp > 0 )
	{
		fFollowFlags |= kSpeedClamp;
	}
	else
	{
		fFollowFlags &= ~kSpeedClamp;
	}

}

void plLineFollowMod::SetOffsetFeet(hsScalar f)
{
	fOffset = f;
	if( fOffset != 0 )
	{
		fFollowFlags &= ~kOffsetAng;
		fFollowFlags |= kOffsetFeet;
	}
	else
	{
		fFollowFlags &= ~kOffset;
	}
}

void plLineFollowMod::SetForceToLine(hsBool on)
{
	if( on )
		fFollowFlags |= kForceToLine;
	else
		fFollowFlags &= ~kForceToLine;
}

void plLineFollowMod::SetOffsetDegrees(hsScalar f)
{
	fOffset = hsScalarDegToRad(f);
	if( fOffset != 0 )
	{
		fFollowFlags &= ~kOffsetFeet;
		fFollowFlags |= kOffsetAng;
		fTanOffset = tanf(f);
	}
	else
	{
		fFollowFlags &= ~kOffset;
	}
}

void plLineFollowMod::SetOffsetClamp(hsScalar f)
{
	fOffsetClamp = f;
	if( fOffsetClamp > 0 )
	{
		fFollowFlags |= kOffsetClamp;
	}
	else
	{
		fFollowFlags &= ~kOffsetClamp;
	}
}

void plLineFollowMod::SetPath(plAnimPath* path)
{
	delete fPath;
	fPath = path;
}

void plLineFollowMod::Read(hsStream* stream, hsResMgr* mgr)
{
	plMultiModifier::Read(stream, mgr);

	fPath = plAnimPath::ConvertNoRef(mgr->ReadCreatable(stream));

	mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefParent), plRefFlags::kPassiveRef);

	mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefObject), plRefFlags::kPassiveRef);

	int n = stream->ReadSwap32();
	while(n--)
	{
		mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefStereizer), plRefFlags::kPassiveRef);
	}

	UInt32 f = stream->ReadSwap32();
	SetFollowMode(FollowMode(f & 0xffff));

	fFollowFlags = (UInt16)((f >> 16) & 0xffff);

	if( fFollowFlags & kOffset )
	{
		fOffset = stream->ReadSwapScalar();
	}
	if( fFollowFlags & kOffsetAng )
	{
		fTanOffset = tanf(fOffset);
	}
	if( fFollowFlags & kOffsetClamp )
	{
		fOffsetClamp = stream->ReadSwapScalar();
	}
	if( fFollowFlags & kSpeedClamp )
	{
		fSpeedClamp = stream->ReadSwapScalar();
	}
}

void plLineFollowMod::Write(hsStream* stream, hsResMgr* mgr)
{
	plMultiModifier::Write(stream, mgr);

	mgr->WriteCreatable(stream, fPath);

	mgr->WriteKey(stream, fPathParent); 

	mgr->WriteKey(stream, fRefObj); 

	stream->WriteSwap32(fStereizers.GetCount());
	int i;
	for( i = 0; i < fStereizers.GetCount(); i++ )
		mgr->WriteKey(stream, fStereizers[i]->GetKey());

	UInt32 f = UInt32(fFollowMode) | (UInt32(fFollowFlags) << 16);
	stream->WriteSwap32(f);

	if( fFollowFlags & kOffset )
		stream->WriteSwapScalar(fOffset);
	if( fFollowFlags & kOffsetClamp )
		stream->WriteSwapScalar(fOffsetClamp);
	if( fFollowFlags & kSpeedClamp )
		stream->WriteSwapScalar(fSpeedClamp);
}


#include "plProfile.h"
plProfile_CreateTimer("LineFollow", "RenderSetup", LineFollow);

hsBool plLineFollowMod::MsgReceive(plMessage* msg)
{
	plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef(msg);
	if( refMsg )
	{
		if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
		{
			plSceneObject* obj = plSceneObject::ConvertNoRef(refMsg->GetRef());
			if( kRefParent == refMsg->fType )
				fPathParent = obj;
			else if( kRefObject == refMsg->fType )
				fRefObj = obj;
			else if( kRefStereizer == refMsg->fType )
			{
				plStereizer* ster = plStereizer::ConvertNoRef(refMsg->GetRef());
				int idx = fStereizers.Find(ster);
				if( idx == fStereizers.kMissingIndex )
					fStereizers.Append(ster);
			}
		}
		else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
		{
			if( kRefParent == refMsg->fType )
				fPathParent = nil;
			else if( kRefObject == refMsg->fType )
				fRefObj = nil;
			else if( kRefStereizer == refMsg->fType )
			{
				plStereizer* ster = (plStereizer*)(refMsg->GetRef());
				int idx = fStereizers.Find(ster);
				if( idx != fStereizers.kMissingIndex )
					fStereizers.Remove(idx);
			}
		}
		return true;
	}
	plRenderMsg* rend = plRenderMsg::ConvertNoRef(msg);
	if( rend )
	{
		plProfile_BeginLap(LineFollow, this->GetKey()->GetUoid().GetObjectName());
		hsPoint3 oldPos = fSearchPos;
		fSearchPos = rend->Pipeline()->GetViewPositionWorld();
		ICheckForPop(oldPos, fSearchPos);
		plProfile_EndLap(LineFollow, this->GetKey()->GetUoid().GetObjectName());
		return true;
	}
	plListenerMsg* list = plListenerMsg::ConvertNoRef(msg);
	if( list )
	{
		hsPoint3 oldPos = fSearchPos;
		fSearchPos = list->GetPosition();
		ICheckForPop(oldPos, fSearchPos);

		ISetupStereizers(list);
		return true;
	}
	plPlayerPageMsg* pPMsg = plPlayerPageMsg::ConvertNoRef(msg);
	if (pPMsg)
	{
		if (pPMsg->fPlayer == plNetClientMgr::GetInstance()->GetLocalPlayerKey() && !pPMsg->fUnload)
		{
			fRefObj = (plSceneObject*)pPMsg->fPlayer->GetObjectPtr();
		}
		return true;
	}

	return plMultiModifier::MsgReceive(msg);
}

void plLineFollowMod::SetFollowMode(FollowMode f) 
{ 
	IUnRegister();
	fFollowMode = f; 
	IRegister();

	plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}

void plLineFollowMod::IUnRegister()
{
	switch( fFollowMode )
	{
	case kFollowObject:
		break;
	case kFollowListener:
		plgDispatch::Dispatch()->UnRegisterForExactType(plListenerMsg::Index(), GetKey());
		break;
	case kFollowCamera:
		plgDispatch::Dispatch()->UnRegisterForExactType(plRenderMsg::Index(), GetKey());
		break;
	case kFollowLocalAvatar:
		plgDispatch::Dispatch()->UnRegisterForExactType(plPlayerPageMsg::Index(), GetKey());
		break;

	}
}

void plLineFollowMod::IRegister()
{
	switch( fFollowMode )
	{
	case kFollowObject:
		break;
	case kFollowListener:
		plgDispatch::Dispatch()->RegisterForExactType(plListenerMsg::Index(), GetKey());
		break;
	case kFollowCamera:
		plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());
		break;
	case kFollowLocalAvatar:
		{	
			if (plNetClientApp::GetInstance() && plNetClientApp::GetInstance()->GetLocalPlayer())
				fRefObj = ((plSceneObject*)plNetClientApp::GetInstance()->GetLocalPlayer());
			plgDispatch::Dispatch()->RegisterForExactType(plPlayerPageMsg::Index(), GetKey());
			break;
		}
	}
}

hsBool plLineFollowMod::IEval(double secs, hsScalar del, UInt32 dirty)
{
	if( !fPath )
		return false;

	ISetPathTransform();

	if( !IGetSearchPos() )
		return false;

	hsMatrix44 tgtXfm;
	IGetTargetTransform(fSearchPos, tgtXfm);

	if( fFollowFlags & kOffset )
		IOffsetTargetTransform(tgtXfm);

	int i;
	for( i = 0; i < GetNumTargets(); i++ )
	{
		ISetTargetTransform(i, tgtXfm);
	}
	return true;
}

hsBool plLineFollowMod::IOffsetTargetTransform(hsMatrix44& tgtXfm)
{
	hsPoint3 tgtPos = tgtXfm.GetTranslate();

	hsVector3 tgt2src(&fSearchPos, &tgtPos);
	hsScalar t2sLen = tgt2src.Magnitude();
	hsFastMath::NormalizeAppr(tgt2src);

	hsVector3 out;
	out.Set(-tgt2src.fY, tgt2src.fX, 0); // (0,0,1) X (tgt2src)

	if( fFollowFlags & kOffsetAng )
	{
		hsScalar del = t2sLen * fTanOffset;
		if( fFollowFlags & kOffsetClamp ) 
		{
			if( del > fOffsetClamp )
				del = fOffsetClamp;
			else if( del < -fOffsetClamp )
				del = -fOffsetClamp;
		}
		out *= del;
	}
	else if( fFollowFlags & kOffsetFeet )
	{
		out *= fOffset;
	}
	else
		out.Set(0,0,0);

	if( fFollowFlags & kForceToLine )
	{
		hsPoint3 newSearch = tgtPos;
		newSearch += out;
		IGetTargetTransform(newSearch, tgtXfm);
	}
	else
	{
		tgtXfm.fMap[0][3] += out[0];
		tgtXfm.fMap[1][3] += out[1];
		tgtXfm.fMap[2][3] += out[2];
	}

	return true;
}

hsBool plLineFollowMod::IGetTargetTransform(hsPoint3& searchPos, hsMatrix44& tgtXfm)
{
	hsScalar t = fPath->GetExtremePoint(searchPos);
	if( fFollowFlags & kFullMatrix )
	{
		fPath->SetCurTime(t, plAnimPath::kNone);
		fPath->GetMatrix44(&tgtXfm);
	}
	else
	{
		fPath->SetCurTime(t, plAnimPath::kCalcPosOnly);
		hsPoint3 pos;
		fPath->GetPosition(&pos);
		tgtXfm.MakeTranslateMat((hsVector3*)&pos);
	}

	return true;
}

void plLineFollowMod::ISetPathTransform()
{
	if( fPathParent && fPathParent->GetCoordinateInterface() )
	{
		hsMatrix44 l2w = fPathParent->GetCoordinateInterface()->GetLocalToWorld();
		hsMatrix44 w2l = fPathParent->GetCoordinateInterface()->GetWorldToLocal();
		
		fPath->SetTransform(l2w, w2l);
	}
}

void plLineFollowMod::ICheckForPop(const hsPoint3& oldPos, const hsPoint3& newPos)
{
	hsVector3 del(&oldPos, &newPos);

	hsScalar elapsed = hsTimer::GetDelSysSeconds();
	hsScalar speedSq = 0.f;
	if (elapsed > 0.f)
		speedSq = del.MagnitudeSquared() / elapsed;

	const hsScalar kMaxSpeedSq = 30.f * 30.f; // (feet per sec)^2
	if( speedSq > kMaxSpeedSq )
		fFollowFlags |= kSearchPosPop;
	else
		fFollowFlags &= ~kSearchPosPop;
}

hsBool plLineFollowMod::IGetSearchPos()
{
	hsPoint3 oldPos = fSearchPos;
	if( kFollowObject == fFollowMode )
	{
		if( !fRefObj )
			return false;

		if( fRefObj->GetCoordinateInterface() )
		{
			fSearchPos = fRefObj->GetCoordinateInterface()->GetWorldPos();
			ICheckForPop(oldPos, fSearchPos);
			return true;
		}
		else if( fRefObj->GetDrawInterface() )
		{
			fSearchPos = fRefObj->GetDrawInterface()->GetWorldBounds().GetCenter();
			ICheckForPop(oldPos, fSearchPos);
			return true;
		}
		return false;
	}
	else 
	if (fFollowMode == kFollowLocalAvatar)
	{	
		if (!fRefObj)
			return false;
		if( fRefObj->GetCoordinateInterface() )
		{
			fSearchPos = fRefObj->GetCoordinateInterface()->GetWorldPos();
			ICheckForPop(oldPos, fSearchPos);
			return true;
		}
		else if( fRefObj->GetDrawInterface() )
		{
			fSearchPos = fRefObj->GetDrawInterface()->GetWorldBounds().GetCenter();
			ICheckForPop(oldPos, fSearchPos);
			return true;
		}
		return false;
	}
	return true;
}

hsMatrix44 plLineFollowMod::IInterpMatrices(const hsMatrix44& m0, const hsMatrix44& m1, hsScalar parm)
{
	hsMatrix44 retVal;
	int i, j;
	for( i = 0; i < 3; i++ )
	{
		for( j = 0; j < 4; j++ )
		{
			retVal.fMap[i][j] = m0.fMap[i][j] * (1.f - parm) + m1.fMap[i][j] * parm;
		}
	}
	retVal.fMap[3][0] = retVal.fMap[3][1] = retVal.fMap[3][2] = 0;
	retVal.fMap[3][3] = 1.f;
	retVal.NotIdentity();
	return retVal;
}

hsMatrix44 plLineFollowMod::ISpeedClamp(plCoordinateInterface* ci, const hsMatrix44& unclTgtXfm)
{
	// If our search position has popped, or delsysseconds is zero, just return as is.
	if( (fFollowFlags & kSearchPosPop) || !(hsTimer::GetDelSysSeconds() > 0) )
		return unclTgtXfm;

	const hsMatrix44 currL2W = ci->GetLocalToWorld();
	const hsPoint3 oldPos = currL2W.GetTranslate();
	const hsPoint3 newPos = unclTgtXfm.GetTranslate();
	const hsVector3 del(&newPos, &oldPos);
	hsScalar elapsed = hsTimer::GetDelSysSeconds();
	hsScalar speed = 0.f;
	if (elapsed > 0.f)
		speed = del.Magnitude() / elapsed;

	if( speed > fSpeedClamp )
	{
		hsScalar parm = fSpeedClamp / speed;

		hsMatrix44 clTgtXfm = IInterpMatrices(currL2W, unclTgtXfm, parm);

		return clTgtXfm;
	}

	return unclTgtXfm;
}

void plLineFollowMod::ISetTargetTransform(int iTarg, const hsMatrix44& unclTgtXfm)
{
	plCoordinateInterface* ci = IGetTargetCoordinateInterface(iTarg);
	if( ci )
	{
		hsMatrix44 tgtXfm = fFollowFlags & kSpeedClamp ? ISpeedClamp(ci, unclTgtXfm) : unclTgtXfm;
		if( fFollowFlags & kFullMatrix )
		{
			// This branch currently never gets taken. If it ever does,
			// we should probably optimize out this GetInverse() (depending
			// on how often it gets taken).
			const hsMatrix44& l2w = tgtXfm;
			hsMatrix44 w2l;
			l2w.GetInverse(&w2l);

			ci->SetTransform(l2w, w2l);
		}
		else
		{
			hsMatrix44 l2w = ci->GetLocalToWorld();
			hsMatrix44 w2l = ci->GetWorldToLocal();

			hsPoint3 pos = tgtXfm.GetTranslate();
			hsPoint3 oldPos = l2w.GetTranslate();
			
			l2w.SetTranslate(&pos);

			hsMatrix44 xlate;
			xlate.Reset();
			xlate.SetTranslate(&oldPos);
			w2l = w2l * xlate;
			xlate.SetTranslate(&-pos);
			w2l = w2l * xlate;

			ci->SetTransform(l2w, w2l);
		}
		hsPoint3 newPos = tgtXfm.GetTranslate();
		int i;
		for( i = 0; i < fStereizers.GetCount(); i++ )
		{
			if( fStereizers[i] )
			{
				fStereizers[i]->SetWorldInitPos(newPos);
				fStereizers[i]->Stereize();
			}
		}
	}
}

void plLineFollowMod::ISetupStereizers(const plListenerMsg* listMsg)
{
	int i;
	for( i = 0; i < fStereizers.GetCount(); i++ )
	{
		if( fStereizers[i] )
			fStereizers[i]->SetFromListenerMsg(listMsg);
	}
}

void plLineFollowMod::AddTarget(plSceneObject* so)
{
	plMultiModifier::AddTarget(so);

	if( so )
		plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}

void plLineFollowMod::RemoveTarget(plSceneObject* so)
{
	plMultiModifier::RemoveTarget(so);
}

void plLineFollowMod::AddStereizer(const plKey& key)
{
	hsgResMgr::ResMgr()->SendRef(plKey(key), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefStereizer), plRefFlags::kPassiveRef);
}

void plLineFollowMod::RemoveStereizer(const plKey& key)
{
	hsgResMgr::ResMgr()->SendRef(plKey(key), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRemove, 0, kRefStereizer), plRefFlags::kPassiveRef);
}

// derived version of this class for rail cameras
// the difference is the rail camera just calculates 
// the desired position but does not move the target to
// it.

plRailCameraMod::plRailCameraMod() :
fCurrentTime(0.0f),
fTargetTime(0.0f),
fFarthest(false)
{
	plLineFollowMod::plLineFollowMod();
	fGoal.Set(0,0,0);
}

plRailCameraMod::~plRailCameraMod()
{
}

hsBool	plRailCameraMod::IGetTargetTransform(hsPoint3& searchPos, hsMatrix44& tgtXfm)
{
	if (fPath->GetFarthest())
	{	
		fFarthest = true;
		fPath->SetFarthest(false);
	}
	fTargetTime = fPath->GetExtremePoint(searchPos);
	fPath->SetCurTime(fTargetTime, plAnimPath::kCalcPosOnly);
	hsPoint3 pos;
	fPath->GetPosition(&pos);
	tgtXfm.MakeTranslateMat((hsVector3*)&pos);
	
	return true;
}

hsPoint3 plRailCameraMod::GetGoal(double secs, hsScalar speed)
{
	hsScalar delTime;
	int dir;
	if (fTargetTime == fCurrentTime)
		return fGoal;

	if (fTargetTime > fCurrentTime)
	{	
		dir = 1;
		delTime = fTargetTime - fCurrentTime;
	}
	else
	{	
		dir = -1;
		delTime = fCurrentTime - fTargetTime;
	}
	if (fPath->GetWrap() && delTime > fPath->GetLength() * 0.5f)
		dir *= -1;
	
	if (delTime <= (secs * speed))
		fCurrentTime = fTargetTime;
	else
		fCurrentTime += (hsScalar)((secs * speed) * dir);

	if (fPath->GetWrap())
	{
		if (fCurrentTime > fPath->GetLength())
			fCurrentTime = (fCurrentTime - fPath->GetLength());
		else
		if (fCurrentTime < 0.0f)
			fCurrentTime = fPath->GetLength() - fCurrentTime;
	}
	if (fFarthest)
		fPath->SetCurTime((fPath->GetLength() - fCurrentTime), plAnimPath::kCalcPosOnly);
	else
		fPath->SetCurTime(fCurrentTime, plAnimPath::kCalcPosOnly);
	
	fPath->GetPosition(&fGoal);
	
	fPath->SetCurTime(fTargetTime, plAnimPath::kCalcPosOnly);
	
	return fGoal;
}