Sprip os-specific tasks from Device

samples/terrain/terrain.cpp

@@ -17,7 +17,7 @@ public:
 	{
 		if (event.key == KC_ESCAPE)
 		{
-			GetDevice()->StopRunning();
+			GetDevice()->stop();
 		}
 	}
 };
@@ -123,7 +123,7 @@ public:
 		
 	void OnLoad()
 	{
-		crown::Renderer* renderer = crown::GetDevice()->GetRenderer();
+		crown::Renderer* renderer = crown::GetDevice()->renderer();
 
 		renderer->set_clear_color(Color4::LIGHTBLUE);
 		
@@ -167,7 +167,7 @@ public:
 
 	void RenderScene()
 	{
-		Renderer* renderer = GetDevice()->GetRenderer();
+		Renderer* renderer = GetDevice()->renderer();
 		
 		system->set_view_by_cursor();
 		system->camera_render();
@@ -250,9 +250,13 @@ private:
 
 int main(int argc, char** argv)
 {
-	Device* mDevice = GetDevice();
+	os::init_os();
+	os::create_render_window(0, 0, 1000, 625, false);
+	os::init_input();
 
-	if (!mDevice->Init(argc, argv))
+	Device* engine = GetDevice();
+
+	if (!engine->init(argc, argv))
 	{
 		return 0;
 	}
@@ -261,20 +265,22 @@ int main(int argc, char** argv)
 	MainScene mainScene;
 	mainScene.OnLoad();
 
-	while (mDevice->IsRunning())
+	while (engine->is_running())
 	{
 		os::event_loop();
 
 		get_input_manager()->event_loop();
 
-		GetDevice()->GetRenderer()->begin_frame();
+		engine->renderer()->begin_frame();
 			mainScene.RenderScene();
-		GetDevice()->GetRenderer()->end_frame();
+		engine->renderer()->end_frame();
 
 		os::swap_buffers();
 	}
 
-	mDevice->Shutdown();
+	engine->shutdown();
+
+	os::destroy_render_window();
 
 	return 0;
 }

src/Camera.cpp

@@ -154,8 +154,8 @@ const Frustum& Camera::GetFrustum() const
 
 void Camera::Render()
 {
-	GetDevice()->GetRenderer()->set_matrix(MT_PROJECTION, mProjection);
-	GetDevice()->GetRenderer()->set_matrix(MT_VIEW, mView);
+	GetDevice()->renderer()->set_matrix(MT_PROJECTION, mProjection);
+	GetDevice()->renderer()->set_matrix(MT_VIEW, mView);
 }
 
 void Camera::UpdateProjectionMatrix()

src/Device.cpp

@@ -35,8 +35,8 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Args.h"
 #include <cstdlib>
 
-// #include "renderers/gl/GLRenderer.h"
-#include "renderers/gles/GLESRenderer.h"
+#include "renderers/gl/GLRenderer.h"
+//#include "renderers/gles/GLESRenderer.h"
 
 namespace crown
 {
@@ -47,15 +47,17 @@ const uint16_t Device::CROWN_MICRO = 0;
 
 //-----------------------------------------------------------------------------
 Device::Device() :
-	mPreferredWindowWidth(1000),
-	mPreferredWindowHeight(625),
-	mPreferredWindowFullscreen(false),
-	mIsInit(false),
-	mIsRunning(false),
-	mRenderer(NULL)
+	m_preferred_window_width(1000),
+	m_preferred_window_height(625),
+	m_preferred_window_fullscreen(false),
+
+	m_is_init(false),
+	m_is_running(false),
+
+	m_renderer(NULL)
 {
-	string::strcpy(mPreferredRootPath, string::EMPTY);
-	string::strcpy(mPreferredUserPath, string::EMPTY);
+	string::strcpy(m_preferred_root_path, string::EMPTY);
+	string::strcpy(m_preferred_user_path, string::EMPTY);
 }
 
 //-----------------------------------------------------------------------------
@@ -64,134 +66,118 @@ Device::~Device()
 }
 
 //-----------------------------------------------------------------------------
-bool Device::Init(int argc, char** argv)
+bool Device::init(int argc, char** argv)
 {
-	if (ParseCommandLine(argc, argv) == false)
+	if (parse_command_line(argc, argv) == false)
 	{
 		return false;
 	}
 
-	// Initialize
-	Log::D("Initializing Device...");
-
-	if (IsInit())
+	if (is_init())
 	{
-		Log::E("Device is already initialized.");
+		Log::E("Crown Engine is already initialized.");
 		return false;
 	}
 
-	// Set the root path
-	// GetFilesystem()->Init(mPreferredRootPath.c_str(), mPreferredUserPath.c_str());
+	// Initialize
+	Log::I("Initializing Crown Engine %d.%d.%d...", CROWN_MAJOR, CROWN_MINOR, CROWN_MICRO);
 
-	// Create the main window
-	if (!os::create_render_window(0, 0, mPreferredWindowWidth, mPreferredWindowHeight, mPreferredWindowFullscreen))
-	{
-		Log::E("Unable to create the main window.");
-		return false;
-	}
-	Log::D("Window created.");
+	// Set the root path
+	// GetFilesystem()->Init(m_preferred_root_path.c_str(), m_preferred_user_path.c_str());
 
 	// Create the renderer
-	if (!mRenderer)
+	if (m_renderer == NULL)
 	{
 		// FIXME FIXME FIXME
 		// #ifdef CROWN_BUILD_OPENGL
-		// 	mRenderer = new GLRenderer();
+		 	m_renderer = new GLRenderer();
+			Log::I("Using GLRenderer.");
 		// #elif defined CROWN_BUILD_OPENGLES
-			mRenderer = new GLESRenderer();
+		//	m_renderer = new GLESRenderer();
 		// #endif
 	}
-	Log::D("Renderer created.");
-
-	os::init_input();
 
-	mIsInit = true;
+	m_is_init = true;
 
-	StartRunning();
+	start();
 
-	Log::I("Crown Game Engine %d.%d.%d", CROWN_MAJOR, CROWN_MINOR, CROWN_MICRO);
-	Log::I("Crown is up and running, enjoy!");
+	Log::I("Crown Engine initialized.");
 
 	return true;
 }
 
 //-----------------------------------------------------------------------------
-void Device::Shutdown()
+void Device::shutdown()
 {
-	if (!IsInit())
+	if (is_init() == false)
 	{
-		Log::E("Device is not initialized.");	
+		Log::E("Crown Engine is not initialized.");	
 		return;
 	}
 
 	Log::I("Releasing Renderer...");
 
-	if (mRenderer)
+	if (m_renderer)
 	{
-		delete mRenderer;
+		delete m_renderer;
 	}
 
-	Log::I("Releasing Render Window...");
-	os::destroy_render_window();
-
-	mIsInit = false;
+	m_is_init = false;
 }
 
 //-----------------------------------------------------------------------------
-bool Device::IsInit()
+bool Device::is_init() const
 {
-	return mIsInit;
+	return m_is_init;
 }
 
 //-----------------------------------------------------------------------------
-Renderer* Device::GetRenderer()
+Renderer* Device::renderer()
 {
-	return mRenderer;
+	return m_renderer;
 }
 
 //-----------------------------------------------------------------------------
-void Device::StartRunning()
+void Device::start()
 {
-	if (!IsInit())
+	if (is_init() == false)
 	{
+		Log::E("Cannot start uninitialized engine.");
 		return;
 	}
 
-	mIsRunning = true;
+	m_is_running = true;
 }
 
 //-----------------------------------------------------------------------------
-void Device::StopRunning()
+void Device::stop()
 {
-	if (!IsInit())
+	if (is_init() == false)
 	{
+		Log::E("Cannot stop uninitialized engine.");
 		return;
 	}
 
-	mIsRunning = false;
+	m_is_running = false;
 }
 
 //-----------------------------------------------------------------------------
-bool Device::IsRunning() const
+bool Device::is_running() const
 {
-	return mIsRunning;
+	return m_is_running;
 }
 
 //-----------------------------------------------------------------------------
-void Device::Frame()
+void Device::frame()
 {
-	os::event_loop();
-
 	get_input_manager()->event_loop();
 
-		mRenderer->begin_frame();
-		mRenderer->end_frame();
-
-	os::swap_buffers();
+	m_renderer->begin_frame();
+	m_renderer->end_frame();
 }
 
 //-----------------------------------------------------------------------------
-bool Device::ParseCommandLine(int argc, char** argv)
+bool Device::parse_command_line(int argc, char** argv)
 {
 	int32_t fullscreen = 0;
 
@@ -220,14 +206,14 @@ bool Device::ParseCommandLine(int argc, char** argv)
 			}
 			case 0:
 			{
-				mPreferredWindowFullscreen = fullscreen;
+				m_preferred_window_fullscreen = fullscreen;
 
 				break;
 			}
 			// Help
 			case 'i':
 			{
-				PrintHelpMessage();
+				print_help_message();
 				return false;
 			}
 			// Root path
@@ -239,7 +225,7 @@ bool Device::ParseCommandLine(int argc, char** argv)
 					return false;
 				}
 
-				string::strcpy(mPreferredRootPath, args.option_argument());
+				string::strcpy(m_preferred_root_path, args.option_argument());
 
 				break;
 			}
@@ -252,7 +238,7 @@ bool Device::ParseCommandLine(int argc, char** argv)
 					return false;
 				}
 
-				string::strcpy(mPreferredUserPath, args.option_argument());
+				string::strcpy(m_preferred_user_path, args.option_argument());
 
 				break;
 			}
@@ -265,7 +251,7 @@ bool Device::ParseCommandLine(int argc, char** argv)
 					return false;
 				}
 
-				mPreferredWindowWidth = atoi(args.option_argument());
+				m_preferred_window_width = atoi(args.option_argument());
 				break;
 			}
 			// Window height
@@ -277,7 +263,7 @@ bool Device::ParseCommandLine(int argc, char** argv)
 					return false;
 				}
 
-				mPreferredWindowHeight = atoi(args.option_argument());
+				m_preferred_window_height = atoi(args.option_argument());
 				break;
 			}
 			default:
@@ -291,7 +277,7 @@ bool Device::ParseCommandLine(int argc, char** argv)
 }
 
 //-----------------------------------------------------------------------------
-void Device::PrintHelpMessage()
+void Device::print_help_message()
 {
 	os::printf("Usage: crown [options]\n");
 	os::printf("Options:\n\n");

src/Device.h

@@ -34,32 +34,31 @@ namespace crown
 class Renderer;
 class InputManager;
 
-/**
-	Device.
-*/
+/// The Engine.
 class Device
 {
-
 public:
 
 							Device();
 							~Device();
 
-	Renderer*				GetRenderer();
+	bool					init(int argc, char** argv);
+	void					shutdown();
+
+	bool					is_running() const;
+	bool					is_init() const;
+
+	void					start();
+	void					stop();
 
-	void					StartRunning();
-	void					StopRunning();
-	bool					IsRunning() const;
-	bool					IsInit();
-	void					Frame();
+	void					frame();
 
-	bool					Init(int argc, char** argv);
-	void					Shutdown();
+	Renderer*				renderer();
 
 private:
 
-	bool					ParseCommandLine(int argc, char** argv);
-	void					PrintHelpMessage();
+	bool					parse_command_line(int argc, char** argv);
+	void					print_help_message();
 
 private:
 
@@ -67,16 +66,21 @@ private:
 	static const uint16_t	CROWN_MINOR;
 	static const uint16_t	CROWN_MICRO;
 
-	int32_t					mPreferredWindowWidth;
-	int32_t					mPreferredWindowHeight;
-	bool					mPreferredWindowFullscreen;
-	char					mPreferredRootPath[512];
-	char					mPreferredUserPath[512];
+private:
+
+	// Preferred settings from command line
+	int32_t					m_preferred_window_width;
+	int32_t					m_preferred_window_height;
+	bool					m_preferred_window_fullscreen;
+
+	char					m_preferred_root_path[512];
+	char					m_preferred_user_path[512];
 
-	bool					mIsInit		: 1;
-	bool					mIsRunning	: 1;
+	bool					m_is_init		: 1;
+	bool					m_is_running	: 1;
 
-	Renderer*				mRenderer;
+	// Subsystems
+	Renderer*				m_renderer;
 
 private:
 

src/Terrain.cpp

@@ -280,7 +280,7 @@ uint32_t Terrain::SnapToGrid(const Vec3& vertex)
 
 void Terrain::Render()
 {
-	Renderer* renderer = GetDevice()->GetRenderer();
+	Renderer* renderer = GetDevice()->renderer();
 
 	renderer->render_triangles(
 				mVertices[0].to_float_ptr(),

src/TextureResource.cpp

@@ -42,7 +42,7 @@ void TextureResource::online(TextureResource* texture)
 {
 	assert(texture != NULL);
 
-	texture->m_render_texture = GetDevice()->GetRenderer()->load_texture(texture);
+	texture->m_render_texture = GetDevice()->renderer()->load_texture(texture);
 }
 
 //-----------------------------------------------------------------------------