summaryrefslogtreecommitdiffstats
path: root/dev/MinGfx/src/craft_cam.h
diff options
context:
space:
mode:
authorunknown <paulx161@umn.edu>2021-02-03 14:22:28 -0600
committerunknown <paulx161@umn.edu>2021-02-03 14:22:28 -0600
commit9b83919815f6a6ce5d73da1c28483970d0ca5589 (patch)
tree4558864445dccc1605e5315e0bb11c46d2018da1 /dev/MinGfx/src/craft_cam.h
parentAdded worksheet and support code for assignment 2 (diff)
downloadcsci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar.gz
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar.bz2
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar.lz
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar.xz
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.tar.zst
csci4611-9b83919815f6a6ce5d73da1c28483970d0ca5589.zip
added dev/MinGfx/
Diffstat (limited to 'dev/MinGfx/src/craft_cam.h')
-rw-r--r--dev/MinGfx/src/craft_cam.h219
1 files changed, 219 insertions, 0 deletions
diff --git a/dev/MinGfx/src/craft_cam.h b/dev/MinGfx/src/craft_cam.h
new file mode 100644
index 0000000..bdfcd7e
--- /dev/null
+++ b/dev/MinGfx/src/craft_cam.h
@@ -0,0 +1,219 @@
+/*
+ This file is part of the MinGfx Project.
+
+ Copyright (c) 2017,2018 Regents of the University of Minnesota.
+ All Rights Reserved.
+
+ Original Author(s) of this File:
+ Dan Keefe, 2018, University of Minnesota
+
+ Author(s) of Significant Updates/Modifications to the File:
+ ...
+ */
+
+#ifndef SRC_CRAFT_CAM_H_
+#define SRC_CRAFT_CAM_H_
+
+#include "point2.h"
+#include "matrix4.h"
+#include "vector2.h"
+
+
+namespace mingfx {
+
+
+/** This implements a user interface for controlling the camera with the mouse.
+ This interface is appropriate for "first person" camera control, as in games
+ like Minecraft.
+
+ Use the arrow keys or A,S,W,Z keys to move around in the virtual world.
+ UP/DOWN and W/Z move forward and back. LEFT/RIGHT or A/S rotate your body
+ to face left or right. You can rotate and tilt your head to look
+ left/right/up/down by moving the mouse. In Minecraft, that movement happens
+ whenever you move the mouse, regardless of whether you are holding down a
+ mouse button, but in some games you want to hold the camera still while you
+ use the mouse to draw on the screen or do something else. It's possible to
+ use this interface both ways by calling the MouseMove() function either every
+ time the mouse moves, or only when the mouse is in a dragging mode.
+
+ Example usage:
+ ~~~
+ // Create a global or member variable in your MyGraphicsApp class:
+ CraftCam cam_;
+
+
+ // If you want to always rotate the view with the mouse, use this:
+ void MyGraphicsApp::OnMouseMove(const Point2 &pos, const Vector2 &delta) {
+ Vector2 delta_ndc = PixelsToNormalizedDeviceCoords(pos);
+ cam_.OnMouseMove(delta_ndc);
+ }
+
+ // Alternatively, if you want to only rotate the view when the mouse button is
+ // held down, use this instead. Call cam_.OnMouseMove() in either one function
+ // or the other, but not both!
+ // void MyGraphicsApp::OnLeftMouseDrag(const Point2 &pos, const Vector2 &delta) {
+ // Vector2 delta_ndc = PixelsToNormalizedDeviceCoords(pos);
+ // cam_.OnMouseMove(delta_ndc);
+ // }
+
+ // This tells the camera to simulate walking based on the keyboard keys currently
+ // pressed. You need to pass a pointer to the underlying GLFW window created by
+ // GraphicsApp.
+ void MyGraphicsApp::UpdateSimulation(double dt) {
+ cam_.UpdateSimulation(dt, window());
+ }
+
+ void MyGraphicsApp::InitOpenGL() {
+ cam_.set_view_matrix(Matrix4::lookAt(Point3(0,2,2), Point3(0,2,0), Vector3(0,1,0)););
+ }
+
+ void MyGraphicsApp::DrawOpenGL() {
+ // draw your scene using the view matrix from the camera
+ Matrix4 proj_matrix = Matrix4::perspective(60, aspect_ratio(), 1, 200);
+ Matrix4 view_matrix = cam_.view_matrix();
+ Matrix4 model_matrix = Matrix4::RotateY(to_radians(45.0));
+ quick_shapes.DrawCube(model_matrix, view_matirx, proj_matrix, Color(1,1,1));
+ }
+ ~~~
+ */
+class CraftCam {
+public:
+
+ /// Creates a CraftCam object with an initial view matrix = identity.
+ CraftCam();
+
+ /// Creates a CraftCam object with the supplied initial view matrix.
+ CraftCam(const Matrix4 &initial_view_matrix);
+
+ virtual ~CraftCam();
+
+
+ // To make the interaction work, the following set of functions need to be
+ // called from your GraphicsApp or whatever main application class you use
+ // to receive user input events and a draw callback.
+
+ /// Call this from your app's UpdateSimulation() method. This tells the
+ /// camera to simulate walking based on the keyboard keys currently pressed.
+ /// You need to pass a pointer to the underlying GLFW window created by
+ /// GraphicsApp. Example:
+ /// ~~~
+ /// void MyGraphicsApp::UpdateSimulation(double dt) {
+ /// cam_.UpdateSimulation(dt, window());
+ /// }
+ /// ~~~
+ void UpdateSimulation(double dt, GLFWwindow *window_ptr);
+
+
+ /// Call this from your app's OnMouseMove() or On*MouseDrag() method. Use
+ /// OnMouseMove() if you want to always rotate the view with the mouse.
+ /// Remember to convert the mouse coordinates (usually reported by window
+ /// managers in pixels) into normalized device coordinates:
+ /// ~~~
+ /// void MyGraphicsApp::OnMouseMove(const Point2 &pos, const Vector2 &delta) {
+ /// Vector2 delta_ndc = PixelsToNormalizedDeviceCoords(pos);
+ /// cam_.OnMouseMove(delta_ndc);
+ /// }
+ /// ~~~
+ /// Alternatively, if you want to only rotate the view when the mouse button is
+ /// held down, use On*MouseDrag() instead:
+ /// ~~~
+ /// void MyGraphicsApp::OnLeftMouseDrag(const Point2 &pos, const Vector2 &delta) {
+ /// Vector2 delta_ndc = PixelsToNormalizedDeviceCoords(pos);
+ /// cam_.OnMouseMove(delta_ndc);
+ /// }
+ /// ~~~
+ void OnMouseMove(const Vector2 &normalized_mouse_delta);
+
+
+ /// Access the camera view matrix created by the CraftCam interactions via
+ /// this method and use it to draw the geometry in your scence.
+ /// For example, within GraphicsApp::DrawUsingOpenGL(), you might have:
+ /// ~~~
+ /// Matrix4 P = Matrix4::Perspective(30, aspect_ratio(), 1, 20);
+ /// Matrix4 V = cam.view_matrix();
+ /// Matrix4 M = Matrix4::RotateY(GfxMath::ToRadians(45.0));
+ /// quick_shapes.DrawCube(M, V, P, Color(1,1,1));
+ /// ~~~
+ Matrix4 view_matrix();
+
+
+ /// Returns the "eye" point (i.e., focal point) of the camera in world
+ /// space coordinates.
+ Point3 eye();
+
+ /// Returns the look direction (i.e., -Z axis of the camera matrix) in world
+ /// space coordinates.
+ Vector3 look();
+
+
+ /// Sets the y value of the camera (i.e., the height). If you want to set
+ /// the entire view matrix, then use set_view_matrix(), but if you just want
+ /// to update the height, e.g., while walking around a bumpy terrain, then
+ /// use this.
+ void UpdateHeight(float new_y_value);
+
+
+ // -------------
+
+ /// This is not required, but you may use this if you wish to set an initial
+ /// view matrix or reset the view matrix
+ void set_view_matrix(Matrix4 view_matrix);
+
+
+ /// This is the scale factor used to speed up / slow down forward/backward
+ /// translation when walking for the UP / DOWN keys. It defaults to 1.0,
+ /// smaller values will make the camera walk slower, larger values will
+ /// speed it up.
+ float translation_scale();
+
+ /// This is the scale factor used to speed up / slow down forward/backward
+ /// translation when walking for the UP / DOWN keys. It defaults to 1.0,
+ /// smaller values will make the camera walk slower, larger values will
+ /// speed it up.
+ void set_translation_scale(float s);
+
+ /// This is the scale factor used to speed up / slow down left/right
+ /// rotation when walking for the LEFT / RIGHT keys. It defaults to 1.0,
+ /// smaller values will make the camera turn slower, larger values will
+ /// speed it up.
+ float rotation_scale();
+
+ /// This is the scale factor used to speed up / slow down left/right
+ /// rotation when walking for the LEFT / RIGHT keys. It defaults to 1.0,
+ /// smaller values will make the camera turn slower, larger values will
+ /// speed it up.
+ void set_rotation_scale(float s);
+
+ /// This is the scale factor used to speed up / slow down looking around
+ /// when moving the head with the mouse. It defaults to 1.0, smaller values
+ /// will make the camera turn slower, larger values will speed it up.
+ float look_scale();
+
+ /// This is the scale factor used to speed up / slow down looking around
+ /// when moving the head with the mouse. It defaults to 1.0, smaller values
+ /// will make the camera turn slower, larger values will speed it up.
+ void set_look_scale(float s);
+
+private:
+
+ void WalkForward(double dt);
+ void WalkBackward(double dt);
+ void RotateLeft(double dt);
+ void RotateRight(double dt);
+ void LookWithMouse(const Vector2 &mouse_delta);
+
+ float t_scale_;
+ float r_scale_;
+ float l_scale_;
+ float yaw_;
+ float pitch_;
+ Matrix4 base_head_;
+ Matrix4 added_rot_;
+};
+
+
+} // end namespace
+
+#endif
+
+