/*==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 "plArmatureMod.h"
// local
#include "plAvBrain.h"
#include "plAvBrainUser.h"
#include "plAvatarMgr.h"
#include "plAGModifier.h"
#include "plAvatarClothing.h"
#include "plClothingSDLModifier.h"
#include "plAvatarSDLModifier.h"
#include "plAGAnim.h"
#include "plArmatureEffects.h"
#include "plAvBrainHuman.h"
#include "plMatrixChannel.h"
#include "plAvatarTasks.h"
#include "plAvCallbackAction.h"
#include "plAvBrainCritter.h"
// global
#include "plgDispatch.h"
#include "hsQuat.h"
#include "hsTimer.h"
// other
#include "pnSceneObject/plCoordinateInterface.h"
#include "pnSceneObject/plAudioInterface.h"
#include "plInterp/plAnimTimeConvert.h"
#include "pnMessage/plEnableMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnMessage/plSDLModifierMsg.h"
#include "pnMessage/plAttachMsg.h"
#include "pnMessage/plWarpMsg.h"
#include "pnMessage/plCorrectionMsg.h"
#include "pnMessage/plCameraMsg.h"
#include "pnMessage/plPipeResMakeMsg.h"
#include "plMessage/plAvatarMsg.h"
#include "plMessage/plAvatarFootMsg.h"
#include "plMessage/plInputEventMsg.h"
#include "plMessage/plLoadAgeMsg.h"
#include "plMessage/plAnimCmdMsg.h"
#include "plMessage/plListenerMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "plMessage/plParticleUpdateMsg.h"
#include "plParticleSystem/plParticleSystem.h"
#include "plParticleSystem/plParticleSDLMod.h"
#include "pfMessage/plArmatureEffectMsg.h"
#include "pfMessage/pfKIMsg.h"
#include "plVault/plVault.h"
#include "pnKeyedObject/plFixedKey.h"
#include "pnKeyedObject/plKey.h"
#include "pnKeyedObject/plKeyImp.h"
#include "plDrawable/plInstanceDrawInterface.h"
#include "plDrawable/plDrawableSpans.h"
#include "plSurface/plLayerAnimation.h"
#include "plSurface/hsGMaterial.h"
#include "pnNetCommon/plNetApp.h"
#include "plNetClient/plNetClientMgr.h" // for CCR stuff..
#include "plNetClient/plNetLinkingMgr.h"
#include "plModifier/plSpawnModifier.h"
#include "plPipeline/plDebugText.h"
#include "plResMgr/plKeyFinder.h"
#include "plAudio/plWin32StaticSound.h"
#include "plAudio/plAudioSystem.h"
#include "plNetMessage/plNetMessage.h"
#include "plInputCore/plAvatarInputInterface.h"
#include "plInputCore/plSceneInputInterface.h"
#include "plInputCore/plInputDevice.h"
#include "pfCamera/plVirtualCamNeu.h"
#include "plScene/plRelevanceMgr.h"
#include "plMessage/plSimStateMsg.h"
#include "plGImage/plLODMipmap.h"
#include "plPipeline.h"
#include "plTweak.h"
#include "plDrawable/plVisLOSMgr.h"
int plArmatureModBase::fMinLOD = 0; // standard is 3 levels of LOD
double plArmatureModBase::fLODDistance = 50.0;
plArmatureModBase::plArmatureModBase() :
fWaitFlags(kNeedMesh | kNeedPhysics | kNeedApplicator | kNeedBrainActivation),
fController(nil),
fCurLOD(-1),
fRootAnimator(nil),
fDisabledPhysics(0),
fDisabledDraw(0)
{
}
plArmatureModBase::~plArmatureModBase()
{
delete fController;
while (fUnusedBones.size() > 0)
{
delete fUnusedBones.back();
fUnusedBones.pop_back();
}
}
hsBool plArmatureModBase::MsgReceive(plMessage* msg)
{
hsBool result = false;
plArmatureBrain *curBrain = nil;
if (fBrains.size() > 0)
{
curBrain = fBrains.back();
if(curBrain->MsgReceive(msg))
return true;
}
return plAGMasterMod::MsgReceive(msg);
}
void plArmatureModBase::AddTarget(plSceneObject* so)
{
plAGMasterMod::AddTarget(so);
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}
void plArmatureModBase::RemoveTarget(plSceneObject* so)
{
int count = fBrains.size();
for(int i = count - 1; i >= 0; i--)
{
plArmatureBrain *brain = fBrains[i];
if (brain)
brain->Deactivate();
delete brain;
fBrains.pop_back();
}
plAGMasterMod::RemoveTarget(so);
}
hsBool plArmatureModBase::IEval(double time, hsScalar elapsed, UInt32 dirty)
{
if (IsFinal())
{
if (fBrains.size())
{
plArmatureBrain *curBrain = fBrains.back();
if (curBrain)
{
hsBool result = curBrain->Apply(time, elapsed);
if (!result)
{
PopBrain();
delete curBrain;
}
}
}
AdjustLOD();
}
else
IFinalize();
return true;
}
void plArmatureModBase::Read(hsStream * stream, hsResMgr *mgr)
{
plAGMasterMod::Read(stream, mgr);
int i;
int meshKeyCount = stream->ReadSwap32();
for(i = 0; i < meshKeyCount; i++)
{
plKey meshKey = mgr->ReadKey(stream);
fMeshKeys.push_back(meshKey);
plKeyVector *vec = TRACKED_NEW plKeyVector;
int boneCount = stream->ReadSwap32();
for(int j = 0; j < boneCount; j++)
vec->push_back(mgr->ReadKey(stream));
fUnusedBones.push_back(vec);
}
int nBrains = stream->ReadSwap32();
for (i = 0; i < nBrains; i++)
{
plArmatureBrain * brain = (plArmatureBrain *)mgr->ReadCreatable(stream);
this->PushBrain(brain);
}
}
void plArmatureModBase::Write(hsStream *stream, hsResMgr *mgr)
{
plAGMasterMod::Write(stream, mgr);
int i;
int meshKeyCount = fMeshKeys.size();
stream->WriteSwap32(meshKeyCount);
for (i = 0; i < meshKeyCount; i++)
{
plKey meshKey = fMeshKeys[i];
mgr->WriteKey(stream, meshKey);
// Should be a list per mesh key
stream->WriteSwap32(fUnusedBones[i]->size());
for(int j = 0; j < fUnusedBones[i]->size(); j++)
mgr->WriteKey(stream, (*fUnusedBones[i])[j]);
}
int nBrains = fBrains.size();
stream->WriteSwap32(nBrains);
for (i = 0; i < nBrains; i++)
{
mgr->WriteCreatable(stream, fBrains[i]);
}
}
void plArmatureModBase::AddressMessageToDescendants(const plCoordinateInterface * CI, plMessage *msg)
{
if (!CI)
return;
msg->AddReceiver(CI->GetOwnerKey());
for (int i = 0; i < CI->GetNumChildren(); i++)
AddressMessageToDescendants(CI->GetChild(i), msg);
}
void plArmatureModBase::EnableDrawingTree(const plSceneObject *object, hsBool status)
{
if (!object)
return;
plEnableMsg *msg = TRACKED_NEW plEnableMsg;
if (status)
msg->SetCmd( plEnableMsg::kEnable );
else
msg->SetCmd( plEnableMsg::kDisable );
msg->SetCmd( plEnableMsg::kDrawable );
const plCoordinateInterface *pCI = object->GetCoordinateInterface();
AddressMessageToDescendants(pCI, msg);
plgDispatch::MsgSend(msg);
}
plKey plArmatureModBase::GetWorldKey() const
{
if (fController)
return fController->GetSubworld();
else
return nil;
}
hsBool plArmatureModBase::ValidatePhysics()
{
if (!fTarget)
return false;
if (fController)
{
EnablePhysics(true);
fWaitFlags &= ~kNeedPhysics;
}
return !(fWaitFlags & kNeedPhysics);
}
hsBool plArmatureModBase::ValidateMesh()
{
if (fWaitFlags & kNeedMesh)
{
fWaitFlags &= ~kNeedMesh;
int n = fMeshKeys.size();
for(int i = 0; i < n; i++)
{
plKey meshKey = fMeshKeys[i];
plSceneObject *meshObj = (plSceneObject *)meshKey->GetObjectPtr();
if (!meshObj)
{
fWaitFlags |= kNeedMesh;
break;
}
hsBool visible = (i == fCurLOD ? true : false);
EnableDrawingTree(meshObj, visible);
}
}
return !(fWaitFlags & kNeedMesh);
}
void plArmatureModBase::PushBrain(plArmatureBrain *brain)
{
plArmatureBrain *oldBrain = GetCurrentBrain();
if (oldBrain)
oldBrain->Suspend();
fBrains.push_back(brain);
// don't activate brains until we are attached to our target
// addTarget will do activation...
if (GetTarget(0))
brain->Activate(this);
DirtySynchState(kSDLAvatar, 0);
}
void plArmatureModBase::PopBrain()
{
plArmatureBrain *oldBrain = nil;
if (fBrains.size() > 0)
{
oldBrain = fBrains.back();
oldBrain->Deactivate();
fBrains.pop_back();
}
plArmatureBrain *newBrain = GetCurrentBrain();
if (newBrain)
newBrain->Resume();
DirtySynchState(kSDLAvatar, 0);
}
plArmatureBrain *plArmatureModBase::GetCurrentBrain() const
{
plArmatureBrain *result = nil;
if (fBrains.size() > 0)
result = fBrains.back();
return result;
}
plDrawable *plArmatureModBase::FindDrawable() const
{
if (fMeshKeys[0] == nil)
return nil;
plSceneObject *so = plSceneObject::ConvertNoRef(fMeshKeys[0]->ObjectIsLoaded());
if (so == nil)
return nil;
const plDrawInterface *di = so->GetDrawInterface();
if (di && di->GetNumDrawables() > 0)
{
plDrawable *spans = plDrawable::ConvertNoRef(di->GetDrawable(0));
if (spans)
return spans;
}
const plInstanceDrawInterface *idi = plInstanceDrawInterface::ConvertNoRef(di);
if (idi)
return idi->GetInstanceDrawable();
return nil;
}
void plArmatureModBase::LeaveAge()
{
int nBrains = fBrains.size();
for (int i = nBrains - 1; i >= 0; i--)
{
plArmatureBrain * curBrain = fBrains[i];
if (curBrain->LeaveAge())
{
if (curBrain == GetCurrentBrain())
{
PopBrain();
delete curBrain;
}
}
}
}
hsBool plArmatureModBase::IsFinal()
{
return !fWaitFlags;
}
void plArmatureModBase::AdjustLOD()
{
if (!IsDrawEnabled())
return;
hsPoint3 camPos = plVirtualCam1::Instance()->GetCameraPos();
plSceneObject * SO = GetTarget(0);
if (SO)
{
hsMatrix44 l2w = SO->GetLocalToWorld();
hsPoint3 ourPos = l2w.GetTranslate();
hsPoint3 delta = ourPos - camPos;
hsScalar distanceSquared = delta.MagnitudeSquared();
if (distanceSquared < fLODDistance * fLODDistance)
SetLOD(__max(0, fMinLOD));
else if (distanceSquared < fLODDistance * fLODDistance * 4.0)
SetLOD(__max(1, fMinLOD));
else
SetLOD(2);
}
}
// Should always be called from AdjustLOD
hsBool plArmatureModBase::SetLOD(int iNewLOD)
{
if (iNewLOD >= fMeshKeys.size())
iNewLOD = fMeshKeys.size() - 1;
int oldLOD = fCurLOD;
if (iNewLOD != fCurLOD)
{
int oldLOD = fCurLOD;
if(fMeshKeys.size() > iNewLOD)
{
if (fCurLOD != -1)
{
plSceneObject * oldMesh = (plSceneObject *)fMeshKeys[oldLOD]->GetObjectPtr();
EnableDrawingTree(oldMesh, false);
}
else
{
// just starting up; turn all except current off
for (int i = 0; i < fMeshKeys.size(); i++)
{
if (i != iNewLOD)
{
plKey offKey = fMeshKeys[i];
plSceneObject * offMesh = (plSceneObject *)offKey->GetObjectPtr();
EnableDrawingTree(offMesh, false);
}
}
}
fCurLOD = iNewLOD;
plSceneObject * newMesh = (plSceneObject *)fMeshKeys[fCurLOD]->GetObjectPtr();
EnableDrawingTree(newMesh, true);
int boneLOD;
for (boneLOD = 0; boneLOD < fMeshKeys.size(); boneLOD++)
IEnableBones(boneLOD, boneLOD <= iNewLOD ? false: true);
}
}
return oldLOD;
}
void plArmatureModBase::RefreshTree()
{
fCurLOD = -1;
AdjustLOD();
}
int plArmatureModBase::AppendMeshKey(plKey meshKey)
{
fMeshKeys.push_back(meshKey);
return fMeshKeys.size() - 1;
}
int plArmatureModBase::AppendBoneVec(plKeyVector *boneVec)
{
fUnusedBones.push_back(boneVec);
return fUnusedBones.size() - 1;
}
UInt8 plArmatureModBase::GetNumLOD() const
{
return fMeshKeys.size();
}
void plArmatureModBase::EnablePhysics(hsBool status, UInt16 reason /* = kDisableReasonUnknown */)
{
if (status)
fDisabledPhysics &= ~reason;
else
fDisabledPhysics |= reason;
hsBool newStatus = !fDisabledPhysics;
if (fController)
fController->Enable(newStatus);
}
//
// Enabling Kinematics (state=true) will have the affect of:
// - disabling outside forces (gravity and other physics objects pushing us)
// - but leave on collisions with detector regions
// Disabling Kinematics (state=false) means:
// - all outside forces will affect us and collisions on
// i.e. normal enabled physical
void plArmatureModBase::EnablePhysicsKinematic(hsBool status)
{
if (fController)
fController->Kinematic(status);
}
void plArmatureModBase::EnableDrawing(hsBool status, UInt16 reason /* = kDisableReasonUnknown */)
{
hsBool oldStatus = !fDisabledDraw;
if (status)
fDisabledDraw &= ~reason;
else
fDisabledDraw |= reason;
hsBool newStatus = !fDisabledDraw;
if (oldStatus == newStatus)
return;
int i;
for (i = 0; i < fMeshKeys.size(); i++)
{
plSceneObject *obj = plSceneObject::ConvertNoRef(fMeshKeys[i]->ObjectIsLoaded());
if (obj)
EnableDrawingTree(obj, newStatus);
}
if (status)
fCurLOD = -1; // We just enabled all LOD. Need to force ourselves to recompute current LOD
}
void plArmatureModBase::IFinalize()
{
if (fWaitFlags & kNeedMesh)
ValidateMesh();
if (fWaitFlags & kNeedPhysics)
ValidatePhysics();
if (fWaitFlags & kNeedApplicator)
ICustomizeApplicator();
if (fWaitFlags & kNeedBrainActivation)
{
int nBrains = fBrains.size();
for (int i = 0; i < nBrains; i++)
{
// every brain gets activated, but all except the top brain
// also get suspended when the one above them is activated.
if (i > 0)
fBrains[i - 1]->Suspend();
fBrains[i]->Activate(this);
}
fWaitFlags &= ~kNeedBrainActivation;
}
}
void plArmatureModBase::ICustomizeApplicator()
{
const plAGModifier *agMod = plAGModifier::ConvertNoRef(FindModifierByClass(GetTarget(0), plAGModifier::Index()));
if (agMod)
{
plAGApplicator *app = agMod->GetApplicator(kAGPinTransform);
if (app)
{
plMatrixDifferenceApp *differ = plMatrixDifferenceApp::ConvertNoRef(app);
if (differ)
{
fRootAnimator = differ;
fWaitFlags &= ~kNeedApplicator;
return; // already there
}
}
plAGModifier *volAGMod = const_cast<plAGModifier *>(agMod);
plMatrixDifferenceApp *differ = TRACKED_NEW plMatrixDifferenceApp();
fRootAnimator = differ;
volAGMod->SetApplicator(differ);
differ->Enable(false);
fWaitFlags &= ~kNeedApplicator;
}
}
void plArmatureModBase::IEnableBones(int lod, hsBool enable)
{
if (lod < fUnusedBones.size())
{
plKeyVector *vec = fUnusedBones[lod];
int i;
for (i = 0; i < vec->size(); i++)
((plAGModifier *)(*vec)[i]->GetObjectPtr())->Enable(enable);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
const char *plArmatureMod::BoneStrings[] = {"Male", "Female", "Critter", "Actor"};
const hsScalar plArmatureMod::kAvatarInputSynchThreshold = 10.f;
hsScalar plArmatureMod::fMouseTurnSensitivity = 1.f;
hsBool plArmatureMod::fClickToTurn = true;
void plArmatureMod::IInitDefaults()
{
fBoneRootAnimator = nil;
fRootAGMod = nil;
fFootSoundSOKey = nil;
fLinkSoundSOKey = nil;
fBodyType = kBoneBaseMale;
fClothingOutfit = nil;
fClothingSDLMod = nil;
fAvatarSDLMod = nil;
fAvatarPhysicalSDLMod = nil;
fEffects = nil;
fDebugOn = false;
fBoneMap = nil;
fStealthMode = plAvatarStealthModeMsg::kStealthVisible;
fStealthLevel = 0;
fMouseFrameTurnStrength = 0.f;
fSuspendInputCount = 0;
fMidLink = false;
fAlreadyPanicLinking = false;
fReverseFBOnIdle = false;
fFollowerParticleSystemSO = nil;
fPendingSynch = false;
fLastInputSynch = 0;
fOpaque = true;
fPhysHeight = 0.f;
fPhysWidth = 0.f;
fUpdateMsg = nil;
fRootName = nil;
fDontPanicLink = false;
fBodyAgeName = "GlobalAvatars";
fBodyFootstepSoundPage = "Audio";
fAnimationPrefix = "Male";
fUserStr = "";
}
plArmatureMod::plArmatureMod() : plArmatureModBase()
{
IInitDefaults();
fWaitFlags |= kNeedAudio | kNeedCamera | kNeedSpawn;
}
plArmatureMod::~plArmatureMod()
{
delete fBoneMap;
delete [] fRootName;
if (fUpdateMsg)
fUpdateMsg->UnRef();
}
void plArmatureMod::SetPositionAndRotationSim(const hsPoint3* position, const hsQuat* rotation)
{
const plCoordinateInterface* subworldCI = nil;
if (fController)
subworldCI = fController->GetSubworldCI();
hsMatrix44 l2w, w2l;
// If we need the position or rotation, grab it from the avatar
if (!position || !rotation)
{
// Get the current position of the avatar in sim space
hsMatrix44 avatarL2S = GetTarget(0)->GetLocalToWorld();
if (subworldCI)
avatarL2S = subworldCI->GetWorldToLocal() * avatarL2S;
if (!rotation)
l2w = avatarL2S;
else
rotation->MakeMatrix(&l2w);
if (!position)
{
hsPoint3 simPos;
avatarL2S.GetTranslate(&simPos);
l2w.SetTranslate(&simPos);
}
else
l2w.SetTranslate(position);
}
else
{
rotation->MakeMatrix(&l2w);
l2w.SetTranslate(position);
}
// We've got the requested position of the avatar in subworld space, convert
// it to world space if necessary
if (subworldCI)
l2w = subworldCI->GetLocalToWorld() * l2w;
l2w.GetInverse(&w2l);
GetTarget(0)->SetTransform(l2w, w2l);
GetTarget(0)->FlushTransform();
}
void plArmatureMod::GetPositionAndRotationSim(hsPoint3* position, hsQuat* rotation)
{
hsMatrix44 l2s = GetTarget(0)->GetLocalToWorld();
if (fController)
{
const plCoordinateInterface* subworldCI = fController->GetSubworldCI();
if (subworldCI)
l2s = subworldCI->GetWorldToLocal() * l2s;
if (position)
l2s.GetTranslate(position);
if (rotation)
rotation->SetFromMatrix(&l2s);
}
}
const plSceneObject *plArmatureMod::FindBone(const char * name) const
{
plSceneObject *result = nil;
plAGModifier * mod = GetChannelMod(name);
if (mod)
result = mod->GetTarget(0);
return result;
}
const plSceneObject *plArmatureMod::FindBone(UInt32 id) const
{
if(fBoneMap)
return fBoneMap->FindBone(id);
else
return nil;
}
void plArmatureMod::AddBoneMapping(UInt32 id, const plSceneObject *bone)
{
if(!fBoneMap)
fBoneMap = TRACKED_NEW plAvBoneMap();
fBoneMap->AddBoneMapping(id, bone);
}
void plArmatureMod::WindowActivate(bool active)
{
if (!active) // We don't want the avatar to move while we don't have focus
{
if (!plAvatarMgr::GetInstance())
return;
plArmatureMod *localAv = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (localAv)
localAv->ClearInputFlags(true, true);
}
}
char *plArmatureMod::fSpawnPointOverride = nil;
void plArmatureMod::SetSpawnPointOverride( const char *overrideObjName )
{
delete [] fSpawnPointOverride;
if( overrideObjName == nil )
fSpawnPointOverride = nil;
else
{
fSpawnPointOverride = hsStrcpy( overrideObjName );
strlwr( fSpawnPointOverride );
}
}
int plArmatureMod::IFindSpawnOverride( void )
{
if( fSpawnPointOverride == nil || fSpawnPointOverride[ 0 ] == 0 )
return -1;
int i;
plAvatarMgr *mgr = plAvatarMgr::GetInstance();
for( i = 0; i < mgr->NumSpawnPoints(); i++ )
{
char str2[ 256 ];
strcpy(str2, mgr->GetSpawnPoint( i )->GetTarget(0)->GetKeyName());
strlwr(str2);
if (strstr(str2, fSpawnPointOverride) != nil)
return i; // Found it!
}
return -1;
}
void plArmatureMod::Spawn(double timeNow)
{
plAvatarMgr *mgr = plAvatarMgr::GetInstance();
int numSpawnPoints = mgr->NumSpawnPoints();
int spawnNum = IFindSpawnOverride();
if( spawnNum == -1 )
{
spawnNum = plAvatarMgr::GetInstance()->FindSpawnPoint( "LinkInPointDefault" );
if( spawnNum == -1 )
{
spawnNum = plNetClientApp::GetInstance()->GetJoinOrder();
}
}
hsAssert(numSpawnPoints, "No spawn points! You are about to crash!");
if ( numSpawnPoints )
spawnNum %= numSpawnPoints;
ValidatePhysics();
SpawnAt(spawnNum, timeNow);
}
void plArmatureMod::SpawnAt(int spawnNum, double time)
{
plAvatarMgr *mgr = plAvatarMgr::GetInstance();
const plSpawnModifier * spawn = mgr->GetSpawnPoint(spawnNum);
hsMatrix44 l2w;
hsMatrix44 w2l;
if ( spawn )
{
const plSceneObject * spawnObj = spawn->GetTarget(0);
l2w = spawnObj->GetLocalToWorld();
w2l = spawnObj->GetWorldToLocal();
}
if (fController)
fController->ResetAchievedLinearVelocity();
plCoordinateInterface* ci = (plCoordinateInterface*)GetTarget(0)->GetCoordinateInterface();
l2w.RemoveScale();
w2l.RemoveScale();
ci->SetTransform(l2w, w2l);
ci->FlushTransform();
if (plVirtualCam1::Instance())
plVirtualCam1::Instance()->SetCutNextTrans();
if (GetFollowerParticleSystemSO())
{
// Since particles are in world space, if we've got some surrounding us, we've got to translate them to compensate for our warp.
plParticleSystem *sys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(GetFollowerParticleSystemSO()->GetModifierByType(plParticleSystem::Index())));
if (sys)
{
hsPoint3 trans = l2w.GetTranslate() - GetTarget(0)->GetLocalToWorld().GetTranslate();
sys->TranslateAllParticles(trans);
}
}
int nBrains = fBrains.size();
for (int i = 0; i < nBrains; i++)
{
plArmatureBrain * curBrain = fBrains[i];
curBrain->Spawn(time);
}
fWaitFlags &= ~kNeedSpawn;
plAvatarSpawnNotifyMsg *notify = TRACKED_NEW plAvatarSpawnNotifyMsg();
notify->SetTimeStamp(hsTimer::GetSysSeconds() + 0.1);
notify->SetBCastFlag(plMessage::kBCastByExactType);
notify->Send();
EnablePhysics(true);
}
void plArmatureMod::SetFollowerParticleSystemSO(plSceneObject *follower)
{
// TODO: Check for old one and clean up.
hsPoint3 trans = GetTarget(0)->GetLocalToWorld().GetTranslate() - follower->GetLocalToWorld().GetTranslate();
plWarpMsg *warp = TRACKED_NEW plWarpMsg(GetKey(), follower->GetKey(), plWarpMsg::kFlushTransform | plWarpMsg::kZeroVelocity,
GetTarget(0)->GetLocalToWorld());
warp->Send();
hsgResMgr::ResMgr()->AddViaNotify(follower->GetKey(), TRACKED_NEW plAttachMsg(GetTarget(0)->GetKey(), nil, plRefMsg::kOnRequest), plRefFlags::kActiveRef);
fFollowerParticleSystemSO = follower;
plParticleSystem *sys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(follower->GetModifierByType(plParticleSystem::Index())));
if (sys)
{
sys->fMiscFlags |= plParticleSystem::kParticleSystemAlwaysUpdate;
sys->TranslateAllParticles(trans);
sys->SetAttachedToAvatar(true);
}
}
plSceneObject *plArmatureMod::GetFollowerParticleSystemSO()
{
return fFollowerParticleSystemSO;
}
void plArmatureMod::RegisterForBehaviorNotify(plKey key)
{
if (fNotifyKeys.Find(key) == fNotifyKeys.kMissingIndex)
fNotifyKeys.Append(key);
}
void plArmatureMod::UnRegisterForBehaviorNotify(plKey key)
{
fNotifyKeys.RemoveItem(key);
}
void plArmatureMod::IFireBehaviorNotify(UInt32 type, hsBool behaviorStart)
{
if (fNotifyKeys.GetCount() > 0)
{
plAvatarBehaviorNotifyMsg *msg = TRACKED_NEW plAvatarBehaviorNotifyMsg();
msg->SetSender(GetKey());
msg->AddReceivers(fNotifyKeys);
msg->fType = type;
msg->state = behaviorStart;
msg->Send();
}
}
void plArmatureMod::EnterAge(hsBool reSpawn)
{
fMidLink = false;
fAlreadyPanicLinking = false;
EnablePhysics(true, kDisableReasonLinking);
ValidatePhysics();
// force regions to send an update whenever we enter an age
fOldRegionsICareAbout.Clear();
fOldRegionsImIn.Clear();
if (GetFollowerParticleSystemSO())
{
const plParticleSystem *sys = plParticleSystem::ConvertNoRef(GetFollowerParticleSystemSO()->GetModifierByType(plParticleSystem::Index()));
hsAssert(sys, "We have a particle system SO, but no system?");
if (sys)
{
// Need to tell other clients about this
plLoadCloneMsg *clone = TRACKED_NEW plLoadCloneMsg(GetFollowerParticleSystemSO()->GetKey(), plAvatarMgr::GetInstance()->GetKey(), GetKey()->GetUoid().GetClonePlayerID(), true);
clone->SetBCastFlag(plMessage::kLocalPropagate, false);
clone->Send();
GetFollowerParticleSystemSO()->DirtySynchState(plParticleSDLMod::kStrNumParticles, plSynchedObject::kBCastToClients);
}
}
ClearInputFlags(true, false);
if (reSpawn)
fWaitFlags |= kNeedSpawn;
// In case we personal age linked out of a situation and didn't properly
// re-enable input...
plAvatarInputInterface::GetInstance()->EnableForwardMovement(true);
plAvatarInputInterface::GetInstance()->EnableJump(true);
while (fSuspendInputCount > 0)
ResumeInput();
plAvatarInputInterface::GetInstance()->EnableMouseMovement();
}
void plArmatureMod::LeaveAge()
{
plArmatureModBase::LeaveAge();
fMidLink = true;
if (fController)
{
fController->LeaveAge();
}
if (GetFollowerParticleSystemSO())
{
// Need to tell other clients to remove this
plLoadCloneMsg *clone = TRACKED_NEW plLoadCloneMsg(GetFollowerParticleSystemSO()->GetKey(), plAvatarMgr::GetInstance()->GetKey(), GetKey()->GetUoid().GetClonePlayerID(), false);
clone->SetBCastFlag(plMessage::kLocalPropagate, false);
clone->Send();
}
GetArmatureEffects()->ResetEffects();
ClearInputFlags(true, false);
}
void plArmatureMod::PanicLink(hsBool playLinkOutAnim /* = true */)
{
// console override... just go back to the beginning
if (fDontPanicLink)
{
Spawn(0.f);
return;
}
if (fAlreadyPanicLinking)
return;
fAlreadyPanicLinking = true;
plNetApp::StaticDebugMsg("plArmatureMod::PanicLink()");
// make the player book blink as they are linking out
pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kStartBookAlert );
plgDispatch::MsgSend( msg );
// Can't depend on the anim to link if the human brain isn't ready to deal with it
plAvBrainHuman *brain = plAvBrainHuman::ConvertNoRef(GetCurrentBrain());
// If things break then uncomment the code below
if (!brain)// || brain->IsRunningTask())
playLinkOutAnim = false;
if (playLinkOutAnim)
{
plAvOneShotLinkTask *task = TRACKED_NEW plAvOneShotLinkTask;
char *animName = MakeAnimationName("FallingLinkOut");
task->SetAnimName(animName);
task->SetMarkerName("touch");
plAvTaskMsg *taskMsg = TRACKED_NEW plAvTaskMsg(GetKey(), GetKey(), task);
taskMsg->Send();
delete [] animName;
}
else
{
EnablePhysics(false, plArmatureMod::kDisableReasonLinking);
ILinkToPersonalAge();
}
}
void plArmatureMod::PersonalLink()
{
// Can't depend on the anim to link if the human brain isn't ready to deal with it
plAvBrainHuman *brain = plAvBrainHuman::ConvertNoRef(GetCurrentBrain());
if (!brain || brain->IsRunningTask())
ILinkToPersonalAge();
else
{
plAvOneShotLinkTask *task = TRACKED_NEW plAvOneShotLinkTask;
char *animName = MakeAnimationName("PersonalLink");
task->SetAnimName(animName);
task->SetMarkerName("touch");
delete [] animName;
plAvTaskMsg *taskMsg = TRACKED_NEW plAvTaskMsg(GetKey(), GetKey(), task);
taskMsg->SetBCastFlag(plMessage::kNetPropagate);
taskMsg->Send();
}
}
hsBool plArmatureMod::MsgReceive(plMessage* msg)
{
hsBool result = false;
plArmatureBrain *curBrain = nil;
if (fBrains.size() > 0)
{
curBrain = fBrains.back();
if(curBrain->MsgReceive(msg))
return true;
}
plAvatarInputStateMsg *aisMsg = plAvatarInputStateMsg::ConvertNoRef(msg);
if (aisMsg)
{
IHandleInputStateMsg(aisMsg);
return true;
}
plControlEventMsg *control = plControlEventMsg::ConvertNoRef(msg);
if(control)
{
IHandleControlMsg(control);
return true;
}
plCorrectionMsg *corMsg = plCorrectionMsg::ConvertNoRef(msg);
if (corMsg)
{
hsMatrix44 &correction = corMsg->fWorldToLocal * GetTarget(0)->GetLocalToWorld();
if (fBoneRootAnimator)
fBoneRootAnimator->SetCorrection(correction);
}
plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
if (refMsg)
{
plClothingOutfit *outfit = plClothingOutfit::ConvertNoRef(refMsg->GetRef());
if (outfit)
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
fClothingOutfit = outfit;
fClothingOutfit->fAvatar = this;
plgDispatch::Dispatch()->RegisterForExactType(plPipeRTMakeMsg::Index(), fClothingOutfit->GetKey());
}
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
{
if (fClothingOutfit)
plgDispatch::Dispatch()->UnRegisterForExactType(plPipeRTMakeMsg::Index(), fClothingOutfit->GetKey());
fClothingOutfit = nil;
outfit->fAvatar = nil;
}
return true;
}
plArmatureEffectsMgr *effects = plArmatureEffectsMgr::ConvertNoRef(refMsg->GetRef());
if (effects)
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
fEffects = effects;
fEffects->fArmature = this;
}
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
{
fEffects->fArmature = nil;
fEffects = nil;
}
return true;
}
plSceneObject *so = plSceneObject::ConvertNoRef(refMsg->GetRef());
if (so)
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
fClothToSOMap.ExpandAndZero(refMsg->fWhich + 1);
fClothToSOMap[refMsg->fWhich] = so;
}
else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
{
fClothToSOMap[refMsg->fWhich] = nil;
}
return true;
}
}
if (fEffects)
{
plArmatureEffectMsg *aeMsg = plArmatureEffectMsg::ConvertNoRef(msg);
plArmatureEffectStateMsg *aesMsg = plArmatureEffectStateMsg::ConvertNoRef(msg);
if (aeMsg || aesMsg)
return fEffects->MsgReceive(msg);
}
plAttachMsg *aMsg = plAttachMsg::ConvertNoRef(msg);
if (aMsg)
{
GetTarget(0)->MsgReceive(aMsg);
return true;
}
plEnableMsg *enMsg = plEnableMsg::ConvertNoRef(msg);
if(enMsg && enMsg->Type(plEnableMsg::kDrawable))
{
hsBool enable = enMsg->Cmd(plEnableMsg::kEnable);
hsBool disable = enMsg->Cmd(plEnableMsg::kDisable);
hsAssert(enable != disable, "Conflicting or missing commands to enable message");
if(enable != disable)
EnableDrawing(enable);
return true;
}
if(enMsg && enMsg->Cmd(plEnableMsg::kPhysical))
{
EnablePhysics( enMsg->Cmd(plEnableMsg::kEnable));
}
plAvatarOpacityCallbackMsg *opacMsg = plAvatarOpacityCallbackMsg::ConvertNoRef(msg);
if (opacMsg)
{
plLayerLinkAnimation *linkAnim = IFindLayerLinkAnim();
if (linkAnim)
{
bool trans = (linkAnim->GetTimeConvert().CurrentAnimTime() != 0.f);
ISetTransparentDrawOrder(trans);
}
return true;
}
plAvatarPhysicsEnableCallbackMsg *epMsg = plAvatarPhysicsEnableCallbackMsg::ConvertNoRef(msg);
if (epMsg)
{
EnablePhysics(true);
return true;
}
plAvatarStealthModeMsg *stealthMsg = plAvatarStealthModeMsg::ConvertNoRef(msg);
if (stealthMsg && stealthMsg->GetSender() == GetTarget(0)->GetKey() &&
(stealthMsg->fLevel != fStealthLevel || stealthMsg->fMode != fStealthMode))
{
fStealthMode = stealthMsg->fMode;
fStealthLevel = (stealthMsg->fMode == plAvatarStealthModeMsg::kStealthVisible) ? 0 : stealthMsg->fLevel;
if (fStealthMode == plAvatarStealthModeMsg::kStealthCloaked)
{
if (fUpdateMsg)
fUpdateMsg->SetInvis(true);
}
else
{
if (fUpdateMsg)
fUpdateMsg->SetInvis(false);
}
if (fEffects)
fEffects->MsgReceive(stealthMsg);
if (stealthMsg->fMode == plAvatarStealthModeMsg::kStealthCloaked)
EnableDrawing(false, kDisableReasonCCR);
else
EnableDrawing(true, kDisableReasonCCR);
DirtySynchState(kSDLAvatar, 0); // changed invisibility state
plNetApp::StaticDebugMsg("ArmatureMod: rcvd avatarStealth msg, cloaked=%d", stealthMsg->fMode == plAvatarStealthModeMsg::kStealthCloaked);
return true;
}
plParticleTransferMsg *partMsg = plParticleTransferMsg::ConvertNoRef(msg);
if (partMsg)
{
// First, do we have the system?
plSceneObject *dstSysSO = GetFollowerParticleSystemSO();
if (!dstSysSO || ((plKeyImp*)dstSysSO->GetKey())->GetCloneOwner() != partMsg->fSysSOKey)
{
// Need to clone and resend.
if (plNetClientApp::GetInstance()->GetLocalPlayer() != GetTarget(0))
return true; // Only the local player can create the clone.
// Clone is sent to all players.
plLoadCloneMsg *cloneMsg = TRACKED_NEW plLoadCloneMsg(partMsg->fSysSOKey->GetUoid(), plAvatarMgr::GetInstance()->GetKey(), GetKey()->GetUoid().GetClonePlayerID());
cloneMsg->SetTriggerMsg(partMsg);
cloneMsg->SetBCastFlag(plMessage::kNetForce);
cloneMsg->Send();
// Expect to receive a clone message later. Return for now.
return true;
}
else
{
plParticleSystem *dstSys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(dstSysSO->GetModifierByType(plParticleSystem::Index())));
if (dstSys)
{
// Got the system. Time to steal particles!
plParticleSystem *srcSys = nil;
plSceneObject *srcSysSO = plSceneObject::ConvertNoRef(partMsg->fSysSOKey->ObjectIsLoaded());
if (srcSysSO)
srcSys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(srcSysSO->GetModifierByType(plParticleSystem::Index())));
// A nil source system is ok. It just won't copy anything.
int numToGen = partMsg->fNumToTransfer - dstSys->StealParticlesFrom(srcSys, partMsg->fNumToTransfer);
if (numToGen > 0)
{
dstSys->GenerateParticles(numToGen);
}
}
return true;
}
}
plLoadAvatarMsg *avLoadMsg = plLoadAvatarMsg::ConvertNoRef(msg);
if (avLoadMsg)
{
hsBool isPlayer = avLoadMsg->GetIsPlayer();
if (!isPlayer)
plgDispatch::Dispatch()->UnRegisterForExactType(plAgeLoadedMsg::Index(), GetKey());
// see if we're being spawned explictly
plKey spawnPoint = avLoadMsg->GetSpawnPoint();
if (spawnPoint)
{
hsKeyedObject * spawnKO = spawnPoint->ObjectIsLoaded();
if (spawnKO)
{
plSceneObject * spawnSO = plSceneObject::ConvertNoRef(spawnKO);
if(spawnSO)
{
hsMatrix44 l2w = spawnSO->GetLocalToWorld();
plWarpMsg *warpM = TRACKED_NEW plWarpMsg(nil, GetTarget(0)->GetKey(), 0, l2w);
warpM->Send();
fWaitFlags &= ~kNeedSpawn;
}
}
}
// copy the user string over
const char* userStr = avLoadMsg->GetUserStr();
if (userStr)
fUserStr = userStr;
else
fUserStr = "";
return true;
}
plLoadCloneMsg *cloneMsg = plLoadCloneMsg::ConvertNoRef(msg);
if (cloneMsg)
{
if (cloneMsg->GetIsLoading())
{
plSceneObject *so = plSceneObject::ConvertNoRef(cloneMsg->GetCloneKey()->ObjectIsLoaded());
if (so)
{
so->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
plParticleSystem *sys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(so->GetModifierByType(plParticleSystem::Index())));
hsAssert(sys, "Modifier not loaded yet.");
if (sys)
{
sys->DisableGenerators();
sys->MsgReceive(cloneMsg); // Let the system know to finish its init stuff
SetFollowerParticleSystemSO(so);
if (!plNetClientApp::GetInstance()->IsLoadingInitialAgeState())
{
// Just happened. Redirect the trigger and transfer the particles
MsgReceive(cloneMsg->GetTriggerMsg());
}
// otherwise we'll get SDL state about it and handle it in plParticleSDLMod
return true;
}
}
}
else
{
if (cloneMsg->GetCloneKey() == GetFollowerParticleSystemSO())
{
SetFollowerParticleSystemSO(nil);
return true;
}
}
}
plLinkEffectBCMsg *linkBCMsg = plLinkEffectBCMsg::ConvertNoRef(msg);
if (linkBCMsg)
{
if (GetTarget(0)->GetKey() == linkBCMsg->fLinkKey)
{
if (linkBCMsg->HasLinkFlag(plLinkEffectBCMsg::kLeavingAge))
{
fMidLink = true;
IFireBehaviorNotify(plHBehavior::kBehaviorTypeLinkOut, true);
}
else
IFireBehaviorNotify(plHBehavior::kBehaviorTypeLinkIn, true);
}
return true;
}
plLinkInDoneMsg *doneMsg = plLinkInDoneMsg::ConvertNoRef(msg);
if (doneMsg)
{
IFireBehaviorNotify(plHBehavior::kBehaviorTypeLinkIn, false);
return true;
}
plAgeLoadedMsg *ageLoadMsg = plAgeLoadedMsg::ConvertNoRef(msg);
if (ageLoadMsg && ageLoadMsg->fLoaded)
{
// only the local player gets these
NetworkSynch(hsTimer::GetSysSeconds(), true);
EnablePhysics(true);
return true;
}
plAnimCmdMsg *cmdMsg = plAnimCmdMsg::ConvertNoRef(msg);
if (cmdMsg)
{
hsAssert(false, "Illegal use of plAnimCmdMsg on an avatar.");
return true;
}
plSubWorldMsg* subMsg = plSubWorldMsg::ConvertNoRef(msg);
if (subMsg)
{
if (fController)
{
fController->SetSubworld(subMsg->fWorldKey);
DirtySynchState(kSDLAvatar, plSynchedObject::kBCastToClients);
}
return true;
}
return plAGMasterMod::MsgReceive(msg);
}
hsBool plArmatureMod::IHandleControlMsg(plControlEventMsg* pMsg)
{
// Slight change in design here...
// Avatar input control messages are only sent locally.
// When things change (that a remote client would care about),
// we call SynchInputState and that sends off the bit vector
// for the state of all avatar input controls.
//
// This means a remote player will only know which controls are
// active at a certain point. It might miss a particular keypress.
// Don't rely on them receiving it.
if (fSuspendInputCount > 0)
{
fQueuedCtrlMessages.push_back(pMsg);
pMsg->Ref();
}
else
{
ControlEventCode moveCode = pMsg->GetControlCode();
hsBool flagChanged = false;
if(pMsg->ControlActivated())
{
if (moveCode == B_CONTROL_TURN_TO && fClickToTurn)
{
#if 0
// This will do an LOS and call TurnToPoint()
plSceneInputInterface::GetInstance()->RequestAvatarTurnToPointLOS();
#else
plVisHit hit;
if( plVisLOSMgr::Instance()->CursorCheck(hit) )
TurnToPoint(hit.fPos);
#endif
return true;
}
// This control is intended for turning while walking/running.
// It is never net propagated. We just flag our physics state
// as dirty, and let the physics synch (with dead reckoning) handle it.
if (moveCode == A_CONTROL_TURN)
{
// Filter out the messages that are just the mouse recentering
if (pMsg->GetPct() < 0.4 && pMsg->GetPct() > -0.4)
{
fMouseFrameTurnStrength += pMsg->GetPct() * fMouseTurnSensitivity;
SynchIfLocal(hsTimer::GetSysSeconds(), false);
}
}
if (!GetInputFlag( moveCode ) )
{
SetInputFlag( moveCode, true );
flagChanged = true;
if (moveCode == B_CONTROL_JUMP)
SetInputFlag(B_CONTROL_CONSUMABLE_JUMP, true);
if(plNetClientMgr::GetInstance()->AmCCR())
{
// special case for clipping: synch every key change
SynchIfLocal( hsTimer::GetSysSeconds(), false);
}
}
} else {
if ( GetInputFlag( moveCode ) )
{
SetInputFlag( moveCode, false );
flagChanged = true;
if (fReverseFBOnIdle && (moveCode == B_CONTROL_MOVE_FORWARD || moveCode == B_CONTROL_MOVE_BACKWARD))
{
if (!GetInputFlag(B_CONTROL_MOVE_FORWARD) && !GetInputFlag(B_CONTROL_MOVE_BACKWARD))
SetInputFlag(B_CONTROL_LADDER_INVERTED, true);
}
}
}
if (flagChanged && plAvatarInputStateMsg::IsCodeInMap(moveCode))
SynchInputState();
}
return true;
}
void plArmatureMod::IHandleInputStateMsg(plAvatarInputStateMsg *msg)
{
int i;
UInt32 curBit;
for (i = 0, curBit = 0x1; i < plAvatarInputStateMsg::fMapSize; i++, curBit <<= 1)
{
SetInputFlag(msg->fCodeMap[i], msg->fState & curBit);
}
}
void plArmatureMod::SynchInputState(UInt32 rcvID /* = kInvalidPlayerID */)
{
if (plAvatarMgr::GetInstance()->GetLocalAvatar() != this)
return;
plAvatarInputStateMsg *msg = TRACKED_NEW plAvatarInputStateMsg();
int i;
UInt32 curBit;
for (i = 0, curBit = 0x1; i < plAvatarInputStateMsg::fMapSize; i++, curBit <<= 1)
{
if (GetInputFlag(msg->fCodeMap[i]))
msg->fState |= curBit;
}
msg->AddReceiver(GetKey());
msg->SetBCastFlag(plMessage::kNetPropagate);
msg->SetBCastFlag(plMessage::kNetUseRelevanceRegions);
msg->SetBCastFlag(plMessage::kLocalPropagate, false);
msg->SetBCastFlag(plMessage::kNetSendUnreliable, true);
if (rcvID != kInvalidPlayerID)
msg->AddNetReceiver(rcvID);
msg->Send();
fLastInputSynch = hsTimer::GetSysSeconds();
}
void plArmatureMod::ILinkToPersonalAge()
{
plNetClientMgr * nc = plNetClientMgr::GetInstance();
plAgeLinkStruct link;
link.GetAgeInfo()->SetAgeFilename( kPersonalAgeFilename );
link.GetAgeInfo()->SetAgeInstanceName( kPersonalAgeInstanceName );
plSpawnPointInfo hutSpawnPoint;
hutSpawnPoint.SetName(kPersonalAgeLinkInPointCloset);
link.SetSpawnPoint(hutSpawnPoint);
link.SetLinkingRules( plNetCommon::LinkingRules::kOriginalBook );
plLinkToAgeMsg* pMsg = TRACKED_NEW plLinkToAgeMsg( &link );
pMsg->SetLinkInAnimName("PersonalBookEnter");
pMsg->AddReceiver(nc->GetKey());
pMsg->Send();
}
hsBool plArmatureMod::IEval(double time, hsScalar elapsed, UInt32 dirty)
{
if (IsFinal())
{
bool noOverlap = false;
const plArmatureMod *localPlayer = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (plRelevanceMgr::Instance()->GetEnabled() && (localPlayer != nil))
{
// (May decide to update this elsewhere instead.)
plRelevanceMgr::Instance()->SetRegionVectors(GetTarget(0)->GetLocalToWorld().GetTranslate(), fRegionsImIn, fRegionsICareAbout);
if (localPlayer != this)
{
if (!fRegionsImIn.Overlap(localPlayer->fRegionsICareAbout))
{
noOverlap = true;
}
}
else // Bookkeeping for the local player...
{
hsBool update = false;
if (fOldRegionsICareAbout != fRegionsICareAbout)
{
update = true;
fOldRegionsICareAbout = fRegionsICareAbout;
}
if (fOldRegionsImIn != fRegionsImIn)
{
update = true;
fOldRegionsImIn = fRegionsImIn;
}
if (update)
{
// Send message to the server here.
plNetMsgRelevanceRegions relRegionsNetMsg;
relRegionsNetMsg.SetNetProtocol(kNetProtocolCli2Game);
relRegionsNetMsg.SetRegionsICareAbout(fRegionsICareAbout);
relRegionsNetMsg.SetRegionsImIn(fRegionsImIn);
plNetClientApp::GetInstance()->SendMsg(&relRegionsNetMsg);
}
}
}
if (localPlayer == this)
{
if (time - fLastInputSynch > kAvatarInputSynchThreshold)
SynchInputState();
}
if (noOverlap)
{
EnablePhysics(false, kDisableReasonRelRegion);
EnableDrawing(false, kDisableReasonRelRegion);
}
else
{
EnablePhysics(true, kDisableReasonRelRegion);
EnableDrawing(true, kDisableReasonRelRegion);
}
if (fMouseFrameTurnStrength == 0 && GetInputFlag(A_CONTROL_TURN))
SetInputFlag(A_CONTROL_TURN, false);
if (!fMidLink)
plArmatureModBase::IEval(time, elapsed, dirty);
fUpdateMsg->Ref();
fUpdateMsg->Send();
if (fPendingSynch)
NetworkSynch(time, false);
if (fDebugOn)
RefreshDebugDisplay();
fMouseFrameTurnStrength = 0.f; // Processed this frame. Clear it.
// update our attached particle system if necessary
if (GetFollowerParticleSystemSO())
{
plSceneObject* follower = GetFollowerParticleSystemSO();
hsPoint3 trans = GetTarget(0)->GetLocalToWorld().GetTranslate() - follower->GetLocalToWorld().GetTranslate();
if (trans.MagnitudeSquared() > 1) // we can be a bit fuzzy about this, since the particle system is rather large and people won't notice it being off
{
plWarpMsg *warp = TRACKED_NEW plWarpMsg(GetKey(), follower->GetKey(), plWarpMsg::kFlushTransform | plWarpMsg::kZeroVelocity,
GetTarget(0)->GetLocalToWorld());
warp->Send();
plParticleSystem *sys = const_cast<plParticleSystem*>(plParticleSystem::ConvertNoRef(follower->GetModifierByType(plParticleSystem::Index())));
if (sys)
{
sys->fMiscFlags |= plParticleSystem::kParticleSystemAlwaysUpdate;
sys->TranslateAllParticles(trans);
}
}
}
}
else
IFinalize();
return true;
}
void plArmatureMod::AddTarget(plSceneObject* so)
{
plArmatureModBase::AddTarget(so);
plAvatarMgr::GetInstance()->AddAvatar(this); // register for easy lookup
plgDispatch::Dispatch()->RegisterForExactType(plAvatarMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plLinkEffectBCMsg::Index(), GetKey());
// all avatars will register for the age loaded message.
// only players need it, but we don't know that we're a player until it's too late to get it.
// non-players will unregister when they learn the truth.
if (IsLocallyOwned())
plgDispatch::Dispatch()->RegisterForExactType(plAgeLoadedMsg::Index(), GetKey());
// attach a clothingSDLModifier to handle clothing saveState
delete fClothingSDLMod;
fClothingSDLMod = TRACKED_NEW plClothingSDLModifier;
fClothingSDLMod->SetClothingOutfit(GetClothingOutfit()); // ok if clothingOutfit is nil at this point
so->AddModifier(fClothingSDLMod);
// add avatar sdl modifier
delete fAvatarSDLMod;
fAvatarSDLMod = TRACKED_NEW plAvatarSDLModifier;
so->AddModifier(fAvatarSDLMod);
delete fAvatarPhysicalSDLMod;
fAvatarPhysicalSDLMod = TRACKED_NEW plAvatarPhysicalSDLModifier;
so->AddModifier(fAvatarPhysicalSDLMod);
// At export time, this key will be nil. This is important, or else we'll overwrite the page the key comes from.
if (fFootSoundSOKey != nil)
hsgResMgr::ResMgr()->AddViaNotify(fFootSoundSOKey, TRACKED_NEW plAttachMsg(so->GetKey(), nil, plRefMsg::kOnRequest), plRefFlags::kActiveRef);
if (fLinkSoundSOKey != nil)
hsgResMgr::ResMgr()->AddViaNotify(fLinkSoundSOKey, TRACKED_NEW plAttachMsg(so->GetKey(), nil, plRefMsg::kOnRequest), plRefFlags::kActiveRef);
if (fUpdateMsg)
fUpdateMsg->UnRef(); // delete an old one.
fUpdateMsg = TRACKED_NEW plArmatureUpdateMsg(GetKey(), so->IsLocallyOwned(), true, this);
}
void plArmatureMod::RemoveTarget(plSceneObject* so)
{
if (so)
{
if (fClothingSDLMod)
so->RemoveModifier(fClothingSDLMod);
if (fAvatarSDLMod)
so->RemoveModifier(fAvatarSDLMod);
if (fAvatarPhysicalSDLMod)
so->RemoveModifier(fAvatarPhysicalSDLMod);
}
delete fClothingSDLMod;
fClothingSDLMod = nil;
delete fAvatarSDLMod;
fAvatarSDLMod = nil;
delete fAvatarPhysicalSDLMod;
fAvatarPhysicalSDLMod = nil;
plArmatureModBase::RemoveTarget(so);
}
void plArmatureMod::Write(hsStream *stream, hsResMgr *mgr)
{
// Temporarily going around plArmatureModBase so that we don't
// break format
plAGMasterMod::Write(stream, mgr);
mgr->WriteKey(stream, fMeshKeys[0]);
stream->WriteSafeString(fRootName);
int nBrains = fBrains.size();
stream->WriteSwap32(nBrains);
for (int i = 0; i < nBrains; i++)
mgr->WriteCreatable(stream, fBrains[i]);
if (fClothingOutfit == nil)
{
stream->WriteBool( false );
}
else
{
stream->WriteBool( true );
mgr->WriteKey(stream, fClothingOutfit->GetKey());
}
stream->WriteSwap32(fBodyType);
if( fEffects == nil )
stream->WriteBool( false );
else
{
stream->WriteBool( true );
mgr->WriteKey(stream, fEffects->GetKey());
}
stream->WriteSwapFloat(fPhysHeight);
stream->WriteSwapFloat(fPhysWidth);
stream->WriteSafeString(fAnimationPrefix.c_str());
stream->WriteSafeString(fBodyAgeName.c_str());
stream->WriteSafeString(fBodyFootstepSoundPage.c_str());
}
void plArmatureMod::Read(hsStream * stream, hsResMgr *mgr)
{
// Temporarily going around plArmatureModBase so that we don't
// break format
plAGMasterMod::Read(stream, mgr);
fMeshKeys.push_back(mgr->ReadKey(stream));
// read the root name string
fRootName = stream->ReadSafeString();
// read in the brains
int nBrains = stream->ReadSwap32();
for (int i = 0; i < nBrains; i++)
{
plArmatureBrain * brain = (plArmatureBrain *)mgr->ReadCreatable(stream);
this->PushBrain(brain);
}
if( stream->ReadBool() )
mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // plClothingBase
else
fClothingOutfit = nil;
fBodyType = stream->ReadSwap32();
if( stream->ReadBool() )
{
plKey effectMgrKey = mgr->ReadKey(stream);
mgr->AddViaNotify(effectMgrKey, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // plArmatureEffects
// Attach the Footstep emitter scene object
hsResMgr *mgr = hsgResMgr::ResMgr();
const char *age = fBodyAgeName.c_str();
const char *page = fBodyFootstepSoundPage.c_str();
const plLocation &gLoc = plKeyFinder::Instance().FindLocation(age, page);
if (gLoc.IsValid())
{
const plUoid &myUoid = GetKey()->GetUoid();
plUoid SOUoid(gLoc, plSceneObject::Index(), "FootstepSoundObject");
fFootSoundSOKey = mgr->FindKey(SOUoid);
if (fFootSoundSOKey)
{
// So it exists... but FindKey won't properly create our clone. So we do.
SOUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
fFootSoundSOKey = mgr->ReRegister(nil, SOUoid);
}
// Add the effect to our effects manager
plUoid effectUoid(gLoc, plArmatureEffectFootSound::Index(), "FootstepSounds" );
plKey effectKey = mgr->FindKey(effectUoid);
if (effectKey)
{
effectUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
effectKey = mgr->ReRegister(nil, effectUoid);
}
if (effectKey != nil)
mgr->AddViaNotify(effectKey, TRACKED_NEW plGenRefMsg(effectMgrKey, plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef);
// Get the linking sound
plUoid LinkUoid(gLoc, plSceneObject::Index(), "LinkSoundSource");
fLinkSoundSOKey = mgr->FindKey(LinkUoid);
if (fLinkSoundSOKey)
{
LinkUoid.SetClone(myUoid.GetClonePlayerID(), myUoid.GetCloneID());
fLinkSoundSOKey = mgr->ReRegister(nil, LinkUoid);
}
}
}
else
fEffects = nil;
fPhysHeight = stream->ReadSwapFloat();
fPhysWidth = stream->ReadSwapFloat();
char* temp = stream->ReadSafeString();
fAnimationPrefix = temp;
delete [] temp;
temp = stream->ReadSafeString();
fBodyAgeName = temp;
delete [] temp;
temp = stream->ReadSafeString();
fBodyFootstepSoundPage = temp;
delete [] temp;
plgDispatch::Dispatch()->RegisterForExactType(plAvatarStealthModeMsg::Index(), GetKey());
}
hsBool plArmatureMod::DirtySynchState(const char* SDLStateName, UInt32 synchFlags)
{
// skip requests to synch non-avatar state
if (SDLStateName && stricmp(SDLStateName, kSDLAvatar))
{
return false;
}
synchFlags |= plSynchedObject::kForceFullSend; // TEMP
if(GetNumTargets() > 0)
{
plSceneObject *sObj = GetTarget(0);
if(sObj)
sObj->DirtySynchState(SDLStateName, synchFlags);
}
return false;
}
hsBool plArmatureMod::DirtyPhysicalSynchState(UInt32 synchFlags)
{
synchFlags |= plSynchedObject::kForceFullSend; // TEMP
synchFlags |= plSynchedObject::kBCastToClients;
if(GetNumTargets() > 0)
{
plSceneObject *sObj = GetTarget(0);
if(sObj)
sObj->DirtySynchState(kSDLAvatarPhysical, synchFlags);
}
return false;
}
void plArmatureMod::IFinalize()
{
plArmatureModBase::IFinalize();
if (fWaitFlags & kNeedAudio)
{
plSetListenerMsg *msg = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVelocity, GetTarget(0)->GetKey(), true );
msg->Send();
fWaitFlags &= ~kNeedAudio;
}
if (fWaitFlags & kNeedCamera)
{
plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
pMsg->SetCmd(plCameraMsg::kCreateNewDefaultCam);
pMsg->SetCmd(plCameraMsg::kSetSubject);
pMsg->SetSubject(GetTarget(0));
pMsg->SetBCastFlag( plMessage::kBCastByExactType );
pMsg->Send();
fWaitFlags &= ~kNeedCamera;
}
if (fWaitFlags & kNeedSpawn)
{
Spawn(hsTimer::GetSysSeconds());
fWaitFlags &= ~kNeedSpawn;
}
}
void plArmatureMod::ICustomizeApplicator()
{
plArmatureModBase::ICustomizeApplicator();
const plAGModifier *agMod = GetChannelMod("Bone_Root", true);
if (agMod)
{
// are there any applicators that manipulate the transform?
plAGApplicator *app = agMod->GetApplicator(kAGPinTransform);
if(app)
{
plMatrixDelayedCorrectionApplicator *corApp = plMatrixDelayedCorrectionApplicator::ConvertNoRef(app);
if (corApp)
{
fBoneRootAnimator = corApp;
fWaitFlags &= ~kNeedApplicator;
return; // already there
}
}
plAGModifier *volAGMod = const_cast<plAGModifier *>(agMod);
fBoneRootAnimator = TRACKED_NEW plMatrixDelayedCorrectionApplicator();
volAGMod->SetApplicator(fBoneRootAnimator);
fWaitFlags &= ~kNeedApplicator;
}
}
const plSceneObject *plArmatureMod::GetClothingSO(UInt8 lod) const
{
if (fClothToSOMap.GetCount() <= lod)
return nil;
return fClothToSOMap[lod];
}
#define kSynchInterval 1 // synch once per second
void plArmatureMod::NetworkSynch(double timeNow, int force)
{
if (force || ((timeNow - fLastSynch) > kSynchInterval))
{
// make sure state change gets sent out over the network
// avatar state should use relevance region filtering
UInt32 flags = kBCastToClients | kUseRelevanceRegions;
if (force)
flags |= kForceFullSend;
DirtyPhysicalSynchState(flags);
fLastSynch = timeNow;
fPendingSynch = false;
}
else
fPendingSynch = true;
}
hsBool plArmatureMod::IsLocalAvatar()
{
return plAvatarMgr::GetInstance()->GetLocalAvatar() == this;
}
hsBool plArmatureMod::IsLocalAI()
{
plAvBrainCritter* ai = plAvBrainCritter::ConvertNoRef(FindBrainByClass(plAvBrainCritter::Index()));
if (ai)
return ai->LocallyControlled();
return false; // not an AI, obviously not local
}
void plArmatureMod::SynchIfLocal(double timeNow, int force)
{
if (IsLocalAvatar() || IsLocalAI())
{
NetworkSynch(timeNow, force);
}
}
plLayerLinkAnimation *plArmatureMod::IFindLayerLinkAnim()
{
int i;
hsGMaterial *mat = fClothingOutfit->fMaterial;
if (!mat)
return nil;
for (i = 0; i < mat->GetNumLayers(); i++)
{
plLayerInterface *li = mat->GetLayer(i);
while (li != nil)
{
plLayerLinkAnimation *anim = plLayerLinkAnimation::ConvertNoRef(li);
if (anim)
return anim;
li = li->GetUnderLay();
}
}
return nil;
}
hsBool plArmatureMod::ValidatePhysics()
{
if (!fTarget)
return false;
if (!fController)
fController = plPhysicalControllerCore::Create(GetTarget(0)->GetKey(), fPhysHeight, fPhysWidth);
if (fController)
{
if (GetTarget(0)->GetKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey())
{
// local avatars get added to a special LOS db just for them.
fController->SetLOSDB(plSimDefs::kLOSDBLocalAvatar);
}
else
{
// non-local avatars are in the same LOS db as clickables
fController->SetLOSDB(plSimDefs::kLOSDBUIItems);
}
hsClearBits(fWaitFlags, kNeedPhysics);
return true;
}
else
{
return false;
}
}
hsBool plArmatureMod::ValidateMesh()
{
if (fWaitFlags & kNeedMesh)
{
fWaitFlags &= ~kNeedMesh;
int n = fMeshKeys.size();
for(int i = 0; i < n; i++)
{
plKey meshKey = fMeshKeys[i];
plSceneObject * meshObj = (plSceneObject *)meshKey->GetObjectPtr();
if( ! meshObj)
{
fWaitFlags |= kNeedMesh;
break;
}
hsBool visible = (i == fCurLOD) ? true : false;
EnableDrawingTree(meshObj, visible);
// If we haven't created the mapping yet...
if (fClothToSOMap.GetCount() <= i || fClothToSOMap[i] == nil)
{
plGenRefMsg *refMsg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, i, 0);
hsgResMgr::ResMgr()->SendRef(meshObj->GetKey(), refMsg, plRefFlags::kPassiveRef);
}
}
if (!strcmp(GetTarget(0)->GetKeyName(), "Yeesha"))
ISetTransparentDrawOrder(true);
else
ISetTransparentDrawOrder(false);
}
return !(fWaitFlags & kNeedMesh);
}
plArmatureBrain * plArmatureMod::GetNextBrain(plArmatureBrain *brain)
{
plArmatureBrain * result = nil;
bool passedTarget = false;
int count = fBrains.size();
for(int i = count - 1; i >= 0; i--)
{
plArmatureBrain *curBrain = fBrains.at(i);
if(passedTarget)
result = curBrain;
else {
if(curBrain == brain)
passedTarget = true;
}
}
return result;
}
int plArmatureMod::GetBrainCount()
{
return fBrains.size();
}
plArmatureBrain * plArmatureMod::FindBrainByClass(UInt32 classID) const
{
int n = fBrains.size();
for(int i = 0; i < n; i++)
{
plArmatureBrain *brain = fBrains.at(i);
if(brain->ClassIndex() == classID)
{
return brain;
}
}
return nil;
}
void plArmatureMod::TurnToPoint(hsPoint3 &point)
{
plAvBrainHuman *brain = plAvBrainHuman::ConvertNoRef(FindBrainByClass(plAvBrainHuman::Index()));
if (brain)
brain->TurnToPoint(point);
}
void plArmatureMod::SuspendInput()
{
if (fSuspendInputCount == 0 && plNetClientApp::GetInstance()->GetLocalPlayer() == GetTarget(0))
{
plAvatarInputInterface::GetInstance()->SuspendMouseMovement();
PreserveInputState();
ClearInputFlags(false, false);
}
fSuspendInputCount++;
}
void plArmatureMod::ResumeInput()
{
if (fSuspendInputCount > 0) // decrementing an unsigned variable set to 0 is BAD
fSuspendInputCount--;
if(fSuspendInputCount == 0)
{
RestoreInputState();
IProcessQueuedInput();
if (plNetClientApp::GetInstance()->GetLocalPlayer() == GetTarget(0))
plAvatarInputInterface::GetInstance()->EnableMouseMovement();
}
}
void plArmatureMod::IProcessQueuedInput()
{
CtrlMessageVec::iterator i = fQueuedCtrlMessages.begin();
CtrlMessageVec::iterator end = fQueuedCtrlMessages.end();
while(i != end)
{
plControlEventMsg *ctrlMsg = *i;
IHandleControlMsg(ctrlMsg);
ctrlMsg->UnRef();
(*i) = nil;
i++;
}
fQueuedCtrlMessages.clear();
}
void plArmatureMod::PreserveInputState()
{
fMoveFlagsBackup = fMoveFlags;
}
void plArmatureMod::RestoreInputState()
{
fMoveFlags = fMoveFlagsBackup;
}
hsBool plArmatureMod::GetInputFlag (int which) const
{
return fMoveFlags.IsBitSet(which);
}
void plArmatureMod::SetInputFlag(int which, hsBool status)
{
if(status)
{
fMoveFlags.SetBit(which);
} else {
fMoveFlags.ClearBit(which);
}
}
hsBool plArmatureMod::HasMovementFlag() const
{
return (fMoveFlags.IsBitSet(B_CONTROL_MOVE_FORWARD) ||
fMoveFlags.IsBitSet(B_CONTROL_MOVE_BACKWARD) ||
fMoveFlags.IsBitSet(B_CONTROL_ROTATE_LEFT) ||
fMoveFlags.IsBitSet(B_CONTROL_ROTATE_RIGHT) ||
fMoveFlags.IsBitSet(A_CONTROL_TURN) ||
fMoveFlags.IsBitSet(B_CONTROL_STRAFE_LEFT) ||
fMoveFlags.IsBitSet(B_CONTROL_STRAFE_RIGHT));
}
bool plArmatureMod::ForwardKeyDown() const
{
return GetInputFlag(B_CONTROL_MOVE_FORWARD) ? true : false;
}
bool plArmatureMod::BackwardKeyDown() const
{
return GetInputFlag(B_CONTROL_MOVE_BACKWARD) ? true : false;
}
bool plArmatureMod::StrafeLeftKeyDown() const
{
return GetInputFlag(B_CONTROL_STRAFE_LEFT) ? true : false;
}
bool plArmatureMod::StrafeRightKeyDown() const
{
return GetInputFlag(B_CONTROL_STRAFE_RIGHT) ? true : false;
}
bool plArmatureMod::FastKeyDown() const
{
return ((GetInputFlag(B_CONTROL_MODIFIER_FAST) && !GetInputFlag(B_CONTROL_ALWAYS_RUN)) ||
(!GetInputFlag(B_CONTROL_MODIFIER_FAST) && GetInputFlag(B_CONTROL_ALWAYS_RUN)));
}
bool plArmatureMod::StrafeKeyDown() const
{
return GetInputFlag(B_CONTROL_MODIFIER_STRAFE) ? true : false;
}
bool plArmatureMod::TurnLeftKeyDown() const
{
return GetInputFlag(B_CONTROL_ROTATE_LEFT) ? true : false;
}
bool plArmatureMod::TurnRightKeyDown() const
{
return GetInputFlag(B_CONTROL_ROTATE_RIGHT) ? true : false;
}
bool plArmatureMod::JumpKeyDown() const
{
return GetInputFlag(B_CONTROL_JUMP) ? true : false;
}
bool plArmatureMod::ExitModeKeyDown() const
{
return GetInputFlag(B_CONTROL_EXIT_MODE) ? true : false;
}
void plArmatureMod::SetForwardKeyDown()
{
SetInputFlag(B_CONTROL_MOVE_FORWARD, true);
}
void plArmatureMod::SetBackwardKeyDown()
{
SetInputFlag(B_CONTROL_MOVE_BACKWARD, true);
}
void plArmatureMod::SetStrafeLeftKeyDown(bool status)
{
SetInputFlag(B_CONTROL_STRAFE_LEFT, status);
}
void plArmatureMod::SetStrafeRightKeyDown(bool status)
{
SetInputFlag(B_CONTROL_STRAFE_RIGHT, status);
}
void plArmatureMod::SetFastKeyDown()
{
SetInputFlag(B_CONTROL_MODIFIER_FAST, true);
}
void plArmatureMod::SetTurnLeftKeyDown(bool status)
{
SetInputFlag(B_CONTROL_ROTATE_LEFT, status);
}
void plArmatureMod::SetTurnRightKeyDown(bool status)
{
SetInputFlag(B_CONTROL_ROTATE_RIGHT, status);
}
void plArmatureMod::SetJumpKeyDown()
{
SetInputFlag(B_CONTROL_JUMP, true);
}
hsScalar plArmatureMod::GetTurnStrength() const
{
return GetKeyTurnStrength() + GetAnalogTurnStrength();
}
hsScalar plArmatureMod::GetKeyTurnStrength() const
{
if (StrafeKeyDown())
return 0.f;
return (TurnLeftKeyDown() ? 1.f : 0.f) + (TurnRightKeyDown() ? -1.f: 0.f);
}
hsScalar plArmatureMod::GetAnalogTurnStrength() const
{
if (StrafeKeyDown())
return 0.f;
hsScalar elapsed = hsTimer::GetDelSysSeconds();
if (elapsed > 0)
return fMouseFrameTurnStrength / elapsed;
else
return 0;
}
void plArmatureMod::SetReverseFBOnIdle(bool val)
{
fReverseFBOnIdle = val;
if (val)
SetInputFlag(B_CONTROL_LADDER_INVERTED, !(ForwardKeyDown() || BackwardKeyDown()));
else
SetInputFlag(B_CONTROL_LADDER_INVERTED, false);
}
hsBool plArmatureMod::IsFBReversed()
{
return GetInputFlag(B_CONTROL_LADDER_INVERTED);
}
void plArmatureMod::ClearInputFlags(bool saveAlwaysRun, bool clearBackup)
{
bool alwaysRun = (fMoveFlags.IsBitSet(B_CONTROL_ALWAYS_RUN) != 0);
bool fast = (fMoveFlags.IsBitSet(B_CONTROL_MODIFIER_FAST) != 0);
fMoveFlags.Clear();
if (saveAlwaysRun)
{
if (alwaysRun)
fMoveFlags.SetBit(B_CONTROL_ALWAYS_RUN);
if (fast)
fMoveFlags.SetBit(B_CONTROL_MODIFIER_FAST);
}
if (clearBackup)
{
alwaysRun = (fMoveFlagsBackup.IsBitSet(B_CONTROL_ALWAYS_RUN) != 0);
fast = (fMoveFlagsBackup.IsBitSet(B_CONTROL_MODIFIER_FAST) != 0);
fMoveFlagsBackup.Clear();
if (saveAlwaysRun)
{
if (alwaysRun)
fMoveFlagsBackup.SetBit(B_CONTROL_ALWAYS_RUN);
if (fast)
fMoveFlagsBackup.SetBit(B_CONTROL_MODIFIER_FAST);
}
}
}
plAGModifier * plArmatureMod::GetRootAGMod()
{
if(fRootAGMod)
return fRootAGMod;
if(fTarget)
{
const plAGModifier * shit = plAGModifier::ConvertNoRef(FindModifierByClass(fTarget, plAGModifier::Index()));
fRootAGMod = const_cast<plAGModifier *>(shit);
}
return fRootAGMod;
}
int plArmatureMod::GetCurrentGenericType()
{
plAvBrainGeneric *brain = plAvBrainGeneric::ConvertNoRef(GetCurrentBrain());
if (!brain)
return plAvBrainGeneric::kNonGeneric;
else
return brain->GetType();
}
bool plArmatureMod::FindMatchingGenericBrain(const char *names[], int count)
{
int i;
for (i = 0; i < GetBrainCount(); i++)
{
plAvBrainGeneric *brain = plAvBrainGeneric::ConvertNoRef(GetBrain(i));
if (brain && brain->MatchAnimNames(names, count))
return true;
}
return false;
}
char *plArmatureMod::MakeAnimationName(const char *baseName) const
{
std::string temp = fAnimationPrefix + baseName;
char *result = hsStrcpy(temp.c_str()); // why they want a new string I'll never know... but hey, too late to change it now
return result;
}
char *plArmatureMod::GetRootName()
{
return fRootName;
}
void plArmatureMod::SetRootName(const char *name)
{
delete [] fRootName;
fRootName = hsStrcpy(name);
}
plAGAnim *plArmatureMod::FindCustomAnim(const char *baseName) const
{
char *customName = MakeAnimationName(baseName);
plAGAnim *result = plAGAnim::FindAnim(customName);
delete[] customName;
return result;
}
void plArmatureMod::ISetupMarkerCallbacks(plATCAnim *anim, plAnimTimeConvert *atc)
{
std::vector<char*> markers;
anim->CopyMarkerNames(markers);
int i;
for (i = 0; i < markers.size(); i++)
{
hsScalar time = -1;
hsBool isLeft = false;
if (strstr(markers[i], "SndLeftFootDown") == markers[i])
{
isLeft = true;
time = anim->GetMarker(markers[i]);
}
if (strstr(markers[i], "SndRightFootDown") == markers[i])
time = anim->GetMarker(markers[i]);
if (time >= 0)
{
plEventCallbackInterceptMsg *iMsg;
plArmatureEffectMsg *msg = TRACKED_NEW plArmatureEffectMsg(fEffects->GetKey(), kTime);
msg->fEventTime = time;
msg->fTriggerIdx = AnimNameToIndex(anim->GetName());
iMsg = TRACKED_NEW plEventCallbackInterceptMsg();
iMsg->AddReceiver(fEffects->GetKey());
iMsg->fEventTime = time;
iMsg->fEvent = kTime;
iMsg->SetMessage(msg);
atc->AddCallback(iMsg);
hsRefCnt_SafeUnRef(msg);
hsRefCnt_SafeUnRef(iMsg);
plAvatarFootMsg* foot = TRACKED_NEW plAvatarFootMsg(GetKey(), this, isLeft);
foot->fEventTime = time;
iMsg = TRACKED_NEW plEventCallbackInterceptMsg();
iMsg->AddReceiver(fEffects->GetKey());
iMsg->fEventTime = time;
iMsg->fEvent = kTime;
iMsg->SetMessage(foot);
atc->AddCallback(iMsg);
hsRefCnt_SafeUnRef(foot);
hsRefCnt_SafeUnRef(iMsg);
}
delete [] markers[i]; // done with this string, nuke it
}
}
const char *plArmatureMod::GetAnimRootName(const char *name)
{
return name + fAnimationPrefix.length();
}
Int8 plArmatureMod::AnimNameToIndex(const char *name)
{
const char *rootName = GetAnimRootName(name);
Int8 result = -1;
if (!strcmp(rootName, "Walk") || !strcmp(rootName, "WalkBack") ||
!strcmp(rootName, "LadderDown") || !strcmp(rootName, "LadderDownOn") ||
!strcmp(rootName, "LadderDownOff") || !strcmp(rootName, "LadderUp") ||
!strcmp(rootName, "LadderUpOn") || !strcmp(rootName, "LadderUpOff") ||
!strcmp(rootName, "SwimSlow") || !strcmp(rootName, "SwimBackward") ||
!strcmp(rootName, "BallPushWalk"))
result = kWalk;
else if (!strcmp(rootName, "Run") || !strcmp(rootName, "SwimFast"))
result = kRun;
else if (!strcmp(rootName, "TurnLeft") || !strcmp(rootName, "TurnRight") ||
!strcmp(rootName, "StepLeft") || !strcmp(rootName, "StepRight") ||
!strcmp(rootName, "SideSwimLeft") || !strcmp(rootName, "SideSwimRight") ||
!strcmp(rootName, "TreadWaterTurnLeft") || !strcmp(rootName, "TreadWaterTurnRight"))
result = kTurn;
else if (!strcmp(rootName, "GroundImpact") || !strcmp(rootName, "RunningImpact"))
result = kImpact;
else if (strstr(rootName, "Run")) // Critters
result = kRun;
else if (strstr(rootName, "Idle")) // Critters
result = kWalk;
return result;
}
hsBool plArmatureMod::IsInStealthMode() const
{
return (fStealthMode != plAvatarStealthModeMsg::kStealthVisible);
}
bool plArmatureMod::IsOpaque()
{
return fOpaque;
}
bool plArmatureMod::IsMidLink()
{
return fMidLink;
}
hsBool plArmatureMod::ConsumeJump()
{
if (!GetInputFlag(B_CONTROL_CONSUMABLE_JUMP))
return false;
SetInputFlag(B_CONTROL_CONSUMABLE_JUMP, false);
return true;
}
void plArmatureMod::ISetTransparentDrawOrder(bool val)
{
if (fOpaque != val)
return;
fOpaque = !val;
plDrawableSpans *spans = plDrawableSpans::ConvertNoRef(FindDrawable());
if (spans)
{
spans->SetNativeProperty(plDrawable::kPropPartialSort, true);
spans->SetNativeProperty(plDrawable::kPropSortAsOne, true);
if (val)
{
spans->SetNativeProperty(plDrawable::kPropSortSpans, true);
spans->SetRenderLevel(plRenderLevel(plRenderLevel::kBlendRendMajorLevel, plRenderLevel::kDefRendMinorLevel));
}
else
{
spans->SetNativeProperty(plDrawable::kPropSortSpans, false);
spans->SetRenderLevel(plRenderLevel(0, plRenderLevel::kAvatarRendMinorLevel));
}
}
}
bool plArmatureMod::IsKILowestLevel()
{
if ( GetKILevel() == pfKIMsg::kNanoKI )
return true;
else
return false;
}
int plArmatureMod::GetKILevel()
{
return VaultGetKILevel();
}
void plArmatureMod::SetLinkInAnim(const char *animName)
{
if (animName)
{
plAGAnim *anim = FindCustomAnim(animName);
fLinkInAnimKey = (anim ? anim->GetKey() : nil);
}
else
fLinkInAnimKey = nil;
}
plKey plArmatureMod::GetLinkInAnimKey() const
{
return fLinkInAnimKey;
}
//////////////////////
//
// PLARMATURELODMOD
//
//////////////////////
plArmatureLODMod::plArmatureLODMod()
{
}
// CTOR (physical, name)
plArmatureLODMod::plArmatureLODMod(const char* root_name)
: plArmatureMod()
{
fRootName = hsStrcpy(root_name);
}
plArmatureLODMod::~plArmatureLODMod()
{
}
void plArmatureLODMod::Read(hsStream *stream, hsResMgr *mgr)
{
plArmatureMod::Read(stream, mgr);
fMeshKeys.clear();
int meshKeyCount = stream->ReadSwap32();
for(int i = 0; i < meshKeyCount; i++)
{
plKey meshKey = mgr->ReadKey(stream);
fMeshKeys.push_back(meshKey);
plKeyVector *vec = TRACKED_NEW plKeyVector;
int boneCount = stream->ReadSwap32();
for(int j = 0; j < boneCount; j++)
vec->push_back(mgr->ReadKey(stream));
fUnusedBones.push_back(vec);
}
}
// WRITE
void plArmatureLODMod::Write(hsStream *stream, hsResMgr *mgr)
{
plArmatureMod::Write(stream, mgr);
int meshKeyCount = fMeshKeys.size();
stream->WriteSwap32(meshKeyCount);
for(int i = 0; i < meshKeyCount; i++)
{
plKey meshKey = fMeshKeys[i];
mgr->WriteKey(stream, meshKey);
// Should be a list per mesh key
stream->WriteSwap32(fUnusedBones[i]->size());
for(int j = 0; j < fUnusedBones[i]->size(); j++)
mgr->WriteKey(stream, (*fUnusedBones[i])[j]);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
// DEBUG SUPPORT
int plArmatureMod::RefreshDebugDisplay()
{
plDebugText &debugTxt = plDebugText::Instance();
char strBuf[ 2048 ];
int lineHeight = debugTxt.GetFontSize() + 4;
UInt32 scrnWidth, scrnHeight;
debugTxt.GetScreenSize( &scrnWidth, &scrnHeight );
int y = 10;
int x = 10;
DumpToDebugDisplay(x, y, lineHeight, strBuf, debugTxt);
return y;
}
void plArmatureMod::DumpToDebugDisplay(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt)
{
sprintf(strBuf, "Armature <%s>:", fRootName);
debugTxt.DrawString(x, y, strBuf, 255, 128, 128);
y += lineHeight;
plSceneObject * SO = GetTarget(0);
if(SO)
{
// global location
hsMatrix44 l2w = SO->GetLocalToWorld();
hsPoint3 worldPos = l2w.GetTranslate();
char *opaque = IsOpaque() ? "yes" : "no";
sprintf(strBuf, "position(world): %.2f, %.2f, %.2f Opaque: %3s",
worldPos.fX, worldPos.fY, worldPos.fZ, opaque);
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
hsPoint3 kPos;
char *kinematic = "n.a.";
const char* frozen = "n.a.";
if (fController)
{
fController->GetKinematicPosition(kPos);
kinematic = fController->IsKinematic() ? "on" : "off";
}
sprintf(strBuf, "kinematc(world): %.2f, %.2f, %.2f Kinematic: %3s",
kPos.fX, kPos.fY, kPos.fZ,kinematic);
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
if (fController)
frozen = fController->IsEnabled() ? "no" : "yes";
// are we in a subworld?
plKey world = nil;
if (fController)
world = fController->GetSubworld();
sprintf(strBuf, "In world: %s Frozen: %s", world ? world->GetName() : "nil", frozen);
debugTxt.DrawString(x,y, strBuf);
y+= lineHeight;
if (fController)
{
hsPoint3 physPos;
GetPositionAndRotationSim(&physPos, nil);
const hsVector3& vel = fController->GetLinearVelocity();
sprintf(strBuf, "position(physical): <%.2f, %.2f, %.2f> velocity: <%5.2f, %5.2f, %5.2f>", physPos.fX, physPos.fY, physPos.fZ, vel.fX, vel.fY, vel.fZ);
}
else
{
sprintf(strBuf, "position(physical): no controller");
}
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
}
DebugDumpMoveKeys(x, y, lineHeight, strBuf, debugTxt);
int i;
for(i = 0; i < fBrains.size(); i++)
{
plArmatureBrain *brain = fBrains[i];
brain->DumpToDebugDisplay(x, y, lineHeight, strBuf, debugTxt);
}
if (fClothingOutfit)
{
y += lineHeight;
debugTxt.DrawString(x, y, "ItemsWorn:");
y += lineHeight;
strBuf[0] = '\0';
int itemCount = 0;
for (i = 0; i < fClothingOutfit->fItems.GetCount(); i++)
{
if (itemCount == 0)
strcat(strBuf, " ");
strcat(strBuf, fClothingOutfit->fItems[i]->fName);
itemCount++;
if (itemCount == 4)
{
debugTxt.DrawString(x, y, strBuf);
itemCount = 0;
strBuf[0] = '\0';
y += lineHeight;
}
if (itemCount > 0)
strcat(strBuf, ", ");
}
if (itemCount > 0)
{
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
}
}
if (plRelevanceMgr::Instance()->GetEnabled())
{
y += lineHeight;
debugTxt.DrawString(x, y, "Relevance Regions:");
y += lineHeight;
sprintf(strBuf, " In: %s", plRelevanceMgr::Instance()->GetRegionNames(fRegionsImIn).c_str());
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
sprintf(strBuf, " Care about: %s", plRelevanceMgr::Instance()->GetRegionNames(fRegionsICareAbout).c_str());
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
}
}
class plAvBoneMap::BoneMapImp
{
public:
typedef std::map<UInt32, const plSceneObject *> id2SceneObjectMap;
id2SceneObjectMap fMap;
};
plAvBoneMap::plAvBoneMap()
{
fImp = TRACKED_NEW BoneMapImp;
}
plAvBoneMap::~plAvBoneMap()
{
delete fImp;
}
const plSceneObject * plAvBoneMap::FindBone(UInt32 boneID)
{
BoneMapImp::id2SceneObjectMap::iterator i = fImp->fMap.find(boneID);
const plSceneObject *result = nil;
if(i != fImp->fMap.end())
{
result = (*i).second;
}
return result;
}
void plAvBoneMap::AddBoneMapping(UInt32 boneID, const plSceneObject *SO)
{
(fImp->fMap)[boneID] = SO;
}
void plArmatureMod::DebugDumpMoveKeys(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt)
{
char buff[256];
sprintf(buff, "Mouse Input Map: %s", plAvatarInputInterface::GetInstance()->GetInputMapName());
debugTxt.DrawString(x, y, buff);
y += lineHeight;
sprintf(buff, "Turn strength: %.2f (key: %.2f, analog: %.2f)", GetTurnStrength(), GetKeyTurnStrength(), GetAnalogTurnStrength());
debugTxt.DrawString(x, y, buff);
y += lineHeight;
GetMoveKeyString(buff);
debugTxt.DrawString(x, y, buff);
y += lineHeight;
}
void plArmatureMod::GetMoveKeyString(char *buff)
{
sprintf(buff, "Move keys: ");
if(FastKeyDown())
strcat(buff, "FAST ");
if(StrafeKeyDown())
strcat(buff, "STRAFE ");
if(ForwardKeyDown())
strcat(buff, "FORWARD ");
if(BackwardKeyDown())
strcat(buff, "BACKWARD ");
if(TurnLeftKeyDown())
strcat(buff, "TURNLEFT ");
if(TurnRightKeyDown())
strcat(buff, "TURNRIGHT ");
if(StrafeLeftKeyDown())
strcat(buff, "STRAFELEFT ");
if(StrafeRightKeyDown())
strcat(buff, "STRAFERIGHT ");
if(JumpKeyDown())
strcat(buff, "JUMP ");
}