added dev/MinGfx/

1 files changed, 256 insertions, 0 deletions

diff --git a/dev/MinGfx/src/unicam.h b/dev/MinGfx/src/unicam.h
new file mode 100644
index 0000000..999232b
--- /dev/null
+++ b/dev/MinGfx/src/unicam.h
@@ -0,0 +1,256 @@
+/*
+ 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_UNICAM_H_
+#define SRC_UNICAM_H_
+
+#include "quick_shapes.h"
+#include "point2.h"
+#include "point3.h"
+#include "vector2.h"
+#include "vector3.h"
+
+
+namespace mingfx {
+
+    
+/** This implements a user interface for controlling the camera with the mouse.
+ It is a special interface inspired by the "Unicam" technique developed by 
+ Zeleznik et al.  
+ 
+ The key feature is that this interface makes it possible to control camera pan, 
+ dolly, and rotation with only a single mouse button.  That is quite useful 
+ because it leaves the other mouse buttons free for pointing, sketching, or 
+ other interaction techniques.
+
+ The only downside of this technique is that it can take some time to learn.  In
+ order to enjoy it, you will need to read these brief instructions on how to Pan,
+ Dolly, Rotate, and Spin:
+ 
+ - Pan: Click and drag horizontally with the mouse.  Once you make an initial
+ horizontal movement you can than pan up and down as well, but the key to entering
+ pan mode is to start with a horizontal movement.
+ 
+ - Dolly: Click and drag vertically with the mouse.  The initial movement must
+ be vertical.  If you click on some object in the scene, then the speed of dollying
+ is set so that the object will come all the up to the camera lens if you drag
+ the mouse to the bottom of the screen.
+ 
+ - Rotate: Start with a quick click and release to set the center of rotation.  
+ This is most useful if you click on some object in the scene.  You will see a
+ black dot appear to mark the center of rotation.  If you click on the background
+ then a center of rotation will be selected for you.  It will be a point straight
+ ahead and at a depth 4.0 units away.  The depth can be adjusted for your application
+ with set_default_depth().  Once your center of rotation is established, move 
+ your mouse away a bit and then click and drag to do a trackball rotatation of
+ the scene around this point.  Come to a stop before letting go of the mouse
+ button in order to avoid entering the spin state!
+ 
+ - Spin: For some fun, try "throwing" the scene so that it continues to rotate
+ even after you let go.  To do this, start a rotation and then let go of the 
+ mouse button while your mouse is still moving.  To stop spinning just click and
+ release the mouse once to "catch" the scene.
+
+ 
+ Example usage:
+~~~
+// Create a global or member variable in your MyGraphicsApp class:
+UniCam unicam_;
+ 
+ 
+void MyGraphicsApp::OnLeftMouseDown(const Point2 &pos) {
+    Point2 mouse_xy = PixelsToNormalizedDeviceCoords(pos);
+    float mouse_z = ReadZValueAtPixel(pos);
+    unicam_.OnButtonDown(mouse_xy, mouse_z);
+}
+
+void MyGraphicsApp::OnLeftMouseDrag(const Point2 &pos, const Vector2 &delta) {
+    Point2 mouse_xy = PixelsToNormalizedDeviceCoords(pos);
+    unicam_.OnDrag(mouse_xy);
+}
+
+void MyGraphicsApp::OnLeftMouseUp(const Point2 &pos) {
+    Point2 mouse_xy = PixelsToNormalizedDeviceCoords(pos);
+    unicam_.OnButtonUp(mouse_xy);
+}
+
+void MyGraphicsApp::InitOpenGL() {
+    projMatrix_ = Matrix4::perspective(30, aspect_ratio(), 1, 20);
+    unicam_.set_view_matrix(Matrix4::lookAt(Point3(2.5,1,2.5), Point3(0,0,0), Vector3(0,1,0)););
+}
+
+void MyGraphicsApp::DrawOpenGL() {
+    // draw your scene using the view matrix from UniCam
+    Matrix4 proj_matrix = Matrix4::Perspective(60, aspect_ratio(), 0.001, 10);;
+    Matrix4 view_matrix = uniCam.view_matrix();
+    Matrix4 model_matrix = Matrix4::RotateY(to_radians(45.0));
+    quickShapes.DrawCube(model_matrix, view_matirx, proj_matrix, Color(1,1,1));
+
+    // tell unicam to draw itself (i.e., the small sphere that marks the center of
+    // rotation when in rotation mode)
+    unicam_.Draw(proj_matrix);
+}
+~~~
+*/
+class UniCam {
+public:  
+    
+    /// Creates a UniCam object with an initial view matrix = identity.
+    UniCam();
+
+    /// Creates a UniCam object with the supplied initial view matrix.
+    UniCam(const Matrix4 &initialViewMatrix);
+    
+    virtual ~UniCam();
+
+    
+    // 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.
+    
+    /// Attach this to whatever mouse button you wish, for example, call this
+    /// from within GraphicsApp::OnRightMouseDown().  If your mousePos is reported
+    /// in pixels, you will need to convert it to normalized device coordinates
+    /// before passing it on to this routine.  The depth buffer value for the
+    /// pixel under the mouse is also needed.  If you are using GraphicsApp, you
+    /// can access both of these as follows:
+    /// ~~~
+    /// Point2 mouse_xy = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
+    /// float mouse_z = ReadZValueAtPixel(mouse_in_pixels);
+    /// uniCam.OnButtonDown(mouse_xy, mouse_z);
+    /// ~~~
+    void OnButtonDown(const Point2 &normalizedMousePos, float mouseZ);
+    
+    /// Attach this to the corresponding mouse move event, for example, call this
+    /// from within GraphicsApp::OnRightMouseDrag().  If your mousePos is reported
+    /// in pixels, you will need to convert it to normalized device coordinates
+    /// before passing it on to this routine.  Within GraphicsApp, use:
+    /// ~~~
+    /// Point2 mouse_xy = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
+    /// uniCam.OnDrag(mouse_xy);
+    /// ~~~
+    void OnDrag(const Point2 &normalizedMousePos);
+    
+    /// Attach this to the corresponding button up event, for example, call this
+    /// from within GraphicsApp::OnRightMouseUp().  If your mousePos is reported
+    /// in pixels, you will need to convert it to normalized device coordinates
+    /// before passing it on to this routine.  Within GraphicsApp, use:
+    /// ~~~
+    /// Point2 mouse_xy = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
+    /// uniCam.OnButtonUp(mouse_xy);
+    /// ~~~
+    void OnButtonUp(const Point2 &normalizedMousePos);
+    
+    /// Attach this to a callback that can be used to control animation.  Within
+    /// GraphicsApp::UpdateSimulation(), use:
+    /// ~~~
+    /// uniCam.AdvanceAnimation(dt);
+    /// ~~~
+    void AdvanceAnimation(double dt);
+
+    /// Finally, attach this to your draw callback routine.  Within
+    /// GraphicsApp::DrawUsingOpenGL(), use:
+    /// ~~~
+    /// uniCam.Draw(projMatrix);
+    /// ~~~
+    void Draw(const Matrix4 &projectionMatrix);
+    
+    
+    /// Access the camera view matrix created by the UniCam 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 = unicam.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();
+    
+    
+    // -------------
+    
+    /// 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 viewMatrix);
+    
+    /// This sets the depth of the center of rotation for the case when the user's
+    /// click does not intersect any geometry.  It defaults to 4 units, but the
+    /// right value to use depends very much on the current scene.  For example,
+    /// you could set a very good value by calculating the current centroid of
+    /// your scene and the finding the depth of this point (the distance along
+    /// the look vector) relative to the camera.
+    void set_default_depth(float d);
+    
+    
+private:
+    
+    void recalc_angular_vel();
+    
+    enum class UniCamState {
+        START,
+        PAN_DOLLY_ROT_DECISION,
+        PAN_DOLLY_DECISION,
+        ROT_WAIT_FOR_SECOND_CLICK,
+        PAN,
+        DOLLY,
+        ROT,
+        SPINNING
+    };
+    UniCamState state_;
+    
+    Point2  mouseLast_;
+    double  elapsedTime_;
+
+    Point2  initialClickPos_;
+    bool    hitGeometry_;
+    Point3  hitPoint_;
+
+    bool    rotInitialized_;
+    Point3  rotLastIPoint_;
+    float   boundingSphereRad_;
+    Point3  boundingSphereCtr_;
+    double  rotLastTime_;
+    std::vector<std::pair<double, double>> rotAngularVelBuffer_;
+    double rotAngularVel_;
+    Vector3 rotAxis_;
+    
+    bool    dollyInitialized_;
+    float   dollyFactor_;
+    float   defaultDepth_;
+    
+    bool    showIcon_;
+    QuickShapes quickShapes_;
+
+    Matrix4 V_;
+    Matrix4 Vstart_;
+
+    // saved from the last draw call in order to unproject the mouse pos
+    Matrix4 Pdraw_;
+};
+
+    
+} // end namespace
+
+#endif
+
+