Input saparated from MovableCamera and implemented in FPSSystem

src/CMakeLists.txt

@@ -21,6 +21,7 @@ set (SRC
 	Terrain.cpp
 	TextRenderer.cpp
 	World.cpp
+	FPSSystem.cpp
 )
 
 set (HEADERS
@@ -57,6 +58,7 @@ set (HEADERS
 	TextureManager.h
 	VertexBuffer.h
 	World.h
+	FPSSystem.h
 )
 
 set (CORE_SRC

src/FPSSystem.cpp

@@ -0,0 +1,151 @@
+#pragma once
+#include "InputManager.h"
+#include "MovableCamera.h"
+#include "FPSSystem.h"
+#include "Vec2.h"
+#include "Vec3.h"
+#include "Mat3.h"
+
+namespace crown
+{
+
+//-----------------------------------------------------------------------
+FPSSystem::FPSSystem() :
+	m_angle_x(0),
+	m_angle_y(0),
+	m_sensibility()
+{
+	get_input_manager()->register_keyboard_listener(this);
+	m_camera = new MovableCamera(Vec3::ZERO, true, 90.0f, 1.6f, true, 0.1, 2.5);
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+}
+
+//-----------------------------------------------------------------------
+void FPSSystem::KeyPressed(const KeyboardEvent& event)
+{
+	switch (event.key)
+	{
+		case 'w':
+		{
+			m_up_pressed = true;
+			break;
+		}
+		case 'a':
+		{
+			m_left_pressed = true;
+			break;
+		}
+		case 's':
+		{
+			m_down_pressed = true;
+			break;
+		}
+		case 'd':
+		{
+			m_right_pressed = true;
+			break;
+		}
+		default:
+		{
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------
+void FPSSystem::KeyReleased(const KeyboardEvent& event)
+{
+	switch (event.key)
+	{
+		case 'w':
+		{
+			m_up_pressed = false;
+			break;
+		}
+		case 'a':
+		{
+			m_left_pressed = false;
+			break;
+		}
+		case 's':
+		{
+			m_down_pressed = false;
+			break;
+		}
+		case 'd':
+		{
+			m_right_pressed = false;
+			break;
+		}
+		default:
+		{
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------
+void FPSSystem::set_camera_speed(const real speed)
+{
+	m_camera->SetSpeed(speed);
+}
+
+//-----------------------------------------------------------------------
+void FPSSystem::set_camera_sensibility(const real sensibility)
+{
+	m_camera->SetSensibility(sensibility);
+}
+
+//-----------------------------------------------------------------------
+void FPSSystem::camera_render()
+{
+	if (m_up_pressed)
+	{
+		m_camera->MoveForward();
+	}
+
+	if (m_left_pressed)
+	{
+		m_camera->StrafeLeft();
+	}		
+
+	if (m_down_pressed)
+	{
+		m_camera->MoveBackward();
+	}
+
+	if (m_right_pressed)
+	{
+		m_camera->StrafeRight();
+	}
+
+	m_camera->Render();
+}
+
+//-----------------------------------------------------------------------	
+void FPSSystem::set_view_by_cursor()
+{
+	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)
+	{
+		return;
+	}
+
+	Vec2 delta = lastPos - currentPos;
+
+	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
+	lastPos = get_input_manager()->get_cursor_relative_xy();
+
+	m_angle_x += delta.y * m_sensibility;
+	m_angle_y += delta.x * m_sensibility;
+
+	m_angle_x = math::clamp_to_range(-89.999f * math::DEG_TO_RAD, 89.999f * math::DEG_TO_RAD, m_angle_x);
+	m_angle_y = math::fmod(m_angle_y, math::TWO_PI);
+
+	m_camera->SetRotation(m_angle_x, m_angle_y);
+}
+
+} // namespace crown

src/FPSSystem.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "Types.h"
+#include "Camera.h"
+#include "Vec2.h"
+#include "Mouse.h"
+#include "Keyboard.h"
+#include "Touch.h"
+#include "Accelerometer.h"
+
+namespace crown
+{
+/// TODO: GameplaySystem example class
+class FPSSystem : public MouseListener, public KeyboardListener, public TouchListener, public AccelerometerListener
+{
+public:
+
+					/// Constructor
+					FPSSystem();
+
+	void			set_camera_speed(const real speed);
+	void 			set_camera_sensibility(const real sensibility);	
+	void			camera_render();
+	void			set_view_by_cursor();	
+
+	virtual void 	KeyPressed(const KeyboardEvent& event);
+	virtual void 	KeyReleased(const KeyboardEvent& event);
+
+private:
+
+	real 	m_angle_x;
+	real 	m_angle_y;
+	real	m_speed;
+	real 	m_sensibility;
+	
+	MovableCamera* m_camera;
+
+	bool m_up_pressed : 1;
+	bool m_right_pressed : 1;
+	bool m_down_pressed : 1;
+	bool m_left_pressed : 1;
+};
+
+} // namespace crown

src/MovableCamera.cpp

@@ -31,55 +31,54 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 namespace crown
 {
-
+//-----------------------------------------------------------------------
 MovableCamera::MovableCamera(const Vec3& position, bool visible, float fov, float aspect, bool active, float speed, float sensibility) :
 	Camera(position, visible, fov, aspect, active),
 	mSpeed(speed),
-	mMouseSensibility(sensibility),
-	mUpPressed(false),
-	mRightPressed(false),
-	mDownPressed(false),
-	mLeftPressed(false)
+	mSensibility(sensibility)
 {
-	get_input_manager()->register_keyboard_listener(this);
-
 	mRotFactor = Vec2(0.0f, 0.0f);
 	mAngleX = 0.0f;
 	mAngleY = 0.0f;
-
-	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
 }
 
+//-----------------------------------------------------------------------
 MovableCamera::~MovableCamera()
 {
 }
 
-float MovableCamera::GetMouseSensibility() const
+//-----------------------------------------------------------------------
+float MovableCamera::GetSensibility() const
 {
-	return mMouseSensibility;
+	return mSensibility;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::SetActive(bool active)
 {
 	Camera::SetActive(active);
 	get_input_manager()->set_cursor_relative_xy(Vec2(0.5f, 0.5f));
 }
 
-void MovableCamera::SetMouseSensibility(float sensibility)
+//-----------------------------------------------------------------------
+void MovableCamera::SetSensibility(float sensibility)
 {
-	mMouseSensibility = sensibility;
+	mSensibility = sensibility;
 }
 
+//-----------------------------------------------------------------------
 float MovableCamera::GetSpeed() const
 {
 	return mSpeed;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::SetSpeed(float speed)
 {
 	mSpeed = speed;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::Render()
 {
 	if (!mActive)
@@ -87,107 +86,27 @@ void MovableCamera::Render()
 		return;
 	}
 
-	SetViewByMouse();
-
-	if (mUpPressed)
-	{
-		MoveForward();
-		UpdateViewMatrix();
-	}
+	// FIXME 
+	// SetRotation(0, 0);
 
-	if (mRightPressed)
-	{
-		StrafeRight();
-		UpdateViewMatrix();
-	}
-
-	if (mDownPressed)
-	{
-		MoveBackward();
-		UpdateViewMatrix();
-	}
-
-	if (mLeftPressed)
-	{
-		StrafeLeft();
-		UpdateViewMatrix();
-	}
+	UpdateViewMatrix();
 
 	Camera::Render();
 }
 
-void MovableCamera::KeyPressed(const KeyboardEvent& event)
-{
-	switch (event.key)
-	{
-		case 'w':
-		{
-			mUpPressed = true;
-			break;
-		}
-		case 'a':
-		{
-			mLeftPressed = true;
-			break;
-		}
-		case 's':
-		{
-			mDownPressed = true;
-			break;
-		}
-		case 'd':
-		{
-			mRightPressed = true;
-			break;
-		}
-		default:
-		{
-			break;
-		}
-	}
-}
-
-void MovableCamera::KeyReleased(const KeyboardEvent& event)
-{
-	switch (event.key)
-	{
-		case 'w':
-		{
-			mUpPressed = false;
-			break;
-		}
-		case 'a':
-		{
-			mLeftPressed = false;
-			break;
-		}
-		case 's':
-		{
-			mDownPressed = false;
-			break;
-		}
-		case 'd':
-		{
-			mRightPressed = false;
-			break;
-		}
-		default:
-		{
-			break;
-		}
-	}
-}
-
+//-----------------------------------------------------------------------
 void MovableCamera::MoveForward()
 {
 	mPosition += mLookAt * mSpeed;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::MoveBackward()
 {
 	mPosition -= mLookAt * mSpeed;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::StrafeLeft()
 {
 	Vec3 left = mUp.cross(mLookAt);
@@ -195,6 +114,7 @@ void MovableCamera::StrafeLeft()
 	mPosition += left * mSpeed;
 }
 
+//-----------------------------------------------------------------------
 void MovableCamera::StrafeRight()
 {
 	Vec3 left = mUp.cross(mLookAt);
@@ -202,44 +122,27 @@ void MovableCamera::StrafeRight()
 	mPosition -= left * mSpeed;
 }
 
-void MovableCamera::SetViewByMouse()
+//-----------------------------------------------------------------------
+void MovableCamera::SetRotation(const real x, const real y)
 {
-	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)
-	{
-		return;
-	}
-
-	Vec2 delta = lastPos - currentPos;
-
-	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;
-
-	mAngleX = math::clamp_to_range(-89.999f * math::DEG_TO_RAD, 89.999f * math::DEG_TO_RAD, mAngleX);
-	mAngleY = math::fmod(mAngleY, math::TWO_PI);
-
 	Vec3 right(1, 0, 0);
 	Vec3 look;
 
 	look.x = 0.0f;
-	look.y = math::sin(mAngleX);
-	look.z = -math::cos(mAngleX);
+	look.y = math::sin(x);
+	look.z = -math::cos(x);
 
 	Vec3 up = right.cross(look);
 	up.normalize();
 
 	Mat3 m;
-	m.build_rotation_y(mAngleY);
+	m.build_rotation_y(y);
 	look = m * look;
 	mUp = m * up;
 
 	Camera::SetLookAt(look);
+
+	// FIXME: Terrain sample must be fixed for testing
 }
 
 } // namespace crown

src/MovableCamera.h

@@ -34,7 +34,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 namespace crown
 {
 
-class MovableCamera : public Camera, public MouseListener, public KeyboardListener
+class MovableCamera : public Camera
 {
 
 public:
@@ -46,11 +46,11 @@ public:
 	//! Destructor
 	~MovableCamera();
 
-	//! Returns the camera's mouse movement sensibility
-	float GetMouseSensibility() const;
+	//! Returns the camera's movement sensibility
+	float GetSensibility() const;
 
-	//! Sets the camera's mouse movement sensibility
-	void SetMouseSensibility(float sensibility);
+	//! Sets the camera's movement sensibility
+	void SetSensibility(float sensibility);
 
 	//! Returns the camera's speed
 	float GetSpeed() const;
@@ -63,28 +63,21 @@ public:
 	//! Loads the view matrix
 	virtual void Render();
 
-	virtual void KeyPressed(const KeyboardEvent& event);
-	virtual void KeyReleased(const KeyboardEvent& event);
-
-protected:
-
 	void MoveForward();
 	void MoveBackward();
 	void StrafeLeft();
 	void StrafeRight();
-	void SetViewByMouse();
+	void SetRotation(const real x, const real y);
+
+protected:
 
 	Vec2 mRotFactor;
 	float mAngleX;
 	float mAngleY;
 
 	float mSpeed;
-	float mMouseSensibility;
+	float mSensibility;
 
-	bool mUpPressed : 1;
-	bool mRightPressed : 1;
-	bool mDownPressed : 1;
-	bool mLeftPressed : 1;
 };
 
 } // namespace crown

src/os/android/AndroidOS.cpp

@@ -256,7 +256,10 @@ bool destroy_render_window()
 //-----------------------------------------------------------------------------
 void get_render_window_metrics(uint32_t& width, uint32_t& height)
 {
-	// not necessary
+	// TODO: must be implemented in android CrownView through JNI
+	// tmp implementation, for testing on htc desire
+	width = 480;
+	height = 800;
 }
 
 //-----------------------------------------------------------------------------