void CTyHMProxy::Ty_Serialize(CArchive &ar)
{
if (ar.IsStoring())
{
ar<<m_x0<<m_y0<<m_x1<<m_y1;
ar.Write((unsigned char *)m_hmname,sizeof(char)*33);
ar<<m_display;
ar.Write((unsigned char *)m_str1,sizeof(char)*33);
ar.Write((unsigned char *)m_str2,sizeof(char)*33);
ar<<m_color1<<m_color2<<m_bFlash<<m_FangXiang<<m_TextHeight<<m_TextWidth<<m_JqWidth;
ar.Write((unsigned char *)m_TextFont,sizeof(char)*16);
ar<<m_bTranslate1<<m_bTranslate2;
}
else
{
UnRegister();
ar>>m_x0>>m_y0>>m_x1>>m_y1;
ar.Read((unsigned char *)m_hmname,sizeof(char)*33);
ar>>m_display;
ar.Read((unsigned char *)m_str1,sizeof(char)*33);
ar.Read((unsigned char *)m_str2,sizeof(char)*33);
ar>>m_color1>>m_color2>>m_bFlash>>m_FangXiang>>m_TextHeight>>m_TextWidth>>m_JqWidth;
ar.Read((unsigned char *)m_TextFont,sizeof(char)*16);
ar>>m_bTranslate1>>m_bTranslate2;
Register();
}
}
void CParticleManager::Update( float deltaTime )
{
for (uint32_t i = 0; i < m_particle.size(); ++i)
{
CParticle* pParticle = m_particle[i];
if (pParticle != NULL)
{
if (pParticle->IsAlive())
{
pParticle->Update(deltaTime);
if (pParticle->GetType() == ePT_Visual)
{
Function<void(void)> func = Bind(*pParticle, &CParticle::PreRender);
CRenderManager::GetInstance()->SendQuadToCache(pParticle->GetPhysics()->GetWorldPos(),
pParticle->GetRadius(),
pParticle->GetRadius(),
pParticle->GetColor(),
&func);
}
}
else
{
UnRegister(pParticle);
}
}
}
}
long GoodsTimerHandler::Register( CPlayer *pPlayer, const CGUID &goodsID,
long lTrigerTime, long lInterval, void *arg )
{
if( IsUnique() )
{
UnRegister( pPlayer, goodsID );
}
GoodsTimerTableT::iterator it = m_GoodsTimers.find( TimerKeyHandle( TimerKey( lTrigerTime ) ) );
if( it == m_GoodsTimers.end() )
{
long lTimerID = GameManager::GetInstance()->Schedule( pPlayer, arg, lTrigerTime + timeGetTime(), lInterval );
GoodsListT *pGoodsList = new GoodsListT();
pGoodsList->push_back( goodsID );
m_GoodsTimers.insert( GoodsTimerTableT::value_type( TimerKeyHandle( TimerKey( lTrigerTime ), lTimerID ),
pGoodsList ) );
return lTimerID;
}
else
{
// add
GoodsListT *pGoodsList = it->second;
// be sure it's unique.
GoodsListT::const_iterator git = std::find( pGoodsList->begin(), pGoodsList->end(), goodsID );
if( git == pGoodsList->end() )
{
pGoodsList->push_back( goodsID );
}
}
return -1;
}
CTpnsMsgManager::~CTpnsMsgManager()
{
for(int i = 0; i < CMD_LIMIT; ++i)
{
UnRegister(i);
}
}
void CTyHMProxy::OnEditProperties(CElecMapView * pView)
{
CPropertySheet sheet( _T("对象..") );
CTyHMProxyProp dlg;
dlg.SetProp(m_hmname,m_display,m_bFlash,m_str1,
m_str2,m_color1,m_color2,m_FangXiang,
m_TextHeight,m_TextWidth,m_JqWidth,
m_TextFont,m_bTranslate1,m_bTranslate2);
sheet.AddPage( (CPropertyPage*)&dlg );
CPropPositionRect dlgpos;
dlgpos.SetContent(m_x0,m_y0,m_x1,m_y1);
sheet.AddPage( (CPropertyPage*)&dlgpos );
if (sheet.DoModal() == IDOK)
{
Invalidate();
UnRegister();
dlg.GetProp(m_hmname,m_display,m_bFlash,m_str1,m_str2,
m_color1,m_color2,m_FangXiang,m_TextHeight,
m_TextWidth,m_JqWidth,m_TextFont,m_bTranslate1,
m_bTranslate2);
if (strlen(m_str1)==0) strcpy(m_str1," ");
if (strlen(m_str2)==0) strcpy(m_str2," ");
dlgpos.GetContent(m_x0,m_y0,m_x1,m_y1);
SetModifiedFlag();
Invalidate();
Register();
return;
}
}
void C4ValueMapData::Reset()
{
// unreg from name list (if using one)
if (pNames) UnRegister();
pNames = nullptr;
// free data
delete[] pData;
pData = nullptr;
}
void Event::Cancel() noexcept {
auto sp_dispatcher = dispatcher_.lock();
if (sp_dispatcher) {
sp_dispatcher->UnRegister(shared_from_this());
} else {
LOG(INFO) << "weak dispatcher is invalid now";
}
}
// Destructor
//-----------------------------------------------------------------------------
CPUTMesh::~CPUTMesh()
{
// un-register the streams of this mesh from OpenGL
UnRegister();
if(m_pVertexBufferObjectIDs)
{
delete [] m_pVertexBufferObjectIDs;
m_pVertexBufferObjectIDs = NULL;
}
}
void C4ValueMapData::Register(C4ValueMapNames *pnNames)
{
// UnReg from old?
if (pNames) UnRegister();
if (pnNames) pnNames->Register(this);
pNames = pnNames;
// alloc data array
ReAllocList();
}
void C4ValueMapNames::Reset()
{
// unreg all data lists
while (pFirst) UnRegister(pFirst);
// free name list
for (int32_t i = 0; i < iSize; i++)
delete[] pNames[i];
delete[] pNames;
pNames = nullptr;
iSize = 0;
}
hsKeyedObject::~hsKeyedObject()
{
if( fpKey && fpKey->ObjectIsLoaded() )
{
// If our key is pointing to an object (presumably back to us),
// then UnRegister will call SetObjectPtr(nil) will unregister the key (and us), which will
// decrement our RefCnt. Unfortunately, we are here because of a call
// to our destructor, in which case we don't want to go back into our
// destructor again. So we'll just up the RefCnt, plKey::UnRegister will dec it back to 1.
hsRefCnt_SafeRef(fpKey->ObjectIsLoaded());
}
UnRegister();
}
Object* HandlerServiceFactory::Create(
const QString& serviceInterface, IServiceLocator* parentLocator,
IServiceLocator* locator) const
{
if (serviceInterface != qobject_interface_iid<IHandlerService*>())
{
return nullptr;
}
IWorkbenchLocationService* wls = locator->GetService<IWorkbenchLocationService>();
IWorkbench* const wb = wls->GetWorkbench();
if (wb == nullptr)
{
return nullptr;
}
Object* parent = parentLocator->GetService(serviceInterface);
if (parent == nullptr)
{
ICommandService* commands = locator->GetService<ICommandService>();
IEvaluationService* evals = locator->GetService<IEvaluationService>();
auto handlerService = new HandlerService(commands, evals, locator);
handlerService->Register();
handlerService->ReadRegistry();
handlerService->UnRegister(false);
return handlerService;
}
return nullptr;
IWorkbenchWindow* const window = wls->GetWorkbenchWindow();
IWorkbenchPartSite* const site = wls->GetPartSite();
if (site == nullptr)
{
Expression::Pointer exp(new WorkbenchWindowExpression(window));
return new SlaveHandlerService(dynamic_cast<IHandlerService*>(parent), exp);
}
if (SlaveHandlerService* slaveParent = dynamic_cast<SlaveHandlerService*>(parent))
{
Expression::Pointer parentExp = slaveParent->GetDefaultExpression();
if (parentExp.Cast<ActivePartExpression>())
{
return new NestableHandlerService(dynamic_cast<IHandlerService*>(parent), parentExp);
}
}
Expression::Pointer exp(new ActivePartExpression(site->GetPart().GetPointer()));
return new SlaveHandlerService(dynamic_cast<IHandlerService*>(parent), exp);
}
CMasterFader::~CMasterFader()
{
UnRegister();
for (int i=0; i<NUM_FADERS; ++i)
SAFE_DELETE(m_pHUDFader[i]);
}
//------------------------------------------------------------------------
CEGTrayIcon::~CEGTrayIcon(void)
{
UnRegister();
}
Hotkey::~Hotkey(){
UnRegister();
}
void CTpnsMsgManager::Register(uint8_t cmd, CTpnsMsgBase* pPrototype)
{
UnRegister(cmd);
m_msgMap[cmd] = pPrototype;
}
DListener::~DListener()
{
UnRegister();
}
//--------------------------------------------------------------------------------------------------
// Name: ~CLetterBoxHudEventListener
// Desc: Destructor
//--------------------------------------------------------------------------------------------------
CLetterBoxHudEventListener::~CLetterBoxHudEventListener()
{
UnRegister();
}//-------------------------------------------------------------------------------------------------
plTempKey::~plTempKey()
{
UnRegister();
delete fObjectPtr;
fObjectPtr = nil;
}
CListener::~CListener()
{
UnRegister();
}
void NFCGameServerToWorldModule::OnClientDisconnect( const int nAddress )
{
UnRegister();
}
// Register the buffer with OpenGL
//-----------------------------------------------------------------------------
CPUTResult CPUTMesh::Register(void** ppLayout)
{
CPUTResult result;
result = UnRegister();
if(CPUTFAILED(result))
return result;
int NumberOfVertexStreamsInThisMesh = GetVertexStreamCount();
int NumberOfTotalStreamsInThisMesh=NumberOfVertexStreamsInThisMesh;
// if indexed, we need one additional vbo
if(IsIndexedMesh())
NumberOfTotalStreamsInThisMesh++;
// allocate the variables we'll need for this operation
//m_ppDXBufferObjects = new ID3D11Buffer*[NumberOfVertexStreamsInThisMesh];
//D3D11_INPUT_ELEMENT_DESC* layout = new D3D11_INPUT_ELEMENT_DESC[ NumberOfVertexStreamsInThisMesh ];
//m_pStreamStrides = new UINT[NumberOfVertexStreamsInThisMesh];
//m_pStreamOffsets = new UINT[NumberOfVertexStreamsInThisMesh];
// generate 1 VAO (vertex array object) to hold all these streams
glGenVertexArrays(1, &m_VertexArrayObjectID);
// Bind VAO so you can
glBindVertexArray(m_VertexArrayObjectID);
// generate 'stream' slots
m_pVertexBufferObjectIDs = new GLuint[NumberOfTotalStreamsInThisMesh];
glGenBuffers(NumberOfTotalStreamsInThisMesh, m_pVertexBufferObjectIDs);
for(int j=0; j<NumberOfVertexStreamsInThisMesh; j++)
{
// register each stream of each mesh, storing it's DX object pointer
CPUTMeshStream* stream = GetVertexStream(j);
if(CPUT_STREAM_ELEMENT_LAYOUT_UNIFORM == stream->GetStreamElementLayoutType())
{
// non-indexed
CPUTMeshStreamUniform* uniformStream = (CPUTMeshStreamUniform*) stream;
// deterimine the number of components per generic vertex attribute. Must be 1, 2, 3, or 4.
// bind this stream's data
GLenum glDataType;
void* pData = NULL;
glDataType = ConvertCPUTFormatToGL(uniformStream->GetDataFormatElementType());
glBindBuffer(GL_ARRAY_BUFFER, m_pVertexBufferObjectIDs[j]);
uniformStream->Lock(&pData);
glBufferData(GL_ARRAY_BUFFER, uniformStream->GetDataElementBlockSize() * uniformStream->GetNumberVerticies(), pData, GL_STATIC_DRAW);
uniformStream->Unlock();
glVertexAttribPointer((GLuint)j, uniformStream->GetNumberDataFormatElements(), glDataType, GL_FALSE, 0, 0);
glEnableVertexAttribArray(j); // slot number
// Store the number of verticies
// TODO: BUG - what if there diff number of elements/stream?
m_NumberOfVerticies = uniformStream->GetNumberVerticies();
}
else if(CPUT_STREAM_ELEMENT_LAYOUT_FLEXIBLE == stream->GetStreamElementLayoutType())
{
// TODO: fill this out with flexible streams
}
else
{
// TODO: ERROR
}
}
// register any index stream (if there is one)
if(IsIndexedMesh())
{
CPUTMeshStream* stream = GetIndexStream();
if(CPUT_STREAM_ELEMENT_LAYOUT_UNIFORM == stream->GetStreamElementLayoutType())
{
void* pData = NULL;
CPUTMeshStreamUniform* uniformStream = (CPUTMeshStreamUniform*) stream;
// bind index stream and fill data
// last m_pVertexBufferObjectID[] is always the Index buffer (if there is one)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pVertexBufferObjectIDs[NumberOfTotalStreamsInThisMesh-1]);
uniformStream->Lock(&pData);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, uniformStream->GetDataElementBlockSize() * uniformStream->GetNumberVerticies(), pData, GL_STATIC_DRAW);
uniformStream->Unlock();
// this is an indexed mesh, so draw as such
m_MeshDrawingType = CPUT_STREAM_TYPE_INDEX;
m_NumberOfVerticies = uniformStream->GetNumberVerticies();
}
}
// unbind what we were doing
// todo: would be better to restore the user's state instead of just blast over it with 0
glBindVertexArray(0);
return CPUT_SUCCESS;
}
inline int UnRegister(ServiceT* pService)
{
return UnRegister(&pService->m_ServerInterface);
}
void CNEOMemPoolWithLock::Free(void *pBlock)
{
if(m_pMemPool)
m_pMemPool->Free(pBlock);
UnRegister(pBlock);
}
