Fix naming conventions in RotateCamera

framework/include/rotate_camera.hpp

@@ -13,52 +13,54 @@ class RotateCamera
   private:
 	/// Constants that defines the behaviour of the camera
 	///		- Minimum elevation in radians
-	static const float min_elevation;
+	static const float minElevation;
 	///		- Maximum elevation in radians
-	static const float max_elevation;
+	static const float maxElevation;
 	///		- Minimum distance from the point of interest
-	static const float min_distance;
+	static const float minDistance;
 	///		- Sensitivity of the mouse when changing elevation or direction angles
-	static const float angle_sensitivity;
+	static const float angleSensitivity;
 	///		- Sensitivity of the mouse when changing zoom
-	static const float zoom_sensitivity;
+	static const float zoomSensitivity;
 
 	/// angle_direction is an angle in which determines into which direction in xz plane I look.
 	///		- 0 degrees .. I look in -z direction
 	///		- 90 degrees .. I look in -x direction
 	///		- 180 degrees .. I look in +z direction
 	///		- 270 degrees .. I look in +x direction
-	float angle_direction;
+	float angleDirection;
 
 	/// angle_direction is an angle in which determines from which "height" I look.
 	///		- positive elevation .. I look from above the xz plane
 	///		- negative elevation .. I look from below the xz plane
-	float angle_elevation;
+	float angleElevation;
 
 	/// Distance from (0,0,0), the point at which I look
 	float distance;
 
 	/// Final position of the eye in world space coordinates, for LookAt or shaders
-	glm::vec3 eye_position;
+	glm::vec3 eyePosition;
 
 	/// Last X and Y coordinates of the mouse cursor
-	int last_x, last_y;
+	int lastX, lastY;
 
 	/// True or false if moused buttons are pressed and the user rotates/zooms the camera
-	bool is_rotating, is_zooming;
+	bool isRotating, isZooming;
 
 	/// Recomputes 'eye_position' from 'angle_direction', 'angle_elevation', and 'distance'
-	void update_eye_pos();
+	void updateEyePos();
 
   public:
 	RotateCamera();
 
 	/// Call when the user presses or releases a mouse button (see glfwSetMouseButtonCallback)
-	void on_mouse_button(int button, int action, int mods);
+	void onMouseButton(int button, int action, int mods);
 
 	/// Call when the user moves with the mouse cursor (see glfwSetCursorPosCallback)
-	void on_mouse_move(double x, double y);
+	void onMouseMove(double x, double y);
 
 	/// Returns the position of the eye in world space coordinates
-	glm::vec3 get_eye_position() const;
+	glm::vec3 getEyePosition() const {
+		return eyePosition;
+	}
 };

framework/src/rotate_camera.cpp

@@ -2,74 +2,69 @@
 
 #include <GLFW/glfw3.h>
 
-const float RotateCamera::min_elevation = -1.5f;
-const float RotateCamera::max_elevation = 1.5f;
-const float RotateCamera::min_distance = 1.0f;
-const float RotateCamera::angle_sensitivity = 0.008f;
-const float RotateCamera::zoom_sensitivity = 0.003f;
+const float RotateCamera::minElevation = -1.5f;
+const float RotateCamera::maxElevation = 1.5f;
+const float RotateCamera::minDistance = 1.0f;
+const float RotateCamera::angleSensitivity = 0.008f;
+const float RotateCamera::zoomSensitivity = 0.003f;
 
 RotateCamera::RotateCamera()
-    : angle_direction(0.0f), angle_elevation(0.785398163f), distance(15.0f), last_x(0), last_y(0), is_rotating(false),
-      is_zooming(false)
+    : angleDirection(0.0f), angleElevation(0.785398163f), distance(15.0f), lastX(0), lastY(0), isRotating(false),
+      isZooming(false)
 {
-	update_eye_pos();
+	updateEyePos();
 }
 
-void RotateCamera::update_eye_pos()
+void RotateCamera::updateEyePos()
 {
-	eye_position.x = distance * cosf(angle_elevation) * -sinf(angle_direction);
-	eye_position.y = distance * sinf(angle_elevation);
-	eye_position.z = distance * cosf(angle_elevation) * cosf(angle_direction);
+	eyePosition.x = distance * cosf(angleElevation) * -sinf(angleDirection);
+	eyePosition.y = distance * sinf(angleElevation);
+	eyePosition.z = distance * cosf(angleElevation) * cosf(angleDirection);
 }
 
-void RotateCamera::on_mouse_button(int button, int action, int mods)
+void RotateCamera::onMouseButton(int button, int action, int mods)
 {
 	// Left mouse button affects the angles
 	if (button == GLFW_MOUSE_BUTTON_LEFT) {
 		if (action == GLFW_PRESS) {
-			is_rotating = true;
+			isRotating = true;
 		} else {
-			is_rotating = false;
+			isRotating = false;
 		}
 	}
 	// Right mouse button affects the zoom
 	if (button == GLFW_MOUSE_BUTTON_RIGHT) {
 		if (action == GLFW_PRESS) {
-			is_zooming = true;
+			isZooming = true;
 		} else {
-			is_zooming = false;
+			isZooming = false;
 		}
 	}
 }
 
-void RotateCamera::on_mouse_move(double x, double y)
+void RotateCamera::onMouseMove(double x, double y)
 {
-	float dx = float(x - last_x);
-	float dy = float(y - last_y);
-	last_x = static_cast<int>(x);
-	last_y = static_cast<int>(y);
+	float dx = float(x - lastX);
+	float dy = float(y - lastY);
+	lastX = static_cast<int>(x);
+	lastY = static_cast<int>(y);
 
-	if (is_rotating) {
-		angle_direction += dx * angle_sensitivity;
-		angle_elevation += dy * angle_sensitivity;
+	if (isRotating) {
+		angleDirection += dx * angleSensitivity;
+		angleElevation += dy * angleSensitivity;
 
 		// Clamp the results
-		if (angle_elevation > max_elevation)
-			angle_elevation = max_elevation;
-		if (angle_elevation < min_elevation)
-			angle_elevation = min_elevation;
+		if (angleElevation > maxElevation)
+			angleElevation = maxElevation;
+		if (angleElevation < minElevation)
+			angleElevation = minElevation;
 	}
-	if (is_zooming) {
-		distance *= (1.0f + dy * zoom_sensitivity);
+	if (isZooming) {
+		distance *= (1.0f + dy * zoomSensitivity);
 
 		// Clamp the results
-		if (distance < min_distance)
-			distance = min_distance;
+		if (distance < minDistance)
+			distance = minDistance;
 	}
-	update_eye_pos();
-}
-
-glm::vec3 RotateCamera::get_eye_position() const
-{
-	return eye_position;
+	updateEyePos();
 }

src/application.cpp

@@ -4,9 +4,9 @@ Application::Application(size_t initialWidth, size_t initialHeight) {
 	this->width = initialWidth;
 	this->height = initialHeight;
 
-	cameraUbo.position = glm::vec4(camera.get_eye_position(), 1.0f);
+	cameraUbo.position = glm::vec4(camera.getEyePosition(), 1.0f);
 	cameraUbo.projection = glm::perspective(glm::radians(45.0f), float(width) / float(height), 0.01f, 1000.0f);
-	cameraUbo.view = glm::lookAt(camera.get_eye_position(), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+	cameraUbo.view = glm::lookAt(camera.getEyePosition(), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
 
 	LightUBO directionalLight;
 	directionalLight.position = glm::vec4(1.0f, 1.0f, 1.0f, 0.0f);
@@ -92,9 +92,9 @@ void Application::render() {
 	// Camera
 	glm::vec3 cameraPosition;
 	if (followedProbe) {
-		cameraPosition = glm::vec3(*followedProbe * glm::vec4(camera.get_eye_position(), 1.0f));
+		cameraPosition = glm::vec3(*followedProbe * glm::vec4(camera.getEyePosition(), 1.0f));
 	} else {
-		cameraPosition = camera.get_eye_position();
+		cameraPosition = camera.getEyePosition();
 	}
 	cameraUbo.position = glm::vec4(cameraPosition, 1.0f);
 	cameraUbo.view = glm::lookAt(cameraPosition, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
@@ -197,10 +197,10 @@ void Application::onResize(GLFWwindow *window, int width, int height) {
 	//glNamedFramebufferTexture(postprocessFramebuffer, GL_DEPTH_ATTACHMENT, postprocessFramebufferDepth, 0);
 }
 void Application::onMouseMove(GLFWwindow *window, double x, double y) {
-	camera.on_mouse_move(x, y);
+	camera.onMouseMove(x, y);
 }
 void Application::onMousePressed(GLFWwindow *window, int button, int action, int mods) {
-	camera.on_mouse_button(button, action, mods);
+	camera.onMouseButton(button, action, mods);
 }
 void Application::onKeyPressed(GLFWwindow *window, int key, int scancode, int action, int mods) {
 	switch (key) {