simple zoom

diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index b2ef9161287b5cf77e30ca188386174f116d1390..9ebc2613d7d24a93be4fca69ddc66c200d16a13d 100644 (file)
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -87,6 +87,12 @@ void Application::OnKeyDown(const SDL_KeyboardEvent &e) {
                case SDLK_d:
                        control.x += 1;
                        break;
+               case SDLK_z:
+                       cam.DoubleZoom();
+                       break;
+               case SDLK_x:
+                       cam.HalfZoom();
+                       break;
                default:
                        break;
        }
@@ -127,6 +133,7 @@ void Application::OnKeyUp(const SDL_KeyboardEvent &e) {
 void Application::Update(int dt) {
        const float delta = dt / 1e3;
        controlled->acc = Vector<float>(control * 10);
+       cam.Update(delta);
        univ.Update(delta);
        focus.Update(delta);
 }
@@ -140,17 +147,17 @@ void Application::Render() {
        constexpr Color focusColor(0xFA, 0xFA, 0x00);
 
        SDL_Surface *dst = screen.Screen();
-       const Vector<int> begin = cam.Offset();
+       const Vector<int> begin = cam.ToScreen(Vector<float>(0, 0));
        const Vector<int> end =
-               begin + (univ.size * univ.secSize * univ.areaSize) + Vector<int>(1, 1);
+               cam.ToScreen((univ.size * univ.secSize * univ.areaSize)) + Vector<int>(1, 1);;
 
        Fill(dst, background);
-       Grid(dst, begin, end, univ.areaSize, secGrid);
-       Grid(dst, begin, end, univ.secSize * univ.areaSize, univGrid);
-       Cross(dst, begin + Vector<int>(focus.Pos()), 15, focusColor);
+       Grid(dst, begin, end, cam.ToScale(univ.areaSize), secGrid);
+       Grid(dst, begin, end, cam.ToScale(univ.secSize * univ.areaSize), univGrid);
+       Cross(dst, cam.ToScreen(focus.Pos()), 15, focusColor);
 
        for (const Entity &e : univ.Entities()) {
-               Cross(dst, begin + (e.area * univ.areaSize) + Vector<int>(e.pos), 10, entityColor);
+               Cross(dst, cam.ToScreen((e.area * univ.areaSize) + Vector<int>(e.pos)), 10, entityColor);
        }
 }
 

diff --git a/src/graphics/Camera.cpp b/src/graphics/Camera.cpp
index 0994a5ab8f0dd9cebe25f54dbdf46fbbf7c36bfd..a72157a9ccc15c2e02d54929812b876a257fa249 100644 (file)
--- a/src/graphics/Camera.cpp
+++ b/src/graphics/Camera.cpp
@@ -5,7 +5,8 @@ namespace space {
 
 Camera::Camera(int w, int h, const Vector<float> &t)
 : target(&t)
-, offset(w/2, h/2) {
+, offset(w/2, h/2)
+, zoom(0) {
 
 }
 
@@ -14,4 +15,16 @@ void Camera::Resize(int w, int h) {
        offset = Vector<float>(w/2, h/2);
 }
 
+void Camera::Update(float delta) {
+
+}
+
+void Camera::DoubleZoom() {
+       zoom += 1;
+}
+
+void Camera::HalfZoom() {
+       zoom -= 1;
+}
+
 }

diff --git a/src/graphics/Camera.h b/src/graphics/Camera.h
index 10699f097e2f5e6d9ca38892bd5d78a3aa5bff7e..e40b051bc64d78c18479fdbcac6f276049a0e830 100644 (file)
--- a/src/graphics/Camera.h
+++ b/src/graphics/Camera.h
@@ -12,16 +12,37 @@ public:
        Camera(int w, int h, const Vector<float> &);
 
 public:
+       void SetTarget(const Vector<float> &t) { target = &t; }
+       void SetZoom(float z) { zoom = z; }
+
        void Resize(int w, int h);
+       void Update(float deltaT);
+
+       void DoubleZoom();
+       void HalfZoom();
 
-       Vector<float> Offset() {
-               return -(*target - offset);
+       Vector<int> ToScreen(Vector<float> v) const {
+               return Vector<int>(OffsetOf(v));
+       }
+       Vector<float> OffsetOf(Vector<float> v) const {
+               return ToScale(v - *target) + offset;
+       }
+       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);
+               }
        }
 
 private:
        const Vector<float> *target;
        Vector<float> offset;
 
+       int zoom;
+
 };
 
 }

diff --git a/src/graphics/primitive.cpp b/src/graphics/primitive.cpp
index c97345a63ac0380f79f0879b8fbeda23a2bc4ffb..1a68d45a9a8a16acfcd5843af60fce1242f35119 100644 (file)
--- a/src/graphics/primitive.cpp
+++ b/src/graphics/primitive.cpp
@@ -128,4 +128,40 @@ void Grid(
        }
 }
 
+void Grid(
+               SDL_Surface *dst,
+               Vector<int> first,
+               Vector<int> second,
+               Vector<float> size,
+               Color color) {
+       Uint32 c = color.MapRGBA(dst);
+
+       Vector<int> from = min(first, second);
+       Vector<int> to = max(first, second);
+
+       if (size.x <= 1 || size.y <= 1) {
+               FillRect(dst, from, to - from, c);
+               return;
+       }
+
+       if (from.x > dst->w || from.y > dst->h || to.x < 0 || to.y < 0) {
+               return;
+       }
+
+       while (from.x < -size.x) from.x += size.x;
+       while (from.y < -size.y) from.y += size.y;
+       while (to.x > dst->w + size.x) to.x -= size.x;
+       while (to.y > dst->h + size.y) to.y -= size.y;
+
+       float width = to.x - from.x;
+       float height = to.y - from.y;
+
+       for (Vector<float> pos(from); pos.x <= to.x; pos.x += size.x) {
+               VLine(dst, pos, height, c);
+       }
+       for (Vector<float> pos(from); pos.y <= to.y; pos.y += size.y) {
+               HLine(dst, pos, width, c);
+       }
+}
+
 }

diff --git a/src/graphics/primitive.h b/src/graphics/primitive.h
index 133e1f9fc17882ec0f2549c1d8ebe4d6aeba3a2d..77267008db520334ffd0e11048c881c2e06a0101 100644 (file)
--- a/src/graphics/primitive.h
+++ b/src/graphics/primitive.h
@@ -34,6 +34,12 @@ void Grid(
        Vector<int> to,
        Vector<int> size,
        Color);
+void Grid(
+       SDL_Surface *,
+       Vector<int> from,
+       Vector<int> to,
+       Vector<float> size,
+       Color);
 
 }
 

diff --git a/src/math/Vector.h b/src/math/Vector.h
index 57159bff2e0e01193e4a8ea16952eace97e9e4b7..b5c6d7d11dd9f9452c0a65b781a511b8fa9603ad 100644 (file)
--- a/src/math/Vector.h
+++ b/src/math/Vector.h
@@ -2,6 +2,7 @@
 #define SPACE_VECTOR_H_
 
 #include <algorithm>
+#include <ostream>
 
 
 namespace space {
@@ -66,6 +67,37 @@ constexpr Vector<Scalar> operator *(Vector<Scalar> lhs, Vector<Scalar> rhs) {
        return Vector<Scalar>(lhs.x * rhs.x, lhs.y * rhs.y);
 }
 
+
+template<class Scalar>
+constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Scalar rhs) {
+       return Vector<Scalar>(lhs.x / rhs, lhs.y / rhs);
+}
+
+template<class Scalar>
+constexpr Vector<Scalar> operator /(Scalar lhs, Vector<Scalar> rhs) {
+       return rhs / lhs;
+}
+template<class Scalar>
+constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Vector<Scalar> rhs) {
+       return Vector<Scalar>(lhs.x / rhs.x, lhs.y / rhs.y);
+}
+
+
+template<class Scalar>
+constexpr bool operator ==(Vector<Scalar> lhs, Vector<Scalar> rhs) {
+       return lhs.x == rhs.x && lhs.y == rhs.y;
+}
+template<class Scalar>
+constexpr bool operator !=(Vector<Scalar> lhs, Vector<Scalar> rhs) {
+       return lhs.x != rhs.x && lhs.y != rhs.y;
+}
+
+
+template<class Scalar>
+inline std::ostream &operator <<(std::ostream &out, Vector<Scalar> v) {
+       return out << '<' << v.x << ',' << v.y << '>';
+}
+
 }