OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
363 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 3ead2ccda5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3ead2ccda5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plArmatureMod.cpp

2856 lines
83 KiB
Raw Blame History

/*==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/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
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 ");
}