chore: add camera

Author: JeremyMeissner

FreeFrame/Camera.cs

@@ -0,0 +1,119 @@
+using OpenTK.Mathematics;
+using System;
+
+namespace FreeFrame
+{
+    // This is the camera class as it could be set up after the tutorials on the website.
+    // It is important to note there are a few ways you could have set up this camera.
+    // For example, you could have also managed the player input inside the camera class,
+    // and a lot of the properties could have been made into functions.
+
+    // TL;DR: This is just one of many ways in which we could have set up the camera.
+    // Check out the web version if you don't know why we are doing a specific thing or want to know more about the code.
+    public class Camera
+    {
+        // Those vectors are directions pointing outwards from the camera to define how it rotated.
+        private Vector3 _front = -Vector3.UnitZ;
+
+        private Vector3 _up = Vector3.UnitY;
+
+        private Vector3 _right = Vector3.UnitX;
+
+        // Rotation around the X axis (radians)
+        private float _pitch;
+
+        // Rotation around the Y axis (radians)
+        private float _yaw = -MathHelper.PiOver2; // Without this, you would be started rotated 90 degrees right.
+
+        // The field of view of the camera (radians)
+        private float _fov = MathHelper.PiOver2;
+
+        public Camera(Vector3 position, float aspectRatio)
+        {
+            Position = position;
+            AspectRatio = aspectRatio;
+        }
+
+        // The position of the camera
+        public Vector3 Position { get; set; }
+
+        // This is simply the aspect ratio of the viewport, used for the projection matrix.
+        public float AspectRatio { private get; set; }
+
+        public Vector3 Front => _front;
+
+        public Vector3 Up => _up;
+
+        public Vector3 Right => _right;
+
+        // We convert from degrees to radians as soon as the property is set to improve performance.
+        public float Pitch
+        {
+            get => MathHelper.RadiansToDegrees(_pitch);
+            set
+            {
+                // We clamp the pitch value between -89 and 89 to prevent the camera from going upside down, and a bunch
+                // of weird "bugs" when you are using euler angles for rotation.
+                // If you want to read more about this you can try researching a topic called gimbal lock
+                var angle = MathHelper.Clamp(value, -89f, 89f);
+                _pitch = MathHelper.DegreesToRadians(angle);
+                UpdateVectors();
+            }
+        }
+
+        // We convert from degrees to radians as soon as the property is set to improve performance.
+        public float Yaw
+        {
+            get => MathHelper.RadiansToDegrees(_yaw);
+            set
+            {
+                _yaw = MathHelper.DegreesToRadians(value);
+                UpdateVectors();
+            }
+        }
+
+        // The field of view (FOV) is the vertical angle of the camera view.
+        // This has been discussed more in depth in a previous tutorial,
+        // but in this tutorial, you have also learned how we can use this to simulate a zoom feature.
+        // We convert from degrees to radians as soon as the property is set to improve performance.
+        public float Fov
+        {
+            get => MathHelper.RadiansToDegrees(_fov);
+            set
+            {
+                var angle = MathHelper.Clamp(value, 1f, 45f);
+                _fov = MathHelper.DegreesToRadians(angle);
+            }
+        }
+
+        // Get the view matrix using the amazing LookAt function described more in depth on the web tutorials
+        public Matrix4 GetViewMatrix()
+        {
+            return Matrix4.LookAt(Position, Position + _front, _up);
+        }
+
+        // Get the projection matrix using the same method we have used up until this point
+        public Matrix4 GetProjectionMatrix()
+        {
+            return Matrix4.CreatePerspectiveFieldOfView(_fov, AspectRatio, 0.01f, 100f);
+        }
+
+        // This function is going to update the direction vertices using some of the math learned in the web tutorials.
+        private void UpdateVectors()
+        {
+            // First, the front matrix is calculated using some basic trigonometry.
+            _front.X = MathF.Cos(_pitch) * MathF.Cos(_yaw);
+            _front.Y = MathF.Sin(_pitch);
+            _front.Z = MathF.Cos(_pitch) * MathF.Sin(_yaw);
+
+            // We need to make sure the vectors are all normalized, as otherwise we would get some funky results.
+            _front = Vector3.Normalize(_front);
+
+            // Calculate both the right and the up vector using cross product.
+            // Note that we are calculating the right from the global up; this behaviour might
+            // not be what you need for all cameras so keep this in mind if you do not want a FPS camera.
+            _right = Vector3.Normalize(Vector3.Cross(_front, Vector3.UnitY));
+            _up = Vector3.Normalize(Vector3.Cross(_right, _front));
+        }
+    }
+}

FreeFrame/Components/Shapes/SVGPolygon.cs

@@ -26,8 +26,6 @@ public SVGPolygon(XmlReader reader)
                 _points.Add((Convert.ToInt32(match.Groups[1].Value), Convert.ToInt32(match.Groups[2].Value)));
         }
 
-        public override void Draw(Vector2i clientSize) => throw new NotImplementedException();
-
         public override List<Vector2i> GetSelectablePoints()
         {
             throw new NotImplementedException();

FreeFrame/Components/Shapes/Shape.cs

@@ -43,11 +43,11 @@ public Shape()
         /// <summary>
         /// Trigge draw element through OpenGL context
         /// </summary>
-        public virtual void Draw(Vector2i clientSize)
+        public virtual void Draw(Vector2i clientSize, Camera camera)
         {
             //Console.WriteLine("Draw {0}, {1}, {2}", GetType().Name, Id, GetHashCode());
             foreach (Renderer vao in Vaos)
-                vao.Draw(clientSize, Color, this);
+                vao.Draw(clientSize, camera, Color, this);
         }
         public void DeleteObjects()
         {

FreeFrame/Renderer.cs

@@ -47,7 +47,7 @@ public Renderer(float[] vertices, uint[] indexes, PrimitiveType primitiveType, S
                 _shader = new Shader("Shaders/shader.vert", "Shaders/rectangle.frag");
             ImplementObjects(vertices, indexes);
         }
-        public void Draw(Vector2i clientSize, Color4 color)
+        public void Draw(Vector2i clientSize, Camera camera, Color4 color)
         {
             _shader.Use();
 
@@ -67,11 +67,17 @@ public void Draw(Vector2i clientSize, Color4 color)
             Matrix4 transform = Matrix4.Identity;
             _shader.SetUniformMat4(uTransformation, transform);
 
+            int uView = _shader.GetUniformLocation("u_View");
+            _shader.SetUniformMat4(uView, camera.GetViewMatrix());
+
+            int uProjection = _shader.GetUniformLocation("u_Projection");
+            _shader.SetUniformMat4(uProjection, camera.GetViewMatrix());
+
             GL.BindVertexArray(VertexArrayObjectID);
 
             GL.DrawElements(_primitiveType, _indexCount, DrawElementsType.UnsignedInt, 0);
         }
-        public void Draw(Vector2i clientSize, Color4 color, Shape shape)
+        public void Draw(Vector2i clientSize, Camera camera, Color4 color, Shape shape)
         {
             _shader.Use();
             // Applied projection matrix
@@ -90,6 +96,12 @@ public void Draw(Vector2i clientSize, Color4 color, Shape shape)
             Matrix4 rotation = Matrix4.CreateRotationZ(MathHelper.DegreesToRadians(shape.Angle));
             _shader.SetUniformMat4(uTransformation, rotation);
 
+            int uView = _shader.GetUniformLocation("u_View");
+            _shader.SetUniformMat4(uView, camera.GetViewMatrix());
+
+            int uProjection = _shader.GetUniformLocation("u_Projection");
+            _shader.SetUniformMat4(uProjection, camera.GetViewMatrix());
+
 
             Type type = shape.GetType();
             if (type == typeof(SVGCircle))

FreeFrame/Selector.cs

@@ -84,16 +84,16 @@ public static float[] AreaToFloatArray(Area area)
                 area.X, area.Y, area.X + area.Width, area.Y, area.X + area.Width, area.Y + area.Height, area.X, area.Y + area.Height // Clockwise
             };
         }
-        public void Draw(Vector2i clientSize)
+        public void Draw(Vector2i clientSize, Camera camera)
         {
             GL.Enable(EnableCap.LineSmooth);
             GL.LineWidth(3.0f);
             foreach ((Renderer vao, Area _, SelectorType type) part in _vaos)
             {
                 if (part.type == SelectorType.Edge)
-                    part.vao.Draw(clientSize, new Color4(0, 125, 200, 255));
+                    part.vao.Draw(clientSize, camera, new Color4(0, 125, 200, 255));
                 else
-                    part.vao.Draw(clientSize, new Color4(0, 125, 255, 255));
+                    part.vao.Draw(clientSize, camera, new Color4(0, 125, 255, 255));
             }
             GL.Disable(EnableCap.LineSmooth);
 

FreeFrame/Shaders/shader.vert

@@ -4,8 +4,11 @@ layout(location = 0) in vec2 position;
 
 uniform mat4 u_Model_To_NDC;
 uniform mat4 u_Transformation;
+uniform mat4 u_View;
+uniform mat4 u_Projection;
+
 
 void main()
 {
-	gl_Position = u_Transformation * (u_Model_To_NDC * vec4(position,1.0, 1.0));
+	gl_Position = u_Transformation * (u_Model_To_NDC * vec4(position,1.0, 1.0)); // * u_View * u_Projection);
 }

FreeFrame/Window.cs

@@ -24,7 +24,8 @@ enum UserMode
         {
             Idle,
             Edit,
-            Create
+            Create,
+            Move
         }
         enum CreateMode
         {
@@ -42,10 +43,12 @@ enum CreateMode
         int _ioTimeline;
         bool _ioIsLoop;
         bool _ioIsReverse;
+        private Camera _camera;
         bool _dialogFilePicker = false;
         bool _dialogCompatibility = false;
 
         Vector2i _mouseOriginalState;
+        Vector3i _cameraOriginalState;
 
         SortedDictionary<int, List<Shape>> _timeline;
 
@@ -81,11 +84,14 @@ protected override void OnLoad()
             _selector = new Selector();
 
             _mouseOriginalState = new Vector2i(0, 0);
+            _cameraOriginalState = new Vector3i(0, 0, 0);
 
             _timeline = new SortedDictionary<int, List<Shape>>();
 
             _ImGuiController = new ImGuiController(ClientSize.X, ClientSize.Y);
 
+            _camera = new Camera(Vector3.UnitZ * 3, Size.X / (float)Size.Y);
+
             _ioIsLoop = false;
             _ioIsReverse = false;
 
@@ -99,6 +105,8 @@ protected override void OnResize(ResizeEventArgs e)
             GL.Viewport(0, 0, ClientSize.X, ClientSize.Y);
 
             _ImGuiController.WindowResized(ClientSize.X, ClientSize.Y);
+
+            _camera.AspectRatio = Size.X / (float)Size.Y; // TODO: Why not ClientSize
         }
         /// <summary>
         /// Triggered at a fixed interval. (Logic, etc.)
@@ -142,6 +150,16 @@ protected override void OnRenderFrame(FrameEventArgs e)
                 //    _selectedShape.ImplementObject(); // Reset VAOS for selected shape
             }
 
+            if (KeyboardState.IsKeyPressed(Keys.Right))
+            {
+                _camera.Position += Vector3.Normalize(Vector3.Cross(_camera.Front, _camera.Up)) * 2;
+            }
+
+            //if (KeyboardState.IsKeyDown(Keys.Space))
+            //    _userMode = UserMode.Move;
+            //else if (KeyboardState.WasKeyDown(Keys.Space) && KeyboardState.IsKeyDown(Keys.Space) == false)
+            //    _userMode = UserMode.Idle;
+
             if (KeyboardState.IsKeyDown(Keys.Escape))
                 ResetSelection();
 
@@ -168,15 +186,14 @@ protected override void OnRenderFrame(FrameEventArgs e)
                     _selectedShape = shape;
                 }
             }
-
+            // Change to ButtonPressed instead of was and is
             if (MouseState.WasButtonDown(MouseButton.Left) == false && MouseState.IsButtonDown(MouseButton.Left) == true) // First left click
                 OnLeftMouseDown();
             else if (MouseState.WasButtonDown(MouseButton.Left) == true && MouseState.IsButtonDown(MouseButton.Left) == true) // Long left click
                 OnLeftMouseEnter();
             else if (MouseState.WasButtonDown(MouseButton.Left) == true && MouseState.IsButtonDown(MouseButton.Left) == false) // Release left click
                 OnLeftMouseUp();
 
-
             //GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
             foreach (Shape shape in _shapes)
             {
@@ -186,7 +203,7 @@ protected override void OnRenderFrame(FrameEventArgs e)
 
                 //shape.ImplementObject(); // Reset VAOs
                 //shape.ImplementObject();
-                shape.Draw(ClientSize);
+                shape.Draw(ClientSize, _camera);
             }
 
             if (_selectedShape != null)
@@ -240,10 +257,11 @@ protected override void OnRenderFrame(FrameEventArgs e)
             switch (_userMode)
             {
                 case UserMode.Edit:
-                    _selector.Draw(ClientSize); // Only draw selector on edit mode
+                    _selector.Draw(ClientSize, _camera); // Only draw selector on edit mode
                     break;
                 case UserMode.Create:
                     break;
+                case UserMode.Move:
                 case UserMode.Idle:
                 default:
                     break;
@@ -381,6 +399,18 @@ public void OnLeftMouseDown()
                     }
                     break;
                 case UserMode.Create:
+                case UserMode.Move:
+                    //if (ImGui.GetIO().WantCaptureMouse == false) // If it's not ImGui click
+                    //{
+                    //    _mouseOriginalState.X = (int)MouseState.X;
+                    //    _mouseOriginalState.Y = (int)MouseState.Y;
+
+                    //    _cameraOriginalState.X = (int)_camera.Position.X;
+                    //    _cameraOriginalState.Y = (int)_camera.Position.Y;
+                    //    _cameraOriginalState.Z = (int)_camera.Position.Z;
+
+                    //}
+                    //break;
                 default:
                     break;
             }
@@ -464,6 +494,9 @@ public void OnLeftMouseEnter() // TODO: Rename this
                         }
                     }
                     break;
+                case UserMode.Move:
+                    //_camera.Position = new Vector3(_cameraOriginalState.X + (-MouseState.X / Size.X) - (-_mouseOriginalState.X / Size.X), _cameraOriginalState.Y + (MouseState.Y / Size.Y) - (_mouseOriginalState.Y / Size.Y), _camera.Position.Z);
+                    break;
                 case UserMode.Idle:
                 default:
                     break;
@@ -561,6 +594,13 @@ public void ShowUIDebug()
             }
             ImGui.End();
         }
+
+        protected override void OnMouseWheel(MouseWheelEventArgs e)
+        {
+            base.OnMouseWheel(e);
+            //Console.WriteLine(_camera.Position.Z);
+            _camera.Position = new Vector3(_camera.Position.X, _camera.Position.Y, _camera.Position.Z + (1f * -e.OffsetY)); // TODO: Smooth the scroll when close
+        }
         public int LinearInterpolate(int x, int x1, int x2, int y1, int y2)
         {
             float y;