www.pudn.com > zfxcengine-0.1.0.zip > ceRenderApp.cpp

/* $Id: ceRenderApp.cpp,v 1.24 2005/09/01 19:47:30 florianxx Exp $ */ 
//////////////////////////////////////////////////////////////////////////////// 
//  Module:    Render                                                         
//! \file      ceRenderApp.cpp 
//! \brief     Stellt eine Klasse zur Verfgung, die alles initialisiert, was man zum Rendern braucht 
//! \author    Enrico Z. 
//                                                                             
//                                                   
// Diese Datei steht unter der LGPL-Lizenz, welche   
// im Hauptordner(ZFXC-Engine) unter LICENSE         
// nachlesbar ist.                                   
//////////////////////////////////////////////////////////////////////////////// 
#include  
#include "Render/ceRenderApp.h" 
#include "Core/ceMemManager.h" 
#include "Core/ceDynlib.h" 
 
using namespace std; 
 
namespace ZFXCE { 
	namespace Render { 
		//////////////////////////////////////////////////////////////////////////////// 
		ceRenderApp::ceRenderApp(int argc, char* argv[]): m_pRenderSystem(NULL), 
			m_pRenderDevice(NULL), m_pWindow(NULL), m_pTextureManager(NULL),  
			m_pRenderObjectFactory(NULL), m_pRenderQueue(NULL), m_bClearColor(TRUE), 
			m_bClearDepth(TRUE), m_bClearStencil(FALSE), m_pInputSystem(NULL) 
		{ 
			m_ClearColor = ceColorRGBA(0.7f, 0.7f, 0.7f, 1.0f); 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		ceRenderApp::ceRenderApp(): m_pRenderSystem(NULL), m_pRenderDevice(NULL), m_pWindow(NULL), 
			m_pTextureManager(NULL), m_pRenderObjectFactory(NULL), m_pRenderQueue(NULL), 
			m_bClearColor(TRUE), m_bClearDepth(TRUE), m_bClearStencil(FALSE), m_pInputSystem(NULL) 
		{ 
			m_ClearColor = ceColorRGBA(0.7f, 0.7f, 0.7f, 1.0f); 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		ceRenderApp::~ceRenderApp() 
		{ 
			ceRenderApp::Release(); 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		bool ceRenderApp::Init() 
		{ 
			PUSH_FUNCTION; 
 
			//config Datei auslesen und standardwerte fr Fenster eintragen 
			// VFS und so initialisieren 
			ceMainApp::Init(); 
			m_pVFS = ceMainApp::GetFileManager(); 
			m_pArchiveManager = m_pVFS->GetArchivManager(); 
			m_pArchiveManager->RegisterDataDir("./"); 
			m_pArchiveManager->RegisterFileExtension("zip", ARCHIVE_ZIP); 
			m_pArchiveManager->RegisterFileExtension("pk3", ARCHIVE_ZIP); 
			m_pArchiveManager->RegisterFileExtension("pk4", ARCHIVE_ZIP); 
			m_pArchiveManager->SearchForArchives(); 
 
			// Inputsystem erstellen 
			ZFXCE::DynLib::RegisterDynLinkedLib(DynLib::CE_INPUT_SDL); 
			ZFXCE::DynLib::GetFromDLL(DynLib::CE_INPUT_SDL, (ceIDefaultSystem**) &m_pInputSystem); 
 
			if(m_strAPI == "OpenGL") 
			{ 
				ZFXCE::DynLib::RegisterDynLinkedLib(DynLib::CE_RENDER_OGL); 
				ZFXCE::DynLib::GetFromDLL(DynLib::CE_RENDER_OGL, (ceIDefaultSystem**) &m_pRenderSystem); 
			} 
#ifdef WIN32 
			else if(m_strAPI == "D3D9") 
			{ 
				// es gibt nur unter Windows einen D3D9 Renderer 
				ZFXCE::DynLib::RegisterDynLinkedLib(DynLib::CE_RENDER_D3D9); 
				ZFXCE::DynLib::GetFromDLL(DynLib::CE_RENDER_D3D9, (ceIDefaultSystem**) &m_pRenderSystem); 
			} 
#endif 
			else 
				CE_EXCEPTION("Unbekannte Render-API: "+m_strAPI, CELS_HARDERROR); 
 
			m_pInputDevice = m_pInputSystem->GetDevice(); 
 
			if(!m_pRenderSystem) 
				CE_EXCEPTION(std::string(__FUNCTION__)+": Got no Rendersystem!", CELS_HARDERROR); 
 
			// RenderSystem erstellen 
			m_pRenderDevice = m_pRenderSystem->CreateDevice(); 
 
			if (NULL == m_pRenderDevice) 
			{ 
				std::cerr << "Invalides RenderDevice!" << std::endl; 
				return FALSE; 
			} 
			 
			// Nur ein Fenster erstellen, falls nötig 
			if(NULL == m_pWindow) 
			{ 
				m_pWindow = m_pRenderDevice->CreateNewWindow(&m_WinProp, m_WinProp.var); 
				 
				if (NULL == m_pWindow) 
				{ 
					cerr << "Invalides Fenster!" << endl; 
					return FALSE; 
				}	 
			} 
			else 
			{ 
				m_pRenderDevice->AddWindow(m_pWindow); 
				m_pRenderDevice->SetupAPI(m_WinProp.m_ScreenMode.m_uiWidth, m_WinProp.m_ScreenMode.m_uiHeight); 
			} 
	 
			m_pRenderDevice->Create(); 
			 
			m_pRenderDevice->SetClearColor(m_ClearColor); 
 
			m_pTextureManager = m_pRenderDevice->GetTextureManager(); 
			if (NULL == m_pTextureManager) 
			{ 
				CE_EXCEPTION("ceRenderApp::Init(): Invalider Texturmanager!\n", CELS_ERROR); 
				return FALSE; 
			} 
 
			m_pTextureManager->Init(m_pVFS); 
 
			m_pRenderObjectFactory = m_pRenderDevice->GetRenderObjectFactory(); 
			m_pRenderQueue = m_pRenderDevice->GetRenderQueue(); 
			 
			/* Events updaten */ 
			m_pInputDevice->Update(); 
 
			// Timer initialisieren 
			m_Timer.Init(); 
 
			return TRUE; 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		bool ceRenderApp::Release() 
		{ 
			m_pTextureManager->RemoveAllTextures(); 
 
			m_pInputDevice->Release(); 
 
			ZFXCE::DynLib::DestroySystem("SDL Input", (ceIDefaultSystem**) &m_pInputSystem); 
			ZFXCE::DynLib::DestroySystem("OpenGL Renderer", (ceIDefaultSystem**) &m_pRenderSystem); 
 
			ceMainApp::Release(); 
 
			return TRUE; 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		void ceRenderApp::PreFrame() 
		{ 
			m_pRenderDevice->ClearBuffers(m_bClearColor, m_bClearDepth, m_bClearStencil); 
 
			m_pRenderDevice->BeginFrame(); 
 
			/* Der User setzt jetzt die Kamera und fuegt Jobs hinzu */ 
		}	 
		//////////////////////////////////////////////////////////////////////////////// 
		void ceRenderApp::PostFrame() 
		{ 
			/* Und wir rendern alles */ 
			m_pRenderQueue->RenderAll(); 
 
			// Dazu erst den alten Titel sichern 
			static std::string strOldTitle = m_pWindow->GetTitle(); 
			 
			// FPS berechnen und in den Fenstertitel setzen 
			static UINT uiFPS = 1; 
			static UINT uiOldFPS=0; 
			m_Timer.GetFPS(&uiFPS); 
 
			if(uiOldFPS != uiFPS) 
			{ 
				static char strFPS[20]; 
				sprintf(strFPS, " - %d FPS", uiFPS ); 
				// we should only do this in windowed mode 
				if(m_WinProp.m_ScreenMode.m_bFullscreen == FALSE) 
					m_pWindow->SetTitle(strOldTitle + strFPS); 
				uiOldFPS = uiFPS; 
			} 
 
			// Render the whole data 
			m_pRenderDevice->EndFrame(); 
		} 
		//////////////////////////////////////////////////////////////////////////////// 
		void ceRenderApp::Execute() 
		{ 
			/* Events abarbeiten */ 
			if(!m_pInputDevice->Update()) 
				exit(0); 
 
			/* nun das eigentliche Frame */ 
			PreFrame(); 
 
			/* user Funktion */ 
			Run(); 
 
			/* Frame beenden */ 
			PostFrame(); 
 
			/* Und Buffer tauschen */ 
			m_pWindow->Update(); 
		} 
	}	// namespace Render 
}		// namespace ZFXCE