//=============================================================================
// 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.";
        }
    }

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

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

FiberMesh::~FiberMesh() {
   m_dragData.isDragging = false;
   
   FOREACH(CurveListIter, m_curves, iter) {
      DifferentialCurve *curve = *iter;
      
      safeDelete(curve);
   }