You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

687 lines
18 KiB

/*==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;
}