void plInputInterfaceMgr::Init( void )
{
RegisterAs( kInputInterfaceMgr_KEY );
plgDispatch::Dispatch()->RegisterForType( plInputIfaceMgrMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForType( plInputEventMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForType( plEvalMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plPlayerPageMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plCmdIfaceModMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plClientMsg::Index(), GetKey() );
/// Hacks (?) for now
plAvatarInputInterface *avatar = new plAvatarInputInterface();
IAddInterface( avatar );
hsRefCnt_SafeUnRef( avatar );
plSceneInputInterface *scene = new plSceneInputInterface();
IAddInterface( scene );
hsRefCnt_SafeUnRef( scene );
plDebugInputInterface *camDrive = new plDebugInputInterface();
IAddInterface( camDrive );
hsRefCnt_SafeUnRef( camDrive );
}
plLogicModBase::~plLogicModBase()
{
int i;
for (i = 0; i < fCommandList.Count(); i++ )
{
hsRefCnt_SafeUnRef(fCommandList[i]);
}
hsRefCnt_SafeUnRef(fNotify);
}
plGBufferGroup::~plGBufferGroup()
{
CleanUp();
for (auto i : fVertexBufferRefs) {
hsRefCnt_SafeUnRef(i);
}
for (auto i : fIndexBufferRefs) {
hsRefCnt_SafeUnRef(i);
}
}
plGBufferGroup::~plGBufferGroup()
{
uint32_t i;
CleanUp();
for( i = 0; i < fVertexBufferRefs.GetCount(); i++ )
hsRefCnt_SafeUnRef( fVertexBufferRefs[ i ] );
for( i = 0; i < fIndexBufferRefs.GetCount(); i++ )
hsRefCnt_SafeUnRef( fIndexBufferRefs[ i ] );
fVertexBufferRefs.Reset();
fIndexBufferRefs.Reset();
}
void plDispatch::ITrashUndelivered()
{
while( fFutureMsgQueue )
{
plMsgWrap* nuke = fFutureMsgQueue;
fFutureMsgQueue = fFutureMsgQueue->fNext;
hsRefCnt_SafeUnRef(nuke->fMsg);
delete nuke;
}
// If we're the main dispatch, any unsent messages at this
// point are just trashed. Slave dispatches just go away and
// leave their messages to be delivered when the main dispatch
// gets around to it.
if( this == plgDispatch::Dispatch() )
{
while( fMsgHead )
{
plMsgWrap* nuke = fMsgHead;
fMsgHead = fMsgHead->fNext;
// hsRefCnt_SafeUnRef(nuke->fMsg); // MOOSE - done in plMsgWrap dtor
delete nuke;
}
// reset static members which we just deleted - MOOSE
fMsgCurrent=fMsgHead=fMsgTail=nil;
fMsgActive = false;
}
}
void plObjectInVolumeDetector::ITrigger(plKey hitter, bool entering, bool immediate)
{
hsRefCnt_SafeUnRef(fSavedActivatorMsg);
fSavedActivatorMsg = 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().c_str(), fNumEvals);
fSavedActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeEnter);
fLastEnterEval = fNumEvals;
}
else
{
DetectorLog("%s: Saving Exiting volume - Evals=%d", GetKeyName().c_str(), fNumEvals);
fSavedActivatorMsg->SetTriggerType(plActivatorMsg::kVolumeExit);
fLastExitEval = fNumEvals;
}
if (immediate)
ISendSavedTriggerMsgs();
}
void plInputInterfaceMgr::Shutdown( void )
{
int i;
// WriteKeyMap();
for( i = 0; i < fInterfaces.GetCount(); i++ )
{
fInterfaces[ i ]->Shutdown();
hsRefCnt_SafeUnRef( fInterfaces[ i ] );
}
fInterfaces.Reset();
for( i = 0; i < fMessageQueue.GetCount(); i++ )
delete fMessageQueue[ i ];
fMessageQueue.Reset();
plgDispatch::Dispatch()->UnRegisterForType( plInputIfaceMgrMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForType( plInputEventMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForType( plEvalMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForExactType( plPlayerPageMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForExactType( plCmdIfaceModMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForExactType( plClientMsg::Index(), GetKey() );
UnRegisterAs( kInputInterfaceMgr_KEY );
}
plCameraModifier1::~plCameraModifier1()
{
int i;
for (i = 0; i < GetNumTrans(); i++)
delete(GetTrans(i));
fTrans.SetCountAndZero(0);
for (i = 0; i < fMessageQueue.Count(); i++)
hsRefCnt_SafeUnRef(fMessageQueue[i]);
fMessageQueue.SetCountAndZero(0);
for (i = 0; i < fFOVInstructions.Count(); i++)
hsRefCnt_SafeUnRef(fFOVInstructions[i]);
fFOVInstructions.SetCountAndZero(0);
}
void plResponderCmdAnim::CreateWait(plMaxNode* node, plErrorMsg* pErrMsg, IParamBlock2 *pb, ResponderWaitInfo& waitInfo)
{
plAnimCmdMsg *animMsg = plAnimCmdMsg::ConvertNoRef(waitInfo.msg);
if (animMsg)
animMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
plSoundMsg *soundMsg = plSoundMsg::ConvertNoRef(waitInfo.msg);
if (soundMsg)
soundMsg->SetCmd(plSoundMsg::kAddCallbacks);
plEventCallbackMsg *eventMsg = new plEventCallbackMsg;
eventMsg->AddReceiver(waitInfo.receiver);
eventMsg->fRepeats = 0;
eventMsg->fUser = waitInfo.callbackUser;
if (!waitInfo.point.IsNull())
{
// FIXME COLIN - Error checking here?
plAnimComponent *animComp = (plAnimComponent*)GetComponent(pb);
plString animName = animComp->GetAnimName();
plNotetrackAnim notetrackAnim(animComp, nil);
plAnimInfo info = notetrackAnim.GetAnimInfo(animName);
eventMsg->fEvent = kTime;
eventMsg->fEventTime = info.GetMarkerTime(waitInfo.point);
}
else
eventMsg->fEvent = kStop;
plMessageWithCallbacks *callbackMsg = plMessageWithCallbacks::ConvertNoRef(waitInfo.msg);
callbackMsg->AddCallback(eventMsg);
// AddCallback adds it's own ref, so remove ours (the default of 1)
hsRefCnt_SafeUnRef(eventMsg);
}
void plNetClientMgr::IDisableNet () {
ASSERT(fDisableMsg);
if (!GetFlagsBit(kDisabled)) {
SetFlagsBit(kDisabled);
// cause subsequent net operations to fail immediately, but don't block
// waiting for net subsystem to shutdown (we'll do that later)
NetCommEnableNet(false, false);
// display a msg to the player
if ( fDisableMsg->yes )
{
if (!GetFlagsBit(plNetClientApp::kPlayingGame))
{
// KI may not be loaded
plString title = plFormat("{} Error", plProduct::CoreName());
hsMessageBox(fDisableMsg->str, title.c_str(), hsMessageBoxNormal, hsMessageBoxIconError );
plClientMsg *quitMsg = new plClientMsg(plClientMsg::kQuit);
quitMsg->Send(hsgResMgr::ResMgr()->FindKey(kClient_KEY));
}
else
{
pfKIMsg *msg = new pfKIMsg(pfKIMsg::kKIOKDialog);
msg->SetString(fDisableMsg->str);
msg->Send();
}
}
}
hsRefCnt_SafeUnRef(fDisableMsg);
fDisableMsg = nil;
}
plRenderTarget* pl3DPipeline::PopRenderTarget()
{
plRenderTarget* old = fRenderTargets.Pop();
plRenderTarget* temp;
size_t i = fRenderTargets.GetCount();
if (i == 0)
{
fCurrRenderTarget = nullptr;
fCurrBaseRenderTarget = nullptr;
hsRefCnt_SafeUnRef(fCurrRenderTargetRef);
fCurrRenderTargetRef = nullptr;
}
else
{
fCurrRenderTarget = fRenderTargets[i - 1];
temp = fCurrRenderTarget;
while (temp != nullptr)
{
fCurrBaseRenderTarget = temp;
temp = temp->GetParent();
}
hsRefCnt_SafeAssign(fCurrRenderTargetRef, (fCurrRenderTarget != nullptr) ? fCurrRenderTarget->GetDeviceRef() : nullptr);
}
fDevice.SetRenderTarget(fCurrRenderTarget);
return old;
}
pfConsole::~pfConsole()
{
if( fInputInterface != nil )
{
plInputIfaceMgrMsg *msg = new plInputIfaceMgrMsg( plInputIfaceMgrMsg::kRemoveInterface );
msg->SetIFace( fInputInterface );
plgDispatch::MsgSend( msg );
hsRefCnt_SafeUnRef( fInputInterface );
fInputInterface = nil;
}
if( fDisplayBuffer != nil )
{
delete [] fDisplayBuffer;
fDisplayBuffer = nil;
}
fTheConsole = nil;
plgDispatch::Dispatch()->UnRegisterForExactType( plConsoleMsg::Index(), GetKey() );
plgDispatch::Dispatch()->UnRegisterForExactType( plControlEventMsg::Index(), GetKey() );
#ifndef PLASMA_EXTERNAL_RELEASE
pfGameMgr::GetInstance()->RemoveReceiver(GetKey());
#endif // PLASMA_EXTERNAL_RELEASE
}
void plNetMsgGameMessage::ReadVersion(hsStream* s, hsResMgr* mgr)
{
plNetMessage::ReadVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.Read(s);
if (contentFlags.IsBitSet(kNetGameMsgDeliveryTime))
{
if (s->ReadByte())
fDeliveryTime.Read(s);
}
if (contentFlags.IsBitSet(kNetGameMsgGameMsg))
{
plMessage* gameMsg = plMessage::ConvertNoRef(mgr->ReadCreatableVersion(s));
// write message (and label) to ram stream
hsRAMStream ramStream;
mgr->WriteCreatable(&ramStream, gameMsg);
// put stream in net msg wrapper
StreamInfo()->CopyStream(&ramStream);
hsRefCnt_SafeUnRef(gameMsg);
}
}
void plNetMsgGameMessage::WriteVersion(hsStream* s, hsResMgr* mgr)
{
plNetMessage::WriteVersion(s, mgr);
hsBitVector contentFlags;
contentFlags.SetBit(kNetGameMsgDeliveryTime);
contentFlags.SetBit(kNetGameMsgGameMsg);
contentFlags.Write(s);
// kNetGameMsgDeliveryTime
if (fDeliveryTime.AtEpoch())
{
s->WriteByte(0); // not sending
}
else
{
s->WriteByte(1); // sending
fDeliveryTime.Write(s);
}
// kNetGameMsgGameMsg
plMessage* gameMsg = GetContainedMsg();
mgr->WriteCreatableVersion(s, gameMsg);
hsRefCnt_SafeUnRef(gameMsg);
}
void plGBufferGroup::DeleteIndicesFromStorage( uint32_t which, uint32_t start, uint32_t length )
{
uint16_t *dstPtr, *srcPtr;
uint32_t amount;
hsAssert( start + length <= fIdxBuffCounts[ which ], "Illegal range to DeleteIndicesFromStorage()" );
if( start + length < fIdxBuffCounts[ which ] )
{
dstPtr = &( fIdxBuffStorage[ which ][ start ] );
srcPtr = &( fIdxBuffStorage[ which ][ start + length ] );
amount = fIdxBuffCounts[ which ] - ( start + length );
memmove( dstPtr, srcPtr, amount * sizeof( uint16_t ) );
}
fIdxBuffCounts[ which ] -= length;
plProfile_DelMem(MemBufGrpIndex, length * sizeof(uint16_t));
if( fIndexBufferRefs.GetCount() > which && fIndexBufferRefs[ which ] != nil )
{
hsRefCnt_SafeUnRef(fIndexBufferRefs[which]);
fIndexBufferRefs[which] = nil;
}
}
void plGBufferGroup::DeleteVertsFromStorage( uint32_t which, uint32_t start, uint32_t length )
{
uint8_t *dstPtr, *srcPtr;
uint32_t amount;
hsAssert( fCells[ which ]->GetCount() == 1, "Cannot delete verts on a mixed buffer group" );
// Adjust cell 0
(*fCells[ which ])[ 0 ].fLength -= length;
start *= fStride;
length *= fStride;
if( start + length < fVertBuffSizes[ which ] )
{
dstPtr = &( fVertBuffStorage[ which ][ start ] );
srcPtr = &( fVertBuffStorage[ which ][ start + length ] );
amount = ( fVertBuffSizes[ which ] ) - ( start + length );
memmove( dstPtr, srcPtr, amount );
}
fVertBuffSizes[ which ] -= length;
plProfile_DelMem(MemBufGrpVertex, length);
if( fVertexBufferRefs.GetCount() > which && fVertexBufferRefs[ which ] != nil )
{
hsRefCnt_SafeUnRef(fVertexBufferRefs[which]);
fVertexBufferRefs[which] = nil;
}
}
plLinkEffectsMgr::~plLinkEffectsMgr()
{
int i;
for( i = 0; i < fLinks.GetCount(); i++ )
{
hsRefCnt_SafeUnRef(fLinks[i]);
}
for( i = 0; i < fWaitlist.GetCount(); i++ )
{
hsRefCnt_SafeUnRef(fWaitlist[i]);
}
for( i = 0; i < fDeadlist.GetCount(); i++ )
{
hsRefCnt_SafeUnRef(fDeadlist[i]);
}
}
void plLinkEffectsTriggerPrepMsg::SetTrigger(plLinkEffectsTriggerMsg *msg)
{
if (fTrigger)
hsRefCnt_SafeUnRef(fTrigger);
hsRefCnt_SafeRef(msg);
fTrigger = msg;
}
bool plNetClientStreamRecorder::IIsValidMsg(plNetMessage* msg)
{
if (plNetMsgGameMessage* gameMsg = plNetMsgGameMessage::ConvertNoRef(msg))
{
int16_t type = gameMsg->StreamInfo()->GetStreamType();
//
// These messages will be regenerated if they are for the local avatar,
// so don't dispatch them in that case.
//
if (type == CLASS_INDEX_SCOPED(plLinkEffectsTriggerMsg))
{
plLinkEffectsTriggerMsg* linkMsg = plLinkEffectsTriggerMsg::ConvertNoRef(gameMsg->GetContainedMsg(GetResMgr()));
if (plNetClientApp::GetInstance())
{
bool isLocal = (linkMsg->GetLinkKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey());
hsRefCnt_SafeUnRef(linkMsg);
if (isLocal)
{
ILogMsg(msg, "IGNORING ");
return false;
}
}
}
else if (type == CLASS_INDEX_SCOPED(plLoadAvatarMsg))
{
plLoadAvatarMsg* loadAvMsg = plLoadAvatarMsg::ConvertNoRef(gameMsg->GetContainedMsg(GetResMgr()));
if (plNetClientApp::GetInstance())
{
bool isLocal = (loadAvMsg->GetCloneKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey());
hsRefCnt_SafeUnRef(loadAvMsg);
if (isLocal)
{
ILogMsg(msg, "IGNORING ");
return false;
}
}
}
}
ILogMsg(msg);
return true;
}
bool plGBufferGroup::ReserveIndexStorage( uint32_t numIndices, uint32_t *ibIndex, uint32_t *ibStart, uint16_t **dataPtr )
{
uint16_t *storagePtr;
int i;
if( numIndices >= kMaxNumIndicesPerBuffer )
{
hsAssert( false, "Egad, why on earth are you adding that many indices???" );
return false;
}
/// Find a spot
for( i = 0; i < fIdxBuffStorage.GetCount(); i++ )
{
if( fIdxBuffCounts[ i ] + numIndices < kMaxNumIndicesPerBuffer )
break;
}
if( i == fIdxBuffStorage.GetCount() )
{
fIdxBuffStorage.Append( nil );
fIdxBuffCounts.Append( 0 );
fIdxBuffStarts.Append(0);
fIdxBuffEnds.Append(-1);
}
*ibIndex = i;
*ibStart = fIdxBuffCounts[ i ];
/// Increase the storage size
storagePtr = new uint16_t[ fIdxBuffCounts[ i ] + numIndices ];
if( fIdxBuffCounts[ i ] > 0 )
memcpy( storagePtr, fIdxBuffStorage[ i ], fIdxBuffCounts[ i ] * sizeof( uint16_t ) );
if( dataPtr != nil )
*dataPtr = storagePtr + fIdxBuffCounts[ i ];
/// Switch over
i = *ibIndex;
if( fIdxBuffStorage[ i ] != nil )
delete [] fIdxBuffStorage[ i ];
fIdxBuffStorage[ i ] = storagePtr;
fIdxBuffCounts[ i ] += numIndices;
plProfile_NewMem(MemBufGrpIndex, numIndices * sizeof(uint16_t));
/// All done!
if( fIndexBufferRefs.GetCount() > i && fIndexBufferRefs[ i ] != nil )
{
hsRefCnt_SafeUnRef(fIndexBufferRefs[i]);
fIndexBufferRefs[i] = nil;
}
return true;
}
void plInputInterfaceMgr::IRemoveInterface( plInputInterface *iface )
{
int idx = fInterfaces.Find( iface );
if( idx != fInterfaces.kMissingIndex )
{
fInterfaces[ idx ]->Shutdown();
hsRefCnt_SafeUnRef( fInterfaces[ idx ] );
fInterfaces.Remove( idx );
}
}
void pl3DPipeline::PopOverrideMaterial(hsGMaterial* restore)
{
hsGMaterial *pop = fOverrideMat.Pop();
hsRefCnt_SafeUnRef(pop);
if (fCurrMaterial == pop)
{
fForceMatHandle = true;
}
}
plEventCallbackMsg* CreateCallbackMsg(plAnimCmdMsg* animMsg, plKey modKey)
{
plEventCallbackMsg *eventMsg = new plEventCallbackMsg;
eventMsg->AddReceiver(modKey);
eventMsg->fRepeats = -1;
animMsg->AddCallback(eventMsg);
hsRefCnt_SafeUnRef(eventMsg); // AddCallback adds it's own ref, so remove ours (the default of 1)
return eventMsg;
}
plResponderModifier::~plResponderModifier()
{
delete fResponderSDLMod;
fResponderSDLMod=nil;
for (int i = 0; i < fStates.Count(); i++)
{
for (int j = 0; j < fStates[i].fCmds.Count(); j++ )
hsRefCnt_SafeUnRef(fStates[i].fCmds[j].fMsg);
}
}
plPlate::~plPlate()
{
if( fFlags & kFlagLocalMaterial )
fMaterial->GetKey()->UnRefObject();
else
{
hsRefCnt_SafeUnRef( fMaterial );
}
fMaterial = nil;
*fOwningHandle = nil;
}
hsBool hsKeyedObject::MsgReceive(plMessage* msg)
{
plSelfDestructMsg* nuke = plSelfDestructMsg::ConvertNoRef(msg);
if (nuke)
{
hsAssert(RefCnt() == 1, "Trying to selfdestruct with bogus refcnt");
hsRefCnt_SafeUnRef(this);
return true;
}
return plReceiver::MsgReceive(msg);
}
void pfGUIControlMod::SetColorScheme( pfGUIColorScheme *newScheme )
{
if( fColorScheme != nil )
{
hsRefCnt_SafeUnRef( fColorScheme );
fColorScheme = nil;
}
fColorScheme = newScheme;
if( fColorScheme != nil )
hsRefCnt_SafeRef( fColorScheme );
}
plNetMessage* plNetClientStreamRecorder::GetNextMessage()
{
plNetMessage* msg = nil;
while (!fBetweenAges && (msg = IGetNextMessage()))
{
if (IIsValidMsg(msg))
return msg;
else
hsRefCnt_SafeUnRef(msg);
}
return nil;
}
void plResponderModifier::IDebugPlayMsg(plAnimCmdMsg* msg)
{
// Create a stop callback so we can do a cue for that too
plEventCallbackMsg *eventMsg = new plEventCallbackMsg;
eventMsg->AddReceiver(GetKey());
eventMsg->fRepeats = 0;
eventMsg->fUser = -1;
eventMsg->fEvent = kStop;
msg->SetCmd(plAnimCmdMsg::kAddCallbacks);
msg->AddCallback(eventMsg);
hsRefCnt_SafeUnRef(eventMsg);
IDebugAnimBox(true);
}
bool plLinkEffectsMgr::IHuntDeadlist(plLinkEffectsTriggerMsg *msg)
{
int i;
bool found = false;
for (i = fDeadlist.GetCount() - 1; i >= 0; i--)
{
if (fDeadlist[i] == msg)
{
found = true;
hsRefCnt_SafeUnRef(fDeadlist[i]);
fDeadlist.Remove(i);
plNetApp::GetInstance()->DebugMsg("Received backup LinkEffectsTriggerMsg. Cleanly ignoring since we received remote trigger.\n");
}
}
return found;
}
