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.
2840 lines
74 KiB
2840 lines
74 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#include "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 "); |
|
}
|
|
|