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.
1155 lines
36 KiB
1155 lines
36 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 "plAvatar/plAvCallbackAction.h" |
|
|
|
#include "hsTypes.h" |
|
#include "plCollisionDetector.h" |
|
#include "plMessage/plCollideMsg.h" |
|
#include "plgDispatch.h" |
|
#include "plMessage/plActivatorMsg.h" |
|
#include "pnMessage/plCameraMsg.h" |
|
#include "pnMessage/plTimeMsg.h" |
|
#include "plMessage/plInputIfaceMgrMsg.h" |
|
#include "pnInputCore/plControlEventCodes.h" |
|
#include "pnNetCommon/plNetApp.h" |
|
#include "pnSceneObject/plSceneObject.h" |
|
#include "pnNetCommon/plNetApp.h" |
|
#include "plNetClient/plNetLinkingMgr.h" |
|
|
|
#include "plPhysical.h" |
|
|
|
#include "pnMessage/plPlayerPageMsg.h" |
|
#include "plMessage/plSimStateMsg.h" |
|
|
|
#include "pnSceneObject/plCoordinateInterface.h" |
|
#include "plAvatar/plArmatureMod.h" |
|
#include "plAvatar/plAvatarMgr.h" |
|
#include "plAvatar/plAvBrainHuman.h" |
|
#include "plAvatar/plAvBrainDrive.h" |
|
|
|
#include "plModifier/plDetectorLog.h" |
|
|
|
#define USE_PHYSX_MULTIPLE_CAMREGION_ENTER 1 |
|
#define USE_PHYSX_COLLISION_FLUTTER_WORKAROUND 1 |
|
|
|
plArmatureMod* plCollisionDetector::IGetAvatarModifier(plKey key) |
|
{ |
|
plSceneObject* avObj = plSceneObject::ConvertNoRef(key->ObjectIsLoaded()); |
|
if (avObj) |
|
{ |
|
// search through its modifiers to see if one of them is an avatar modifier |
|
plArmatureMod* avMod = nil; |
|
for (int i = 0; i < avObj->GetNumModifiers(); i++) |
|
{ |
|
const plModifier* mod = avObj->GetModifier(i); |
|
// see if it is an avatar mod base class |
|
avMod = const_cast<plArmatureMod*>(plArmatureMod::ConvertNoRef(mod)); |
|
if (avMod) |
|
return avMod; |
|
} |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
bool plCollisionDetector::IIsDisabledAvatar(plKey key) |
|
{ |
|
plArmatureMod* avMod = IGetAvatarModifier(key); |
|
plArmatureBrain* avBrain = avMod ? avMod->GetCurrentBrain() : nil; |
|
return (plAvBrainDrive::ConvertNoRef(avBrain) != nil); |
|
} |
|
|
|
hsBool plCollisionDetector::MsgReceive(plMessage* msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
// If the avatar is disabled (flying around), don't trigger |
|
if (IIsDisabledAvatar(pCollMsg->fOtherKey)) |
|
return false; |
|
|
|
if (fType & kTypeBump) |
|
{ |
|
if (!fBumped && !fTriggered) |
|
{ |
|
for (int i = 0; i < fReceivers.Count(); i++) |
|
{ |
|
plActivatorMsg* pMsg = TRACKED_NEW plActivatorMsg; |
|
pMsg->AddReceiver( fReceivers[i] ); |
|
|
|
if (fProxyKey) |
|
pMsg->fHiteeObj = fProxyKey; |
|
else |
|
pMsg->fHiteeObj = GetTarget()->GetKey(); |
|
pMsg->fHitterObj = pCollMsg->fOtherKey; |
|
pMsg->SetSender(GetKey()); |
|
pMsg->SetTriggerType( plActivatorMsg::kCollideContact ); |
|
plgDispatch::MsgSend( pMsg ); |
|
} |
|
fBumped = true; |
|
fTriggered = true; |
|
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
return true; |
|
} |
|
if (fTriggered) |
|
{ |
|
fBumped = true; |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
for (int i = 0; i < fReceivers.Count(); i++) |
|
{ |
|
plActivatorMsg* pMsg = TRACKED_NEW plActivatorMsg; |
|
pMsg->AddReceiver( fReceivers[i] ); |
|
if (fProxyKey) |
|
pMsg->fHiteeObj = fProxyKey; |
|
else |
|
pMsg->fHiteeObj = GetTarget()->GetKey(); |
|
pMsg->fHitterObj = pCollMsg->fOtherKey; |
|
pMsg->SetSender(GetKey()); |
|
|
|
if (fType & kTypeEnter && pCollMsg->fEntering) |
|
{ |
|
pMsg->SetTriggerType( plActivatorMsg::kCollideEnter ); |
|
plgDispatch::MsgSend( pMsg ); |
|
continue; |
|
} |
|
if (fType & kTypeUnEnter && pCollMsg->fEntering) |
|
{ |
|
pMsg->SetTriggerType( plActivatorMsg::kEnterUnTrigger ); |
|
plgDispatch::MsgSend( pMsg ); |
|
continue; |
|
} |
|
if(fType & kTypeExit && !pCollMsg->fEntering) |
|
{ |
|
pMsg->SetTriggerType( plActivatorMsg::kCollideExit ); |
|
plgDispatch::MsgSend( pMsg ); |
|
continue; |
|
} |
|
if(fType & kTypeUnExit && !pCollMsg->fEntering) |
|
{ |
|
pMsg->SetTriggerType( plActivatorMsg::kExitUnTrigger ); |
|
plgDispatch::MsgSend( pMsg ); |
|
continue; |
|
} |
|
if (fType & kTypeAny) |
|
{ |
|
pMsg->SetTriggerType( plActivatorMsg::kCollideContact ); |
|
plgDispatch::MsgSend( pMsg ); |
|
continue; |
|
} |
|
|
|
delete (pMsg); |
|
} |
|
return true; |
|
} |
|
|
|
plEvalMsg* pEval = plEvalMsg::ConvertNoRef(msg); |
|
if (pEval) |
|
{ |
|
if (!fBumped && fTriggered) |
|
{ |
|
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
for (int i = 0; i < fReceivers.Count(); i++) |
|
{ |
|
plActivatorMsg* pMsg = TRACKED_NEW plActivatorMsg; |
|
pMsg->AddReceiver( fReceivers[i] ); |
|
if (fProxyKey) |
|
pMsg->fHiteeObj = fProxyKey; |
|
else |
|
pMsg->fHiteeObj = GetTarget()->GetKey(); |
|
pMsg->SetSender(GetKey()); |
|
pMsg->SetTriggerType( plActivatorMsg::kCollideUnTrigger ); |
|
plgDispatch::MsgSend( pMsg ); |
|
fTriggered = false; |
|
} |
|
} |
|
else |
|
if (fTriggered && fBumped) |
|
{ |
|
fBumped = false; |
|
} |
|
return true; |
|
} |
|
|
|
return plDetectorModifier::MsgReceive(msg); |
|
} |
|
|
|
void plCollisionDetector::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Read(stream, mgr); |
|
stream->ReadSwap(&fType); |
|
} |
|
void plCollisionDetector::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Write(stream, mgr); |
|
stream->WriteSwap(fType); |
|
} |
|
|
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
// camera region detector |
|
|
|
plCameraRegionDetector::~plCameraRegionDetector() |
|
{ |
|
for(int i = 0; i < fMessages.Count(); i++) |
|
{ |
|
plMessage* pMsg = fMessages[i]; |
|
fMessages.Remove(i); |
|
delete(pMsg); |
|
} |
|
fMessages.SetCountAndZero(0); |
|
} |
|
|
|
void plCameraRegionDetector::ITrigger(plKey hitter, bool entering, bool immediate) |
|
{ |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
if (entering && fNumEvals - fLastExitEval <= 1 && fSavingSendMsg) |
|
{ |
|
DetectorLog("%s: Skipping Camera Entering volume", GetKeyName()); |
|
fLastEnterEval = fNumEvals; |
|
if (fSavingSendMsg) |
|
{ |
|
DetectorLog("%s: Dumping saved Camera Exiting volume", GetKeyName()); |
|
} |
|
fSavingSendMsg = false; |
|
return; |
|
} |
|
if (!entering && fNumEvals - fLastEnterEval <= 1 && fSavingSendMsg) |
|
{ |
|
DetectorLog("%s: Skipping Exiting volume", GetKeyName()); |
|
fLastExitEval = fNumEvals; |
|
if (fSavingSendMsg) |
|
{ |
|
DetectorLog("%s: Dumping saved Camera Entering volume", GetKeyName()); |
|
} |
|
fSavingSendMsg = false; |
|
return; |
|
} |
|
|
|
// get rid of any saved messages... this should happen though |
|
if (fSavingSendMsg) |
|
{ |
|
DetectorLog("%s: Killing saved camera message... shouldn't happen", GetKeyName()); |
|
} |
|
// end PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
fSavingSendMsg = true; |
|
fSavedMsgEnterFlag = entering; |
|
if (entering) |
|
{ |
|
//DetectorLog("%s: Saving camera Entering volume - Evals=%d", GetKeyName(),fNumEvals); |
|
fLastEnterEval = fNumEvals; |
|
} |
|
else |
|
{ |
|
//DetectorLog("%s: Saving camera Exiting volume - Evals=%d", GetKeyName(),fNumEvals); |
|
fLastExitEval = fNumEvals; |
|
} |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
// we're saving the message to be dispatched later... |
|
if (immediate) |
|
{ |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
ISendSavedTriggerMsgs(); |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
} |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
|
|
} |
|
|
|
void plCameraRegionDetector::ISendSavedTriggerMsgs() |
|
{ |
|
if (fSavingSendMsg) |
|
{ |
|
for (int i = 0; i < fMessages.Count(); i++) |
|
{ |
|
char str[256]; |
|
|
|
hsRefCnt_SafeRef(fMessages[i]); |
|
if (fSavedMsgEnterFlag) |
|
{ |
|
fMessages[i]->SetCmd(plCameraMsg::kEntering); |
|
sprintf(str, "Entering cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName(),fNumEvals,i+1,fMessages.Count()); |
|
fIsInside = true; |
|
} |
|
else |
|
{ |
|
fMessages[i]->ClearCmd(plCameraMsg::kEntering); |
|
sprintf(str, "Exiting cameraRegion: %s - Evals=%d -msg %d of %d\n", GetKeyName(),fNumEvals,i+1,fMessages.Count()); |
|
fIsInside = false; |
|
} |
|
plgDispatch::MsgSend(fMessages[i]); |
|
DetectorLog("%s", str); |
|
} |
|
} |
|
fSavingSendMsg = false; |
|
} |
|
|
|
|
|
hsBool plCameraRegionDetector::MsgReceive(plMessage* msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
// camera collisions are only for the local player |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != pCollMsg->fOtherKey) |
|
return true; |
|
|
|
|
|
#ifdef USE_PHYSX_MULTIPLE_CAMREGION_ENTER |
|
// first determine if this is a multiple camera region enter (PHYSX BUG WORKAROUND) |
|
if (!fWaitingForEval) |
|
{//plObjectInVolumeCollisionDetector::MsgReceive() will flip fWaitingForEval |
|
// and registers for the Eval, child objects of plObjectInVolumeCollisionDetector |
|
//must decide when they are no longer interested in Evals. I suggest using IHandleEvals() |
|
|
|
fNumEvals = 0; |
|
fLastEnterEval=-999; |
|
fLastExitEval=-999; |
|
} |
|
|
|
// end of (PHYSX BUG WORKAROUND) |
|
#endif // USE_PHYSX_MULTIPLE_CAMREG_ENTER |
|
|
|
} |
|
return plObjectInVolumeDetector::MsgReceive(msg); |
|
} |
|
void plCameraRegionDetector::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Read(stream, mgr); |
|
int n = stream->ReadSwap32(); |
|
fMessages.SetCountAndZero(n); |
|
for(int i = 0; i < n; i++ ) |
|
{ |
|
plCameraMsg* pMsg = plCameraMsg::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
fMessages[i] = pMsg; |
|
} |
|
|
|
} |
|
void plCameraRegionDetector::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Write(stream, mgr); |
|
stream->WriteSwap32(fMessages.GetCount()); |
|
for(int i = 0; i < fMessages.GetCount(); i++ ) |
|
mgr->WriteCreatable( stream, fMessages[i] ); |
|
|
|
} |
|
void plCameraRegionDetector::IHandleEval(plEvalMsg *pEval) |
|
{ |
|
fNumEvals++; |
|
if (fNumEvals - fLastEnterEval > 1 && fNumEvals-fLastExitEval>1) |
|
{ |
|
ISendSavedTriggerMsgs(); |
|
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
fWaitingForEval = false; |
|
} |
|
else |
|
{ |
|
if(fSavedActivatorMsg) |
|
DetectorLog("%s didn't send its message. fNumEvals=%d fLastEnterEval=%d, fLastExit=%d", |
|
GetKeyName(),fNumEvals, fLastEnterEval, fLastExitEval); |
|
|
|
} |
|
} |
|
|
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
// object-in-volume detector |
|
|
|
void plObjectInVolumeDetector::ITrigger(plKey hitter, bool entering, bool immediate) |
|
{ |
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
/* if (entering && fNumEvals - fLastExitEval <= 1 && fSavedActivatorMsg) |
|
{ |
|
//DetectorLog("%s: Skipping Entering volume", GetKeyName()); |
|
fLastEnterEval = fNumEvals; |
|
if (fSavedActivatorMsg) |
|
{ |
|
//DetectorLog("%s: Dumping saved Exiting volume", GetKeyName()); |
|
delete fSavedActivatorMsg; |
|
} |
|
fSavedActivatorMsg = nil; |
|
return; |
|
} |
|
if (!entering && fNumEvals - fLastEnterEval <= 1 && fSavedActivatorMsg) |
|
{ |
|
//DetectorLog("%s: Skipping Exiting volume", GetKeyName()); |
|
fLastExitEval = fNumEvals; |
|
if (fSavedActivatorMsg) |
|
{ |
|
//DetectorLog("%s: Dumping saved Entering volume", GetKeyName()); |
|
delete fSavedActivatorMsg; |
|
} |
|
fSavedActivatorMsg = nil; |
|
return; |
|
} |
|
|
|
// get rid of any saved messages... this should happen though |
|
if (fSavedActivatorMsg) |
|
{ |
|
delete fSavedActivatorMsg; |
|
DetectorLog("%s: Killing saved message... shouldn't happen", GetKeyName()); |
|
} |
|
// end PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
*/ |
|
if(!immediate) |
|
{ |
|
|
|
bookKeepingList::iterator curit=fCollisionList.begin(); |
|
while(curit!=fCollisionList.end()) |
|
{ |
|
if(hitter==(*curit)->hitter) |
|
{//hey the object is already in my list |
|
//try and figure out what my real state is |
|
if(entering) |
|
{ |
|
(*curit)->enters++; |
|
if(!(*curit)->fSubStepCurState) |
|
{//We weren't already in |
|
(*curit)->fSubStepCurState =true; |
|
} |
|
} |
|
else |
|
{ |
|
(*curit)->exits++; |
|
if((*curit)->fSubStepCurState) |
|
{//We were already in |
|
(*curit)->fSubStepCurState =false; |
|
} |
|
} |
|
//get out |
|
break; |
|
} |
|
curit++; |
|
} |
|
if(curit==fCollisionList.end()) |
|
{ |
|
//hitter was not in the list add him in |
|
//hitter was not in the current frame list |
|
//lets find out its state in the begining of the frame |
|
ResidentSet::iterator curres = fCurrentResidents.find(hitter); |
|
bool initialState; |
|
if(curres != fCurrentResidents.end()) |
|
initialState =true; |
|
else |
|
initialState =false; |
|
|
|
plCollisionBookKeepingInfo* BookKeeper=TRACKED_NEW plCollisionBookKeepingInfo(hitter); |
|
if(entering) |
|
{ |
|
BookKeeper->enters++; |
|
BookKeeper->fSubStepCurState =true; |
|
} |
|
else |
|
{ |
|
BookKeeper->exits++; |
|
BookKeeper->fSubStepCurState =false; |
|
} |
|
fCollisionList.push_front(BookKeeper); |
|
} |
|
|
|
|
|
} |
|
else |
|
{ |
|
plActivatorMsg* ActivatorMsg = TRACKED_NEW plActivatorMsg; |
|
ActivatorMsg->AddReceivers(fReceivers); |
|
if (fProxyKey) |
|
ActivatorMsg->fHiteeObj = fProxyKey; |
|
else |
|
ActivatorMsg->fHiteeObj = GetTarget()->GetKey(); |
|
|
|
ActivatorMsg->fHitterObj = hitter; |
|
ActivatorMsg->SetSender(GetKey()); |
|
if (entering) |
|
{ |
|
ActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeEnter); |
|
} |
|
else |
|
{ |
|
ActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeExit); |
|
} |
|
|
|
plgDispatch::MsgSend(ActivatorMsg); |
|
|
|
|
|
} |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
/* fSavedActivatorMsg = TRACKED_NEW plActivatorMsg; |
|
|
|
fSavedActivatorMsg->AddReceivers(fReceivers); |
|
|
|
if (fProxyKey) |
|
fSavedActivatorMsg->fHiteeObj = fProxyKey; |
|
else |
|
fSavedActivatorMsg->fHiteeObj = GetTarget()->GetKey(); |
|
|
|
fSavedActivatorMsg->fHitterObj = hitter; |
|
fSavedActivatorMsg->SetSender(GetKey()); |
|
|
|
if (entering) |
|
{ |
|
//DetectorLog("%s: Saving Entering volume - Evals=%d", GetKeyName(),fNumEvals); |
|
fSavedActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeEnter); |
|
fLastEnterEval = fNumEvals; |
|
} |
|
else |
|
{ |
|
//DetectorLog("%s: Saving Exiting volume - Evals=%d", GetKeyName(),fNumEvals); |
|
fSavedActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeExit); |
|
fLastExitEval = fNumEvals; |
|
} |
|
*/ |
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
// we're saving the message to be dispatched later... |
|
if (immediate) |
|
{ |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
|
|
// fSavedActivatorMsg = nil; |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
} |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
} |
|
/* |
|
void plObjectInVolumeDetector::ISendSavedTriggerMsgs() |
|
{ |
|
if (fSavedActivatorMsg) |
|
{ |
|
if (fSavedActivatorMsg->fTriggerType == plActivatorMsg::kVolumeEnter) |
|
DetectorLog("%s: Sending Entering volume - Evals=%d", GetKeyName(),fNumEvals); |
|
else |
|
DetectorLog("%s: Sending Exiting volume - Evals=%d", GetKeyName(),fNumEvals); |
|
|
|
// we're saving the message to be dispatched later... |
|
plgDispatch::MsgSend(fSavedActivatorMsg); |
|
} |
|
fSavedActivatorMsg = nil; |
|
} |
|
*/ |
|
hsBool plObjectInVolumeDetector::MsgReceive(plMessage* msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
if (pCollMsg) |
|
{ |
|
// If the avatar is disabled (flying around), don't trigger |
|
if (IIsDisabledAvatar(pCollMsg->fOtherKey)) |
|
return false; |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
if (!fWaitingForEval) |
|
{ |
|
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
fWaitingForEval = true; |
|
} |
|
// end PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
ITrigger(pCollMsg->fOtherKey, (pCollMsg->fEntering != 0)); |
|
|
|
return true; |
|
} |
|
|
|
#ifdef USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
// PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
plEvalMsg* pEval = plEvalMsg::ConvertNoRef(msg); |
|
if (pEval) |
|
{ |
|
|
|
//if (fSavedActivatorMsg) |
|
// DetectorLog("%s: InVolumeEval=%d with saved message", GetKeyName(), fNumEvals); |
|
//else |
|
// DetectorLog("%s: InVolumeEval=%d without saved message", GetKeyName(), fNumEvals); |
|
IHandleEval(pEval); |
|
|
|
} |
|
// end PHYSX_FIXME hack for PhysX turd that sends bunches of enter/exits over one frame |
|
#endif // USE_PHYSX_COLLISION_FLUTTER_WORKAROUND |
|
|
|
plPlayerPageMsg* pageMsg = plPlayerPageMsg::ConvertNoRef(msg); |
|
if (pageMsg && pageMsg->fUnload) |
|
{ |
|
ITrigger(pageMsg->fPlayer, false); |
|
} |
|
|
|
return plCollisionDetector::MsgReceive(msg); |
|
} |
|
|
|
void plObjectInVolumeDetector::IHandleEval(plEvalMsg* pEval) |
|
{ |
|
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
fWaitingForEval = false; |
|
for(bookKeepingList::reverse_iterator it= fCollisionList.rbegin();it!=fCollisionList.rend(); it++) |
|
{ |
|
bool alreadyInside; |
|
ResidentSet::iterator HitIt; |
|
HitIt = fCurrentResidents.find((*it)->hitter); |
|
if(HitIt != fCurrentResidents.end()) alreadyInside = true; |
|
else alreadyInside=false; |
|
plActivatorMsg* actout=TRACKED_NEW plActivatorMsg; |
|
actout->fHitterObj=((*it)->hitter); |
|
actout->SetSender(GetKey()); |
|
if (fProxyKey) |
|
actout->fHiteeObj = fProxyKey; |
|
else |
|
actout->fHiteeObj = GetTarget()->GetKey(); |
|
if((*it)->fSubStepCurState)//current substate says we are entered |
|
{//different enters and exits |
|
//figure out what to do |
|
if(!alreadyInside) |
|
{//we are actuall entering |
|
actout->SetTriggerType(plActivatorMsg::kVolumeEnter); |
|
fCurrentResidents.insert((*it)->hitter); |
|
actout->AddReceivers(fReceivers); |
|
actout->Send(); |
|
DetectorLog("%s sent an Enter ActivatorMsg. To: %s", GetKeyName(), GetTarget()->GetKeyName() ); |
|
} |
|
else |
|
{ |
|
DetectorLog("%s squelched an Enter ActivatorMsg.", GetKeyName()); |
|
delete actout; |
|
} |
|
} |
|
else |
|
{ |
|
//fSubStepCurState says we are outside |
|
if(alreadyInside) |
|
{//we are actuall exiting |
|
actout->SetTriggerType(plActivatorMsg::kVolumeExit); |
|
fCurrentResidents.erase((*it)->hitter); |
|
actout->AddReceivers(fReceivers); |
|
actout->Send(); |
|
DetectorLog("%s sent an Exit ActivatorMsg. To: %s", GetKeyName(), GetTarget()->GetKeyName()); |
|
} |
|
else |
|
{ |
|
DetectorLog("%s squelched an Exit ActivatorMsg.", GetKeyName()); |
|
delete actout; |
|
} |
|
} |
|
} |
|
DetectorLog("*********"); |
|
for(bookKeepingList::iterator it = fCollisionList.begin(); it != fCollisionList.end(); it ++) |
|
{ |
|
delete (*it); |
|
} |
|
DetectorLog("This is the regions inhabitants after the op"); |
|
for(ResidentSet::iterator it = fCurrentResidents.begin(); it!= fCurrentResidents.end(); it++) |
|
{ |
|
DetectorLog("%s", (*it)->GetName()); |
|
} |
|
DetectorLog("*********"); |
|
|
|
fCollisionList.clear(); |
|
|
|
} |
|
|
|
void plObjectInVolumeDetector::SetTarget(plSceneObject* so) |
|
{ |
|
plCollisionDetector::SetTarget(so); |
|
|
|
if (so) |
|
plgDispatch::Dispatch()->RegisterForExactType(plPlayerPageMsg::Index(), GetKey()); |
|
else |
|
plgDispatch::Dispatch()->UnRegisterForExactType(plPlayerPageMsg::Index(), GetKey()); |
|
} |
|
|
|
void plObjectInVolumeDetector::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plCollisionDetector::Read(stream, mgr); |
|
} |
|
|
|
void plObjectInVolumeDetector::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plCollisionDetector::Write(stream, mgr); |
|
} |
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
plObjectInVolumeAndFacingDetector::plObjectInVolumeAndFacingDetector() : |
|
fFacingTolerance(0), |
|
fNeedWalkingForward(false), |
|
fAvatarInVolume(false), |
|
fTriggered(false) |
|
{ |
|
} |
|
|
|
plObjectInVolumeAndFacingDetector::~plObjectInVolumeAndFacingDetector() |
|
{ |
|
} |
|
|
|
void plObjectInVolumeAndFacingDetector::SetFacingTolerance(int degrees) |
|
{ |
|
fFacingTolerance = hsCosine(hsScalarDegToRad(degrees)); |
|
} |
|
|
|
void plObjectInVolumeAndFacingDetector::ICheckForTrigger() |
|
{ |
|
plArmatureMod* armMod = plAvatarMgr::GetInstance()->GetLocalAvatar(); |
|
plSceneObject* avatar = armMod ? armMod->GetTarget(0) : nil; |
|
plSceneObject* target = GetTarget(); |
|
|
|
if (armMod && target) |
|
{ |
|
hsVector3 playerView = avatar->GetCoordinateInterface()->GetLocalToWorld().GetAxis(hsMatrix44::kView); |
|
hsVector3 objView = target->GetCoordinateInterface()->GetLocalToWorld().GetAxis(hsMatrix44::kView); |
|
|
|
playerView.Normalize(); |
|
objView.Normalize(); |
|
|
|
hsScalar dot = playerView * objView; |
|
// hsStatusMessageF("Dot: %f Tolerance: %f", dot, fFacingTolerance); |
|
bool facing = dot >= fFacingTolerance; |
|
|
|
bool movingForward = false; |
|
if (fNeedWalkingForward) |
|
{ |
|
// And are we walking towards it? |
|
plArmatureBrain* abrain = armMod->FindBrainByClass(plAvBrainHuman::Index()); //armMod->GetCurrentBrain(); |
|
plAvBrainHuman* brain = plAvBrainHuman::ConvertNoRef(abrain); |
|
if (brain && brain->IsMovingForward() && brain->fCallbackAction->IsOnGround()) |
|
movingForward = true; |
|
} |
|
else |
|
movingForward = true; |
|
|
|
if (facing && movingForward && !fTriggered) |
|
{ |
|
DetectorLog("%s: Trigger InVolume&Facing", GetKeyName()); |
|
fTriggered = true; |
|
ITrigger(avatar->GetKey(), true, true); |
|
} |
|
else if (!facing && fTriggered) |
|
{ |
|
DetectorLog("%s: Untrigger InVolume&Facing", GetKeyName()); |
|
fTriggered = false; |
|
ITrigger(avatar->GetKey(), false, true); |
|
} |
|
} |
|
} |
|
|
|
hsBool plObjectInVolumeAndFacingDetector::MsgReceive(plMessage* msg) |
|
{ |
|
// Avatar is entering or exiting our detector box |
|
plCollideMsg* collMsg = plCollideMsg::ConvertNoRef(msg); |
|
if (collMsg) |
|
{ |
|
// make sure this is the local player... the notify will be the thing that propagates over the network |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != collMsg->fOtherKey) |
|
return true; |
|
|
|
// If the avatar is disabled (flying around), don't trigger |
|
if (IIsDisabledAvatar(collMsg->fOtherKey)) |
|
return false; |
|
|
|
fAvatarInVolume = (collMsg->fEntering != 0); |
|
|
|
if (fAvatarInVolume) |
|
{ |
|
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
ICheckForTrigger(); |
|
} |
|
else |
|
{ |
|
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
|
|
// Avatar is leaving the volume, make sure to untrigger if we haven't already |
|
if (fTriggered) |
|
{ |
|
fTriggered = false; |
|
ITrigger(plNetClientApp::GetInstance()->GetLocalPlayerKey(), false, true); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// Avatar is inside our detector box, so every frame we check if we need to trigger |
|
plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg); |
|
if (evalMsg) |
|
{ |
|
ICheckForTrigger(); |
|
return true; |
|
} |
|
|
|
return plObjectInVolumeDetector::MsgReceive(msg); |
|
} |
|
|
|
void plObjectInVolumeAndFacingDetector::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plObjectInVolumeDetector::Read(stream, mgr); |
|
|
|
fFacingTolerance = stream->ReadSwapScalar(); |
|
fNeedWalkingForward = stream->Readbool(); |
|
} |
|
|
|
void plObjectInVolumeAndFacingDetector::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plObjectInVolumeDetector::Write(stream, mgr); |
|
|
|
stream->WriteSwapScalar(fFacingTolerance); |
|
stream->Writebool(fNeedWalkingForward); |
|
} |
|
|
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
///////////////////////////////// |
|
// subworld region detector |
|
|
|
plSubworldRegionDetector::~plSubworldRegionDetector() |
|
{ |
|
} |
|
|
|
|
|
hsBool plSubworldRegionDetector::MsgReceive(plMessage* msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != pCollMsg->fOtherKey) |
|
return true; |
|
|
|
plArmatureMod* avMod = IGetAvatarModifier(pCollMsg->fOtherKey); |
|
if (avMod) |
|
{ |
|
DetectorLog("%s subworld detector %s", pCollMsg->fEntering ? "Entering" : "Exiting", GetKeyName()); |
|
|
|
if ((pCollMsg->fEntering && !fOnExit) || |
|
(!pCollMsg->fEntering && fOnExit)) |
|
{ |
|
if (fSub) |
|
{ |
|
plSceneObject* SO = plSceneObject::ConvertNoRef(fSub->ObjectIsLoaded()); |
|
if (SO) |
|
{ |
|
DetectorLogSpecial("Switching to subworld %s", fSub->GetName()); |
|
|
|
plKey nilKey; |
|
plSubWorldMsg* msg = TRACKED_NEW plSubWorldMsg(GetKey(), avMod->GetKey(), fSub); |
|
msg->Send(); |
|
} |
|
} |
|
else |
|
{ |
|
DetectorLogSpecial("Switching to main subworld"); |
|
plSubWorldMsg* msg = TRACKED_NEW plSubWorldMsg(GetKey(), avMod->GetKey(), nil); |
|
msg->Send(); |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return plCollisionDetector::MsgReceive(msg); |
|
} |
|
|
|
void plSubworldRegionDetector::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Read(stream, mgr); |
|
fSub = mgr->ReadKey(stream); |
|
fOnExit = stream->ReadBool(); |
|
} |
|
void plSubworldRegionDetector::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plDetectorModifier::Write(stream, mgr); |
|
mgr->WriteKey(stream, fSub); |
|
stream->WriteBool(fOnExit); |
|
} |
|
|
|
/////////////////////////////////// |
|
/////////////////////////////////// |
|
/// plPanicLinkDetector |
|
/////////////////////////////////// |
|
hsBool plPanicLinkRegion::MsgReceive(plMessage* msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != pCollMsg->fOtherKey) |
|
return true; |
|
|
|
if (pCollMsg->fEntering) |
|
{ |
|
plArmatureMod* avMod = IGetAvatarModifier(pCollMsg->fOtherKey); |
|
if (avMod) |
|
{ |
|
hsPoint3 kinPos; |
|
if (avMod->GetController()) |
|
{ |
|
avMod->GetController()->GetKinematicPosition(kinPos); |
|
DetectorLogSpecial("Avatar is panic linking. KinPos at %f,%f,%f and is %s",kinPos.fX,kinPos.fY,kinPos.fZ,avMod->GetController()->IsEnabled() ? "enabled" : "disabled"); |
|
} |
|
avMod->PanicLink(fPlayLinkOutAnim); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return plCollisionDetector::MsgReceive(msg); |
|
} |
|
|
|
void plPanicLinkRegion::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plCollisionDetector::Read(stream, mgr); |
|
|
|
fPlayLinkOutAnim = stream->ReadBool(); |
|
} |
|
|
|
void plPanicLinkRegion::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plCollisionDetector::Write(stream, mgr); |
|
|
|
stream->WriteBool(fPlayLinkOutAnim); |
|
} |
|
|
|
///////////////////////////////////////////////////////////////// |
|
// |
|
// PLSIMPLEREGIONSENSOR |
|
// |
|
///////////////////////////////////////////////////////////////// |
|
|
|
// ctor default |
|
plSimpleRegionSensor::plSimpleRegionSensor() |
|
: fEnterMsg(nil), fExitMsg(nil) |
|
{ |
|
} |
|
|
|
// ctor canonical |
|
plSimpleRegionSensor::plSimpleRegionSensor(plMessage *enterMsg, plMessage *exitMsg) |
|
: fEnterMsg(enterMsg), fExitMsg(exitMsg) |
|
{ |
|
} |
|
|
|
// dtor |
|
plSimpleRegionSensor::~plSimpleRegionSensor() |
|
{ |
|
if(fEnterMsg) |
|
fEnterMsg->UnRef(); |
|
if(fExitMsg) |
|
fExitMsg->UnRef(); |
|
} |
|
|
|
// WRITE |
|
void plSimpleRegionSensor::Write(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSingleModifier::Write(stream, mgr); |
|
if(fEnterMsg) |
|
{ |
|
stream->Writebool(true); |
|
mgr->WriteCreatable(stream, fEnterMsg); |
|
} else { |
|
stream->Writebool(false); |
|
} |
|
if(fExitMsg) |
|
{ |
|
stream->Writebool(true); |
|
mgr->WriteCreatable(stream, fExitMsg); |
|
} else { |
|
stream->Writebool(false); |
|
} |
|
} |
|
|
|
// READ |
|
void plSimpleRegionSensor::Read(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSingleModifier::Read(stream, mgr); |
|
if(stream->Readbool()) |
|
{ |
|
fEnterMsg = plMessage::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
} else { |
|
fEnterMsg = nil; |
|
} |
|
|
|
if(stream->Readbool()) |
|
{ |
|
fExitMsg = plMessage::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
hsAssert(fExitMsg, "Corrupted plSimpleRegionSensor during read."); |
|
} else { |
|
fExitMsg = nil; |
|
} |
|
} |
|
|
|
// MSGRECEIVE |
|
hsBool plSimpleRegionSensor::MsgReceive(plMessage *msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
// make sure this is the local player... the notify will be the thing that propagates over the network |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != pCollMsg->fOtherKey) |
|
return true; |
|
|
|
plKey theThingWhatDoneHitUs = pCollMsg->fOtherKey; |
|
|
|
if(pCollMsg->fEntering) |
|
{ |
|
if(fEnterMsg) |
|
{ |
|
fEnterMsg->ClearReceivers(); |
|
fEnterMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fEnterMsg->Ref(); |
|
fEnterMsg->Send(); |
|
} |
|
} |
|
else { |
|
if(fExitMsg) |
|
{ |
|
fExitMsg->ClearReceivers(); |
|
fExitMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fExitMsg->Ref(); |
|
fExitMsg->Send(); |
|
} |
|
} |
|
return true; |
|
} |
|
return plSingleModifier::MsgReceive(msg); |
|
} |
|
|
|
// IEVAL |
|
hsBool plSimpleRegionSensor::IEval(double secs, hsScalar del, UInt32 dirty) |
|
{ |
|
return false; |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
// Nuke the Read/Write functions on the next file format change |
|
void plSwimDetector::Write(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSimpleRegionSensor::Write(stream, mgr); |
|
|
|
stream->WriteByte(0); |
|
stream->WriteSwapScalar(0); |
|
stream->WriteSwapScalar(0); |
|
} |
|
|
|
void plSwimDetector::Read(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSimpleRegionSensor::Read(stream, mgr); |
|
|
|
stream->ReadByte(); |
|
stream->ReadSwapScalar(); |
|
stream->ReadSwapScalar(); |
|
} |
|
hsBool plSwimDetector::MsgReceive(plMessage *msg) |
|
{ |
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
//removed local player check because this will apply the brain to the local |
|
//controller of the foreign avatar which we still want. |
|
//and if we prop swim state by notify messages we still have a chance of missing it from players |
|
//who were in the region before we linked in |
|
plKey theThingWhatDoneHitUs = pCollMsg->fOtherKey; |
|
if(pCollMsg->fEntering) |
|
{ |
|
if(fEnterMsg) |
|
{ |
|
fEnterMsg->ClearReceivers(); |
|
fEnterMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fEnterMsg->Ref(); |
|
fEnterMsg->Send(); |
|
} |
|
} |
|
else { |
|
if(fExitMsg) |
|
{ |
|
fExitMsg->ClearReceivers(); |
|
fExitMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fExitMsg->Ref(); |
|
fExitMsg->Send(); |
|
} |
|
} |
|
return true; |
|
} |
|
return plSimpleRegionSensor::MsgReceive(msg); |
|
} |
|
hsBool plRidingAnimatedPhysicalDetector::MsgReceive(plMessage *msg) |
|
{ |
|
|
|
plCollideMsg* pCollMsg = plCollideMsg::ConvertNoRef(msg); |
|
|
|
if (pCollMsg) |
|
{ |
|
//removed local player check because this will apply the brain to the local |
|
//controller of the foreign avatar which we still want. |
|
//and if we prop state by notify messages we still have a chance of missing it from players |
|
//who were in the region before we linked in |
|
plKey theThingWhatDoneHitUs = pCollMsg->fOtherKey; |
|
if(pCollMsg->fEntering) |
|
{ |
|
if(fEnterMsg) |
|
{ |
|
fEnterMsg->ClearReceivers(); |
|
fEnterMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fEnterMsg->Ref(); |
|
fEnterMsg->Send(); |
|
} |
|
} |
|
else { |
|
if(fExitMsg) |
|
{ |
|
fExitMsg->ClearReceivers(); |
|
fExitMsg->AddReceiver(theThingWhatDoneHitUs); |
|
fExitMsg->Ref(); |
|
fExitMsg->Send(); |
|
} |
|
} |
|
return true; |
|
} |
|
return plSimpleRegionSensor::MsgReceive(msg); |
|
}
|
|
|