//=============================================================================
// Delete all reserved memory
//=============================================================================
void Game::deleteAll()
{
releaseAll(); // call onLostDevice() for every graphics item
safeDelete(graphics);
safeDelete(input);
initialized = false;
}
bool AudioHandler::setMusic(const std::string& musicKey)
{
//Set current music playing.
stopMusic();
if(musicList.find(musicKey) == musicList.end())
{
std::cout << "Music not found";
return true;
}
if(song != NULL) safeDelete(song);
song = new sbe::Music();
if(!song->OpenFromFile(musicList[musicKey]))
{
Logger::writeMsg(1) << "Music could not be loaded!";
safeDelete(song);
return true;
}
song->SetVolume(mVol);
song->Initialize(2, 44100);
song->Play();
Logger::writeMsg(1) << "Music \"" << musicKey << "\" now playing.";
return false;
}
Lab3Canvas::~Lab3Canvas()
{
safeDelete(m_timer);
safeDelete(m_camera);
gluDeleteQuadric(m_quadric);
makeCurrent();
}
Kernel::~Kernel()
{
program->removeAllShaders();
safeDelete(fragmentShader);
safeDelete(vertexShader);
safeDelete(program);
}
void CSystem::destroyContexts()
{
assert( G_RENDERCTX );
safeDelete( G_RENDERCTX );
assert( G_INPUTCTX );
safeDelete( G_INPUTCTX );
}
//=============================================================================
// Starting point for a Windows application
//=============================================================================
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
// Check for memory leak if debug build
#if defined(DEBUG) | defined(_DEBUG)
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif
MSG msg;
// Create the game, sets up message handler
game = new TileCollision;
// Create the window
if (!CreateMainWindow(hwnd, hInstance, nCmdShow))
return 1;
try{
game->initialize(hwnd); // throws GameError
// main message loop
int done = 0;
while (!done)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// look for quit message
if (msg.message == WM_QUIT)
done = 1;
// decode and pass messages on to WinProc
TranslateMessage(&msg);
DispatchMessage(&msg);
} else
game->run(hwnd); // run the game loop
}
safeDelete(game); // free memory before exit
return msg.wParam;
}
catch(const GameError &err)
{
game->deleteAll();
DestroyWindow(hwnd);
MessageBox(NULL, err.getMessage(), "Error", MB_OK);
}
catch(...)
{
game->deleteAll();
DestroyWindow(hwnd);
MessageBox(NULL, "Unknown error occured in game.", "Error", MB_OK);
}
safeDelete(game); // free memory before exit
return 0;
}
LyingShapesScene::~LyingShapesScene()
{
for (auto shapeIt = cubes.begin(); shapeIt != cubes.end(); shapeIt++)
{
delete (*shapeIt);
}
cubes.clear();
safeDelete(&grid);
safeDelete(&coords);
safeDelete(&mCubes);
}
void cCore::finalize()
{
safeDelete(m_gui);
safeDelete(m_renderer, true);
safeDelete(m_luaMgr);
safeDelete(m_classCreater);
safeDelete(m_msgMgr);
safeDelete(m_batchRenderMgr, true);
safeDelete(m_postProcessMgr, true);
safeDelete(m_fileSystem, true);
safeDelete(m_fileWatcher);
safeDelete(m_debugRenderMgr, true);
}
void FlowText::close()
{
if (mRunning)
{
gGlobalClient->getTimerAxis()->KillTimer(0, this);
mText.clear_wstr();
safeDelete(mPosX);
safeDelete(mPosY);
safeDelete(mAlpha);
safeDelete(mSize);
mRunning = false;
}
}
CWall3D::~CWall3D()
{
for( int i = 0; i < RMCOUNT; ++i ) {
safeDelete( mRenderables[i] );
}
safeDelete( mFadeInMesh );
stl_utils::wipe( mPiecesCombined );
safeDeleteArray( mPieces3D );
safeDeleteArray( mFracturedPieces );
safeDeleteArray( mPieceRestoreTimes );
safeDeleteArray( mQuadtree );
safeDeleteArray( mResTimeGrid );
}
void AsynFileDevice::Close()
{
if ( m_hHandle!=INVALID_HANDLE_VALUE )
{
::CloseHandle(m_hHandle);
m_hHandle = INVALID_HANDLE_VALUE;
}
assert(m_pendingList.empty());
m_pendingList.clear();
safeDelete(m_pReader);
safeDelete(m_pWriter);
}
void CDemo::shutdown()
{
gWriteD3DSettingsPref();
CONS << "Shutting down..." << endl;
CGameInfo::finalize();
delete gDebugRenderer;
safeDelete( gUIDlg );
safeDelete( gUISettingsDlg );
safeDelete( gUIHelpDlg );
safeDelete( gUIGameSetupDlg );
CONS << "Done!" << endl;
}
bool MemoryFileWriter::reallocate(size_t s)
{
if (s == 0)
{
return false;
}
size_t newSize = _cursor + s;
void* b = new char[newSize];
if (b == NULL)
{
return false;
}
memset(b, 0, newSize);
if (_cursor > 0)
{
memcpy(b, _buffer, _cursor);
}
safeDelete(_buffer);
_buffer = b;
_length = newSize;
return true;
}
void AudioHandler::fadeOut(float elapsed, const std::string& strM, float s)
{
//Fade out music during s seconds, or crossfade between song and strM if c = true.
if(fadeCounter != 0) return;
if(strM != "") cross = true;
fadeCounter = elapsed;
interval = mVol / s;
if(cross)
{
if(musicList.find(strM) == musicList.end())
std::cout << "Music not found";
crossSong = new sbe::Music();
if(!crossSong->OpenFromFile(musicList[strM]))
{
Logger::writeMsg(1) << "Music could not be loaded!";
safeDelete(crossSong);
}
crossSong->SetVolume(0);
crossSong->Initialize(2, 44100);
crossSong->Play();
Logger::writeMsg(1) << "Music \"" << strM << "\" now playing.";
}
}
// This function will take a resolved URI and create a version of it that is relative to
// another existing URI. The new URI is stored in the "originalURI"
int daeURI::makeRelativeTo(daeURI* relativeToURI)
{
// !!!GAC for some reason, relativeToURI is in pending and not success state, why??
// Can't do this function unless both URIs have already been successfully resolved
if(getState() != uri_success /*|| relativeToURI->getState() != uri_success*/ )
return(DAE_ERR_INVALID_CALL); // !!!GAC Need to assign a real error code to this
// Can only do this function if both URIs have the same scheme and authority
if((strcmp(getProtocol(), relativeToURI->getProtocol()) != 0) || (strcmp(getAuthority(), relativeToURI->getAuthority()) != 0))
return(DAE_ERR_INVALID_CALL); // !!!GAC Need to assign a real error code to this
// advance till we find a segment that doesn't match
const char *this_filepath = getFilepath();
const char *relativeTo_filepath = relativeToURI->getFilepath();
const char *this_slash = this_filepath;
const char *relativeTo_slash = relativeTo_filepath;
while(*this_filepath == *relativeTo_filepath)
{
if(*this_filepath == '/')
{
this_slash = this_filepath;
relativeTo_slash = relativeTo_filepath;
}
this_filepath++;
relativeTo_filepath++;
}
// Decide how many ../ segments are needed (Filepath should always end in a /)
int segment_count = 0;
relativeTo_slash++;
while(*relativeTo_slash != 0)
{
if(*relativeTo_slash == '/')
segment_count ++;
relativeTo_slash++;
}
this_slash++;
// Delete old URI string
safeDelete(originalURIString);
// Allocate memory for a new "originalURI" and free the old one
char *newRelativeURI = (char*) daeMemorySystem::malloc("uri",strlen(relativeTo_slash)+ strlen(file)+(segment_count*3)+strlen(getID())+2);
char *temp = newRelativeURI;
for(int i = 0; i < segment_count; i++)
{
strcpy(temp,"../");
temp += 3;
}
strcpy(temp,this_slash);
strcat(temp,file);
if(id!=empty && strlen(getID()) != 0)
{
strcat(temp,"#");
strcat(temp,getID());
}
originalURIString = newRelativeURI;
return(DAE_OK);
}
daeURI::daeURI(daeString uriString, daeBool nofrag)
{
initialize();
// !!!GAC this is inefficient as hell, but was the best way to isolate this functionality till the
// !!!GAC daeURI class can be written to support modifying URIs better (should be possible to make a URI,
// !!!GAC change any member and have getURI return the proper const string URI)
if(nofrag)
{
// Strip off the fragment part before constructing the URI
daeString temp = safeCreate(uriString);
daeChar* fragment = (daeChar*)findCharacterReverse(temp, '#');
if(fragment)
{
*fragment = 0;
}
setURI(temp);
safeDelete(temp);
}
else
{
// Generate the URI without changing the string
setURI(uriString);
}
if(nofrag)
validate();
}
Tessellator::~Tessellator()
{
glDeleteVertexArrays(1, &m_vaoID);
glDeleteBuffers(1, &m_bufferID);
glDeleteQueries(1, &m_primitivesQuery);
safeDelete(program);
}
void SyncSourceConfig::setEncoding(const char* s) {
safeDelete(&encodings);
if (s) {
encodings = stringdup(s);
}
}
void AudioHandler::update(float elapsed)
{
if(fadeCounter == 0) return;
fadeCounter += elapsed;
if((mVol - (fadeCounter * interval) <= 0) || (fadeCounter >= (mVol / interval)))
{
fadeCounter = 0;
song->Stop();
if(cross)
{
safeDelete(song);
song = crossSong;
crossSong = NULL;
}
song->SetVolume(mVol);
}
else
{
if(cross) crossSong->SetVolume(fadeCounter * interval);
song->SetVolume(mVol - (fadeCounter * interval));
}
}
bool CButtonNode::setLogicEntity(logic::CButton* logicButton){
// Si no asociamos ninguna entidad logica, terminamos con exito
if(!CUINode::setLogicEntity(logicButton))
return false;
// Si ya hemos asociado una representacion logica,
// borramos la antigua
if(_logicButton){
_logicButton->removeListener(this);
safeDelete(_logicButton);
}
// Nos añadimos como observador y si fallamos devolvemos false
if(!logicButton->addListener(this))
return false;
// Asociamos la entidad logica
_logicButton = logicButton;
// Asignamos al boton los atributos
_status = (COglButton::EButtonStatus)logicButton->status();
textChanged(logicButton->text(), _logicButton->fontName(), _logicButton->fontSize());
return true;
}
void PackageService::onFinish()
{
FinishSqliteVFS();
// Turn off all sticky flags - NO MERCY!
for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr)
{
itr->second->_stayResident = false;
itr->second->_stayForCurrent = false;
itr->second->_stayForNext = false;
}
// And compact so that all packages get disposed
compact();
// If Something's remaining, we're in danger!
for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr)
{
Package* pack = itr->second;
LOG(0, "*** Package '%s': still alive: %d usage, requires:\n", pack->getName().c_str(), pack->getUseCount());
if (pack->getRequiredList().empty())
LOG(0, " <none>\n");
else
pack->printDependancy(1);
}
// Terminate AsyncLoader
if (_asyncLoader)
{
_asyncLoader->Terminate();
}
safeDelete(_asyncLoader);
}
TxGuiRenderer::~TxGuiRenderer()
{
safeRelease(m_pVB);
safeRelease(m_pVBQuick);
safeDelete(m_pResourceProvider);
m_alphaMaskImages.clear();
}
void SyncSourceConfig::setType(const char* t) {
safeDelete(&type);
if (t) {
type = new char[strlen(t)+1];
strcpy(type, t);
}
}
FiberMesh::~FiberMesh() {
m_dragData.isDragging = false;
FOREACH(CurveListIter, m_curves, iter) {
DifferentialCurve *curve = *iter;
safeDelete(curve);
}
static void FinishSqliteVFS()
{
assert(g_NitSqliteVFS);
sqlite3_vfs_unregister(g_NitSqliteVFS);
safeDelete(g_NitSqliteVFS);
}
void Material::preview(Shape *shape) {
SurfacePoint pt;
pt.shape = shape;
if (isEmitter()) {
Emitter *emitter = getEmitter(pt);
emitter->preview(shape);
if (emitter != Material::s_nullEmitter)
safeDelete(emitter);
}
BSDF *bsdf = getBSDF(pt);
bsdf->preview(shape);
safeDelete(bsdf);
}
void Material::setFilter(KernelFilter *filter) {
if (filter != m_filter) {
KernelFilter *oldFilter = m_filter;
m_filter = filter;
safeDelete(oldFilter);
}
}
void Gui::click(const sf::Vector2i& mousePos)
{
for(PanelMap::iterator it = panels.begin(); it != panels.end(); it++)
it->second.click(mousePos);
if(console->isShown())
console->click(mousePos);
else
{
if(mainMenu != NULL)
mainMenu->click(mousePos);
if(optionsMenu != NULL)
optionsMenu->click(mousePos);
if(selectMenu != NULL && !delMain)
selectMenu->click(mousePos);
if(showDia && diagPanel != NULL)
diagPanel->click(mousePos);
}
if(delMain)
{
safeDelete(mainMenu);
delMain = false;
}
if(delOpt)
{
safeDelete(optionsMenu);
delOpt = false;
}
if(delSec)
{
safeDelete(selectMenu);
delSec = false;
}
if(delDia)
{
safeDelete(diagPanel);
delDia = false;
}
}
void SyncSourceConfig::setSync(const char *s) {
safeDelete(&sync);
if (s) {
sync = new char[strlen(s)+1];
strcpy(sync, s);
}
}
void CFrame::remove(CUiComponent* component){
if(component){
_components.remove(component);
_mouseListeners.remove(component);
safeDelete(component);
}
}