code convention changes

src/Device.cpp

@@ -172,7 +172,7 @@ void Device::Frame()
 {
 	os::event_loop();
 
-	GetInputManager()->EventLoop();
+	get_input_manager()->event_loop();
 
 		mRenderer->_BeginFrame();
 		mRenderer->_EndFrame();

src/MovableCamera.cpp

@@ -41,13 +41,13 @@ MovableCamera::MovableCamera(const Vec3& position, bool visible, float fov, floa
 	mDownPressed(false),
 	mLeftPressed(false)
 {
-	GetInputManager()->RegisterKeyboardListener(this);
+	get_input_manager()->register_keyboard_listener(this);
 
 	mRotFactor = Vec2(0.0f, 0.0f);
 	mAngleX = 0.0f;
 	mAngleY = 0.0f;
 
-	GetInputManager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
 }
 
 MovableCamera::~MovableCamera()
@@ -62,7 +62,7 @@ float MovableCamera::GetMouseSensibility() const
 void MovableCamera::SetActive(bool active)
 {
 	Camera::SetActive(active);
-	GetInputManager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
 }
 
 void MovableCamera::SetMouseSensibility(float sensibility)
@@ -204,9 +204,9 @@ void MovableCamera::StrafeRight()
 
 void MovableCamera::SetViewByMouse()
 {
-	static Vec2 lastPos = GetInputManager()->get_cursor_relative_xy();
-	Vec2 currentPos = GetInputManager()->get_cursor_relative_xy();
-	GetInputManager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+	static Vec2 lastPos = get_input_manager()->get_cursor_relative_xy();
+	Vec2 currentPos = get_input_manager()->get_cursor_relative_xy();
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
 
 	if (lastPos == currentPos)
 	{
@@ -215,8 +215,8 @@ void MovableCamera::SetViewByMouse()
 
 	Vec2 delta = lastPos - currentPos;
 
-	GetInputManager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
-	lastPos = GetInputManager()->get_cursor_relative_xy();
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+	lastPos = get_input_manager()->get_cursor_relative_xy();
 
 	mAngleX += delta.y * mMouseSensibility;
 	mAngleY += delta.x * mMouseSensibility;

src/input/EventDispatcher.cpp

@@ -31,9 +31,9 @@ namespace crown
 
 //-----------------------------------------------------------------------------
 EventDispatcher::EventDispatcher() :
-	mMouseListenerList(get_default_allocator()),
-	mKeyboardListenerList(get_default_allocator()),
-	mTouchListenerList(get_default_allocator()),
+	m_mouse_listener_list(get_default_allocator()),
+	m_keyboard_listener_list(get_default_allocator()),
+	m_touch_listener_list(get_default_allocator()),
 	m_acc_listener_list(get_default_allocator())
 {
 }
@@ -44,116 +44,116 @@ EventDispatcher::~EventDispatcher()
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::AddMouseListener(MouseListener* listener)
+void EventDispatcher::add_mouse_listener(MouseListener* listener)
 {
 	assert(listener != NULL);
 
-	mMouseListenerList.push_back(listener);
+	m_mouse_listener_list.push_back(listener);
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::AddKeyboardListener(KeyboardListener* listener)
+void EventDispatcher::add_keyboard_listener(KeyboardListener* listener)
 {
 	assert(listener != NULL);
 
-	mKeyboardListenerList.push_back(listener);
+	m_keyboard_listener_list.push_back(listener);
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::AddTouchListener(TouchListener* listener)
+void EventDispatcher::add_touch_listener(TouchListener* listener)
 {
 	assert(listener != NULL);
 
-	mTouchListenerList.push_back(listener);
+	m_touch_listener_list.push_back(listener);
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::ButtonPressed(const MouseEvent& event)
+void EventDispatcher::button_pressed(const MouseEvent& event)
 {
-	for (uint32_t i = 0; i < mMouseListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_mouse_listener_list.size(); i++)
 	{
-		mMouseListenerList[i]->ButtonPressed(event);
+		m_mouse_listener_list[i]->button_pressed(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::ButtonReleased(const MouseEvent& event)
+void EventDispatcher::button_released(const MouseEvent& event)
 {
-	for (uint32_t i = 0; i < mMouseListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_mouse_listener_list.size(); i++)
 	{
-		mMouseListenerList[i]->ButtonReleased(event);
+		m_mouse_listener_list[i]->button_released(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::CursorMoved(const MouseEvent& event)
+void EventDispatcher::cursor_moved(const MouseEvent& event)
 {
-	for (uint32_t i = 0; i < mMouseListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_mouse_listener_list.size(); i++)
 	{
-		mMouseListenerList[i]->CursorMoved(event);
+		m_mouse_listener_list[i]->cursor_moved(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::KeyPressed(const KeyboardEvent& event)
+void EventDispatcher::key_pressed(const KeyboardEvent& event)
 {
-	for (uint32_t i = 0; i < mKeyboardListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_keyboard_listener_list.size(); i++)
 	{
-		mKeyboardListenerList[i]->KeyPressed(event);
+		m_keyboard_listener_list[i]->key_pressed(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::KeyReleased(const KeyboardEvent& event)
+void EventDispatcher::key_released(const KeyboardEvent& event)
 {
-	for (uint32_t i = 0; i < mKeyboardListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_keyboard_listener_list.size(); i++)
 	{
-		mKeyboardListenerList[i]->KeyReleased(event);
+		m_keyboard_listener_list[i]->key_released(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::TextInput(const KeyboardEvent& event)
+void EventDispatcher::text_input(const KeyboardEvent& event)
 {
-	for (uint32_t i = 0; i < mKeyboardListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_keyboard_listener_list.size(); i++)
 	{
-		mKeyboardListenerList[i]->TextInput(event);
+		m_keyboard_listener_list[i]->text_input(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::TouchDown(const TouchEvent& event)
+void EventDispatcher::touch_down(const TouchEvent& event)
 {
-	for (uint32_t i = 0; i < mTouchListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_touch_listener_list.size(); i++)
 	{
-		mTouchListenerList[i]->TouchDown(event);
+		m_touch_listener_list[i]->touch_down(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::TouchUp(const TouchEvent& event)
+void EventDispatcher::touch_up(const TouchEvent& event)
 {
-	for (uint32_t i = 0; i < mTouchListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_touch_listener_list.size(); i++)
 	{
-		mTouchListenerList[i]->TouchUp(event);
+		m_touch_listener_list[i]->touch_up(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::TouchMove(const TouchEvent& event)
+void EventDispatcher::touch_move(const TouchEvent& event)
 {
-	for (uint32_t i = 0; i < mTouchListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_touch_listener_list.size(); i++)
 	{
-		mTouchListenerList[i]->TouchMove(event);
+		m_touch_listener_list[i]->touch_move(event);
 	}
 }
 
 //-----------------------------------------------------------------------------
-void EventDispatcher::TouchCancel(const TouchEvent& event)
+void EventDispatcher::touch_cancel(const TouchEvent& event)
 {
-	for (uint32_t i = 0; i < mTouchListenerList.size(); i++)
+	for (uint32_t i = 0; i < m_touch_listener_list.size(); i++)
 	{
-		mTouchListenerList[i]->TouchCancel(event);
+		m_touch_listener_list[i]->touch_cancel(event);
 	}
 }
 

src/input/EventDispatcher.h

@@ -39,39 +39,39 @@ class EventDispatcher
 	typedef List<MouseListener*>			MouseListenerList;
 	typedef List<KeyboardListener*>			KeyboardListenerList;
 	typedef List<TouchListener*>			TouchListenerList;
-	typedef List<AccelerometerListener*>	AccListenerList;
+	typedef List<AccelerometerListener*>	AccelerometerListenerList;
 
 public:
 
 	EventDispatcher();
 	~EventDispatcher();
 
-	void AddMouseListener(MouseListener* listener);
-	void AddKeyboardListener(KeyboardListener* listener);
-	void AddTouchListener(TouchListener* listener);
+	void add_mouse_listener(MouseListener* listener);
+	void add_keyboard_listener(KeyboardListener* listener);
+	void add_touch_listener(TouchListener* listener);
 	void add_accelerometer_listener(AccelerometerListener* listener);
 
-	void ButtonPressed(const MouseEvent&);
-	void ButtonReleased(const MouseEvent&);
-	void CursorMoved(const MouseEvent&);
+	void button_pressed(const MouseEvent&);
+	void button_released(const MouseEvent&);
+	void cursor_moved(const MouseEvent&);
 
-	void KeyPressed(const KeyboardEvent&);
-	void KeyReleased(const KeyboardEvent&);
-	void TextInput(const KeyboardEvent&);
+	void key_pressed(const KeyboardEvent&);
+	void key_released(const KeyboardEvent&);
+	void text_input(const KeyboardEvent&);
 
-	void TouchDown(const TouchEvent& event);
-	void TouchUp(const TouchEvent& event);
-	void TouchMove(const TouchEvent& event);
-	void TouchCancel(const TouchEvent& event);
+	void touch_down(const TouchEvent& event);
+	void touch_up(const TouchEvent& event);
+	void touch_move(const TouchEvent& event);
+	void touch_cancel(const TouchEvent& event);
 
 	void accelerometer_changed(const AccelerometerEvent& event);
 
 private:
 
-	MouseListenerList		mMouseListenerList;
-	KeyboardListenerList	mKeyboardListenerList;
-	TouchListenerList		mTouchListenerList;
-	AccListenerList			m_acc_listener_list;
+	MouseListenerList			m_mouse_listener_list;
+	KeyboardListenerList		m_keyboard_listener_list;
+	TouchListenerList			m_touch_listener_list;
+	AccelerometerListenerList	m_acc_listener_list;
 };
 
 } // namespace crown

src/input/InputManager.cpp

@@ -42,7 +42,7 @@ InputManager::~InputManager()
 }
 
 //-----------------------------------------------------------------------------
-void InputManager::EventLoop()
+void InputManager::event_loop()
 {
 	os::OSEvent event;
 
@@ -67,11 +67,11 @@ void InputManager::EventLoop()
 
 				if (event.type == os::OSET_BUTTON_PRESS)
 				{
-					mEventDispatcher.ButtonPressed(mouse_event);
+					m_event_dispatcher.button_pressed(mouse_event);
 				}
 				else
 				{
-					mEventDispatcher.ButtonReleased(mouse_event);
+					m_event_dispatcher.button_released(mouse_event);
 				}
 
 				break;
@@ -84,11 +84,11 @@ void InputManager::EventLoop()
 
 				if (event.type == os::OSET_KEY_PRESS)
 				{
-					mEventDispatcher.KeyPressed(keyboard_event);
+					m_event_dispatcher.key_pressed(keyboard_event);
 				}
 				else
 				{
-					mEventDispatcher.KeyReleased(keyboard_event);
+					m_event_dispatcher.key_released(keyboard_event);
 				}
 
 				break;
@@ -102,11 +102,11 @@ void InputManager::EventLoop()
 				touch_event.y = event.data_c;
 				if (event.type == os::OSET_TOUCH_DOWN)
 				{
-					mEventDispatcher.TouchDown(touch_event);
+					m_event_dispatcher.touch_down(touch_event);
 				}
 				else
 				{
-					mEventDispatcher.TouchUp(touch_event);
+					m_event_dispatcher.touch_up(touch_event);
 				}
 				break;
 			}
@@ -116,7 +116,7 @@ void InputManager::EventLoop()
 				touch_event.pointer_id = event.data_a;
 				touch_event.x = event.data_b;
 				touch_event.y = event.data_c;	
-				mEventDispatcher.TouchMove(touch_event);			
+				m_event_dispatcher.touch_move(touch_event);			
 				break;
 			}
 			case os::OSET_ACCELEROMETER:
@@ -126,7 +126,7 @@ void InputManager::EventLoop()
 				sensor_event.y = event.data_b;
 				sensor_event.z = event.data_c;
 
-				mEventDispatcher.accelerometer_changed(sensor_event);
+				m_event_dispatcher.accelerometer_changed(sensor_event);
 			}
 			default:
 			{

src/input/InputManager.h

@@ -45,40 +45,40 @@ public:
 	~InputManager();
 
 	//! Initializes the input manager.
-	void Init();
+	void init();
 
-	bool IsMouseAvailable() {}
-	bool IsKeyboardAvailable() {}
-	bool IsTouchAvailable() {}
-	bool IsAccelerometerAvailable() {}
+	bool is_mouse_available() {}
+	bool is_keyboard_available() {}
+	bool is_touch_available() {}
+	bool is_accelerometer_available() {}
 
 
-	inline void RegisterMouseListener(MouseListener* listener)
+	inline void register_mouse_listener(MouseListener* listener)
 	{
-		mEventDispatcher.AddMouseListener(listener);
+		m_event_dispatcher.add_mouse_listener(listener);
 	}
 
-	inline void RegisterKeyboardListener(KeyboardListener* listener)
+	inline void register_keyboard_listener(KeyboardListener* listener)
 	{
-		mEventDispatcher.AddKeyboardListener(listener);
+		m_event_dispatcher.add_keyboard_listener(listener);
 	}
 
-	inline void RegisterTouchListener(TouchListener* listener)
+	inline void register_touch_listener(TouchListener* listener)
 	{
-		mEventDispatcher.AddTouchListener(listener);
+		m_event_dispatcher.add_touch_listener(listener);
 	}
 
 	inline void register_accelerometer_listener(AccelerometerListener* listener)
 	{
-//		mEventDispatcher.AddAccelerometerListener(listener)
+		m_event_dispatcher.add_accelerometer_listener(listener);
 	}
 
-	inline EventDispatcher* GetEventDispatcher()
+	inline EventDispatcher* get_event_dispatcher()
 	{
-		return &mEventDispatcher;
+		return &m_event_dispatcher;
 	}
 
-	void EventLoop();
+	void event_loop();
 
 	//! Returns whether the cursor is visible.
 	bool is_cursor_visible() const;
@@ -132,12 +132,12 @@ public:
 
 private:
 
-	EventDispatcher		mEventDispatcher;
+	EventDispatcher		m_event_dispatcher;
 
 	bool				m_cursor_visible;
 };
 
-InputManager* GetInputManager();
+InputManager* get_input_manager();
 
 } // namespace crown
 

src/input/Keyboard.h

@@ -56,9 +56,9 @@ class KeyboardListener
 
 public:
 
-	virtual void KeyPressed(const KeyboardEvent& event) { (void)event; }
-	virtual void KeyReleased(const KeyboardEvent& event) { (void)event; }
-	virtual void TextInput(const KeyboardEvent& event) { (void)event; }
+	virtual void key_pressed(const KeyboardEvent& event) { (void)event; }
+	virtual void key_released(const KeyboardEvent& event) { (void)event; }
+	virtual void text_input(const KeyboardEvent& event) { (void)event; }
 };
 
 /**
@@ -72,7 +72,7 @@ public:
 	/**
 		Constructor.
 	*/
-	Keyboard() : mListener(NULL) {}
+	Keyboard() : m_listener(NULL) {}
 
 	/**
 		Destructor.
@@ -86,26 +86,26 @@ public:
 		of another key when the two are pressed in combination. (Thanks wikipedia.)
 		Crown currently supports three different modifier keys: Shift, Ctrl and Alt.
 	*/
-	virtual bool IsModifierPressed(ModifierKey modifier) const = 0;
+	virtual bool is_modifier_pressed(ModifierKey modifier) const = 0;
 
 	/**
 		Returns whether the specified key is pressed.
 	*/
-	virtual bool IsKeyPressed(KeyCode key) const = 0;
+	virtual bool is_key_pressed(KeyCode key) const = 0;
 
 	/**
 		Returns whether the specified key is released.
 	*/
-	virtual bool IsKeyReleased(KeyCode key) const = 0;
+	virtual bool is_key_released(KeyCode key) const = 0;
 
 	/**
 		Sets the listener for this device.
 	*/
-	inline void SetListener(KeyboardListener* listener) { mListener = listener; }
+	inline void set_listener(KeyboardListener* listener) { m_listener = listener; }
 
 protected:
 
-	KeyboardListener* mListener;
+	KeyboardListener* m_listener;
 };
 
 } // namespace crown

src/input/Mouse.h

@@ -50,14 +50,17 @@ struct MouseEvent
 	float wheel;
 };
 
+/**
+	Interface for managing mouse input
+*/
 class MouseListener
 {
 
 public:
 
-	virtual void ButtonPressed(const MouseEvent& event) { (void)event; }
-	virtual void ButtonReleased(const MouseEvent& event) { (void)event; }
-	virtual void CursorMoved(const MouseEvent& event) { (void)event; }
+	virtual void button_pressed(const MouseEvent& event) { (void)event; }
+	virtual void button_released(const MouseEvent& event) { (void)event; }
+	virtual void cursor_moved(const MouseEvent& event) { (void)event; }
 };
 
 } // namespace crown

src/input/Touch.h

@@ -37,15 +37,18 @@ struct TouchEvent
 	int32_t y;
 };
 
+/**
+	Interface for managing touch input device.	
+*/
 class TouchListener
 {
 
 public:
 
-	virtual void TouchDown(const TouchEvent& event) { (void)event; }
-	virtual void TouchUp(const TouchEvent& event) { (void)event; }
-	virtual void TouchMove(const TouchEvent& event) { (void)event; }
-	virtual void TouchCancel(const TouchEvent& event) { (void)event; }
+	virtual void touch_down(const TouchEvent& event) { (void)event; }
+	virtual void touch_up(const TouchEvent& event) { (void)event; }
+	virtual void touch_move(const TouchEvent& event) { (void)event; }
+	virtual void touch_cancel(const TouchEvent& event) { (void)event; }
 };
 
 /**
@@ -59,7 +62,7 @@ public:
 	/**
 		Constructor.
 	*/
-	Touch() : mListener(NULL) {}
+	Touch() : m_listener(NULL) {}
 
 	/**
 		Destructor.
@@ -71,11 +74,11 @@ public:
 	@param listener
 		The listener
 	*/
-	inline void SetListener(TouchListener* listener) { mListener = listener; }
+	inline void set_listener(TouchListener* listener) { m_listener = listener; }
 
 protected:
 
-	TouchListener* mListener;
+	TouchListener* m_listener;
 };
 
 }