void PBRDemo::Shutdown() {
// Release in the opposite order we initialized in
delete m_pointLightBuffer;
delete m_spotLightBuffer;
delete m_instanceBuffer;
delete(m_instancedGBufferVertexShader);
delete(m_fullscreenTriangleVertexShader);
delete(m_tiledCullFinalGatherComputeShader);
delete(m_postProcessPixelShader);
ReleaseCOM(m_defaultInputLayout);
ReleaseCOM(m_debugObjectInputLayout);
for (auto iter = m_gBuffers.begin(); iter != m_gBuffers.end(); ++iter) {
delete *iter;
}
delete m_depthStencilBuffer;
ReleaseCOM(m_backbufferRTV);
if (m_sceneLoaderThread.joinable()) {
m_sceneLoaderThread.detach();
}
TwTerminate();
Engine::HalflingEngine::Shutdown();
}
void clean_up()
{
#if TWEAK_MENU
TwTerminate();
#endif // TWEAK_MENU
SDL_Quit();
}
// Release the memory held by all objects created
void CScene::ReleaseResources()
{
// The D3D setup and preparation of the geometry created several objects that use up memory (e.g. textures, vertex/index buffers etc.)
// Each object that allocates memory (or hardware resources) needs to be "released" when we exit the program
// There is similar code in every D3D program, but the list of objects that need to be released depends on what was created
// Test each variable to see if it exists before deletion
if( mpd3dDeviceContext ) mpd3dDeviceContext->ClearState();
//delete Camera;
for(int i = 0; i < miNumObjects; i++)
{
delete mpObjects[i];
}
for(int i = 0; i < miNumLights; i++)
{
delete mpLights[i];
}
for(int i = 0; i < miNumMaps; i++)
{
if ( mpMaps[i] )
mpMaps[i]->Release();
}
if( Effect ) Effect->Release();
if( DepthStencilView ) DepthStencilView->Release();
if( RenderTargetView ) RenderTargetView->Release();
if( DepthStencil ) DepthStencil->Release();
if( SwapChain ) SwapChain->Release();
if( mpd3dDevice ) mpd3dDevice->Release();
TwTerminate();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{
if (!initGlfw(argc, argv))
return 0;
if (!initGL(argc, argv))
return 0;
LOG_INFO("Starting main loop.");
running = GL_TRUE;
//g_timer.reset();
while (
running &&
!glfwWindowShouldClose(g_pWindow) &&
!glfwWindowShouldClose(g_pWindow2)
)
{
//float dt = (float)g_timer.seconds();
//timestep(dt);
//g_timer.reset();
display();
//running = running && glfwGetWindowParam(GLFW_OPENED);
glfwPollEvents();
}
TwTerminate();
glfwTerminate();
return 0;
}
CDebugHelperImplementation::~CDebugHelperImplementation()
{
// TODO: finalizar AntTweakBar
int status = TwTerminate();
assert(status);
}
void outPut::reInit()
{
///Terminer AntTweakBar
TwTerminate();
///Terminer GLFW
glfwTerminate();
init_outPut();
}
void Scene::Shutdown()
{
//LAST
TwDeleteAllBars();
TwTerminate();
}
void AntTweakBarWrapper::Cleanup()
{
m_control_panel_bar = NULL;
m_mesh_bar = NULL;
m_sim_bar = NULL;
TwTerminate();
}
Gui::~Gui()
{
if(m_tweakbar)
{
TwDeleteBar(m_tweakbar);
}
TwTerminate();
}
int main(int argc, char *argv[])
{
init(argc, argv);
run();
TwTerminate();
free_resources();
return 0;
}
ControlUI::~ControlUI()
{
//SAFE_DELETE(mpBar);
if (mIsUseTw)
{
TwTerminate();
}
}
bool Tweaker::Terminate()
{
if(s_isInit && !s_doNotUseLib) {
Tweaker::Close();
return TwTerminate() == 0? false : true;
} else {
return false;
}
}
// Function called at exit
void Terminate(void)
{
int i;
for (i=0; i<2; i++) {
glutSetWindow(g_SubWindowData[i].WinID);
glDeleteLists(SHAPE_TEAPOT, NUM_SHAPES);
}
TwTerminate();
}
void destroyObjects(void){
#if _DEBUG
FPS_delete(_fpsCounter);
#endif
Camera_delete(_camera);
SSController_Delete();
GameTime_delete(gameTime);
TwTerminate();
}
GLFW_App::~GLFW_App()
{
TwTerminate();
// close all windows
m_windows.clear();
// terminate GLFW
glfwTerminate();
}
outPut::~outPut()
{
///Terminer AntTweakBar
TwTerminate();
glDeleteProgram(_sLight.getProgramID());
glDeleteProgram(_postProcess.getProgramID());
glDeleteProgram(_sNolight.getProgramID());
///Terminer GLFW
glfwTerminate();
}
void App::Shutdown()
{
//must Use with PHYSX Engine
//m_Physics->Shutdown();
TwDeleteAllBars();
TwTerminate();
glfwDestroyWindow(window);
glfwTerminate();
}
void Application::OnDestroy()
{
if(m_pScene)
delete m_pScene;
m_pWindow->Release();
m_pRenderer->Release();
m_pCamera->Release();
TwTerminate();
}
fractal_t::~fractal_t()
{
// Удаление русурсов OpenGL
glDeleteProgram(program_);
glDeleteShader(vs_);
glDeleteShader(fs_);
glDeleteVertexArrays(1, &vao_);
glDeleteBuffers(1, &vx_buf_);
TwDeleteAllBars();
TwTerminate();
}
Graphics::~Graphics()
{
delete mat_stack_;
delete camera_;
delete options_;
delete graphicsAPI;
for(auto& it : loaders_)
{
delete (it.val);
}
TwTerminate();
}
static void unload(GLFWwindow* window)
{
// AntTweakBar
TwTerminate();
delete s_grid;
delete s_model;
delete g_ball;
ffmpegClose();
}
int main()
{
Core demo;
demo.initialize(GetModuleHandle(nullptr));
while (!demo.window.quitFlag)
{
demo.frame();
}
demo.d3d.immediate_ctx->ClearState();
demo.d3d.immediate_ctx->Flush();
//HACK: move this elsewhere
TwTerminate();
}
void Game::Shutdown()
{
//Terminate AntTweakBar
TwTerminate();
//Release the graphics object
if (m_Graphics)
{
m_Graphics->Shutdown();
delete m_Graphics;
m_Graphics = 0;
}
//Release WaveManager
if (m_waveManager)
{
m_waveManager->Shutdown();
delete m_waveManager;
m_waveManager = 0;
}
//Release the camera object
if (m_Camera)
{
delete m_Camera;
m_Camera = 0;
}
//Release light
delete m_light;
m_light = 0;
//Release all gameobjects
for (vector<GameObject*>::iterator it = m_renderObjects.begin(); it != m_renderObjects.end(); ++it)
{
(*it)->Shutdown();
delete *it;
*it = 0;
}
m_renderObjects.clear();
//Release the input object
if (m_Input)
{
delete m_Input;
m_Input = 0;
}
}
bool Game::Cleanup()
{
AGLLoader::Release();
ShaderManager::Release();
Camera::Release();
TextureManager::Release();
Scene::Release();
DX11Application::Cleanup();
SceneDialog::Release();
RasterManager::cleanup();
TwTerminate();
delete m_cameraController;
delete SPHEREMESH;
delete BOXMESH;
return true;
}
// ***************************************************** Figure::destruction
~FigureAnt()
{
// Terminate AntTweakBar
TwDeleteBar( _bar );
TwTerminate();
glfwSetWindowShouldClose(_window, GL_TRUE);
if(_window)
glfwDestroyWindow( _window);
if( _offscreen ) {
glDeleteRenderbuffers( 1, &_render_buf );
utils::gl::check_error();
glDeleteFramebuffers( 1, &_fbo );
utils::gl::check_error();
}
}
int main(int argc, char **argv)
{
Initialize(argc, argv);
InitializeUI();
glutReshapeFunc(ResizeFunction);
glutDisplayFunc(RenderFunction);
glutIdleFunc(RenderFunction);
glewInit();
programID = LoadShaders("shader.vert", "shader.frag");
LoadTriangle();
CreateGeometry();
glutMainLoop();
TwTerminate();
}
void teardown()
{
TwTerminate();
// Free device global memory
checkCudaErrors(cuMemFree(d_img_content));
//cuProfilerStop();
free(img_content);
rmt_UnbindOpenGL();
rmt_DestroyGlobalInstance(rmt);
cuDevicePrimaryCtxRelease(cuDevice);
cudaDeviceReset();
}
void Terminate()
{
TwTerminate();
glDeleteBuffers(1, &Material::UBO);
glDeleteBuffers(1, &PointLight::UBO);
glDeleteBuffers(1, &g_Camera.UBO);
g_Spheres.shrink_to_fit();
CleanMesh(g_SphereMesh);
glDeleteTextures(3, g_Walls.textures);
CleanMesh(g_WallMesh);
g_BlinnPhongShader.Destroy();
g_AmbientShader.Destroy();
}
static void Terminate()
{
ReleaseTerrain();
for(int i=0;i<MAX_NB_TESTS;i++)
{
gCollisionTests[i]->Release();
DELETESINGLE(gCollisionTests[i]);
}
if(gMainBar)
{
TwDeleteBar(gMainBar);
gMainBar = null;
}
TwTerminate();
}
// ---------- framework : cleanup dx ----------
bool rtvsD3dApp::cleanupDX (LPDIRECT3DDEVICE9 pd3dDevice)
{
// ---- invalidate the texture object ----
if( pTexture != NULL )
{
int nNewRefCount = pTexture->Release();
if( nNewRefCount > 0 )
{
static char strError[256];
sprintf_s ( strError, 256,
"The texture object failed to cleanup properly.\n"
"Release() returned a reference count of %d",
nNewRefCount );
MessageBox( NULL, strError, "ERROR", MB_OK | MB_ICONEXCLAMATION );
}
pTexture = NULL;
}
// ---- invalidate the quad vertex buffer object ----
if( pQuadVertexBuffer != NULL )
{
int nNewRefCount = pQuadVertexBuffer->Release();
if( nNewRefCount > 0 )
{
static char strError[256];
sprintf_s ( strError, 256,
"The quad vertex buffer object failed to cleanup properly.\n"
"Release() returned a reference count of %d",
nNewRefCount );
MessageBox( NULL, strError, "ERROR", MB_OK | MB_ICONEXCLAMATION );
}
pQuadVertexBuffer = NULL;
}
TwTerminate();//cleanup anttweakbar
// ok
return true;
}
