move to SDL2

[space.git] / src / graphics / Camera.h

diff --git a/src/graphics/Camera.h b/src/graphics/Camera.h
index e40b051bc64d78c18479fdbcac6f276049a0e830..815b4b047fdf1e107b3190034ac8ffe02b4a9071 100644 (file)
--- a/src/graphics/Camera.h
+++ b/src/graphics/Camera.h
@@ -1,7 +1,7 @@
 #ifndef SPACE_CAMERA_H_
 #define SPACE_CAMERA_H_
 
-#include "../math/Vector.h"
+#include "Vector.h"
 
 
 namespace space {
@@ -9,39 +9,49 @@ namespace space {
 class Camera {
 
 public:
-       Camera(int w, int h, const Vector<float> &);
+       Camera(Vector<int> size, const Vector<float> &);
 
 public:
        void SetTarget(const Vector<float> &t) { target = &t; }
        void SetZoom(float z) { zoom = z; }
 
-       void Resize(int w, int h);
+       Vector<int> ScreenSize() const { return size; }
+       float Zoom() const { return zoom; }
+
+       void Resize(int w, int h) { Resize(Vector<int>(w, h)); }
+       void Resize(Vector<int>);
        void Update(float deltaT);
 
-       void DoubleZoom();
-       void HalfZoom();
+       void StartZoom();
+       void StopZoom();
+       void StartShrink();
+       void StopShrink();
 
+       /// transform v from world coords to screen coords
        Vector<int> ToScreen(Vector<float> v) const {
-               return Vector<int>(OffsetOf(v));
-       }
-       Vector<float> OffsetOf(Vector<float> v) const {
-               return ToScale(v - *target) + offset;
+               return Vector<int>(ToScale(v - *target)) + offset;
        }
+       /// scale v to current zoom level
        Vector<float> ToScale(Vector<float> v) const {
-               if (zoom == 0) {
-                       return v;
-               } else if (zoom > 0) {
-                       return v * float(1 << zoom);
-               } else {
-                       return v / float(1 << -zoom);
-               }
+               return v * zoom;
+       }
+
+       /// transform v from screen coords to world coords
+       Vector<float> FromScreen(Vector<int> v) const {
+               return FromScale(v - offset) + *target;
+       }
+       /// scale v back from current zoom level
+       Vector<float> FromScale(Vector<float> v) const {
+               return v / zoom;
        }
 
 private:
        const Vector<float> *target;
-       Vector<float> offset;
+       Vector<int> size;
+       Vector<int> offset;
 
-       int zoom;
+       float zoom;
+       int zoomAcc;
 
 };