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; }