mod(bounce): zoom function implemented

Author: beryll1um

examples/bounce/bounce.cpp

@@ -1,5 +1,7 @@
 #include <unified.hpp>
 
+#include <unified/core/system/sleep.hpp>
+
 #include <unified/graphics/2d/camera.hpp>
 #include <unified/graphics/2d/drawable/vertex_array.hpp>
 
@@ -39,12 +41,21 @@ class ExampleBounce : public Application
 
         if (get_key_action(Keyboard::Code::D) == Keyboard::Action::Press)
             velocity.x += 0.05;
+
+        if (get_key_action(Keyboard::Code::Z) == Keyboard::Action::Press) {
+            camera.get_projection() *= 1.01;
+        }
+
+        if (get_key_action(Keyboard::Code::X) == Keyboard::Action::Press) {
+            camera.get_projection() *= 0.99;
+        }
     }
 
     void calculate_circle_position() {
+        auto projected = camera.get_projection() * position;
         for (u32 i = 0; i < circle_vertices_count; ++i) {
             double theta = 6.28 * double(i) / circle_vertices_count;
-            circle[i].point = { position.x + 0.1 * std::cos(theta), position.y + 0.1 * std::sin(theta) };
+            circle[i].point = { projected.x + camera.get_projection()[0][0] * 0.1 * std::cos(theta), projected.y + camera.get_projection()[1][1] * 0.1 * std::sin(theta) };
         }
     }
 
@@ -65,7 +76,7 @@ class ExampleBounce : public Application
     virtual bool OnUpdate(Time elapsed) override {
         clear();
 
-        auto estimated_position = position + camera.get_projection() * velocity * elapsed.asSeconds();
+        auto estimated_position = position + velocity * elapsed.asSeconds();
 
         if (estimated_position.x >= 0.9 || estimated_position.x <= -0.9)
             velocity.x = -(velocity.x / 2.0);

examples/fluid/fluid.cpp

@@ -35,7 +35,7 @@ class ExampleInterfaces : public Application
 
 public:
 
-    ExampleInterfaces() : Application("ExampleFluid"), start_time(get_current_time()) {
+    ExampleInterfaces() : Application("ExampleFluid", VideoMode(800, 600), Application::Floating), start_time(get_current_time()) {
         push_layer<FluidLayer>(this);
         push_layer<ImGuiLayer>(this);
         set_frame_limit(60);

examples/fluid/fluid.frag

@@ -9,7 +9,7 @@ in float out_start_time;
 in vec2 out_resolution;
 in vec4 out_color;
 
-// @note: much of magick numbers
+// @note: a lot of magick numbers
 float position_random(in vec2 position) {
     return fract(sin(dot(position.xy, vec2(12.9898, 78.233))) * 43758.5453123);
 }

include/unified/core/math/matrix.hpp

@@ -31,12 +31,12 @@ struct Matrix
         std::fill(&_data[0][0], &_data[_rows][0], fill);
     }
 
-    UNIFIED_CONSTEXPR _type operator()(u32 row, u32 column) const {
-        return _data[row][column];
+    UNIFIED_CONSTEXPR const _type *operator[](u32 row) const {
+        return _data[row];
     }
 
-    UNIFIED_CONSTEXPR _type &operator()(u32 row, u32 column) {
-        return _data[row][column];
+    UNIFIED_CONSTEXPR _type *operator[](u32 row) {
+        return _data[row];
     }
 
     UNIFIED_FORCE_INLINE u32 rows() const {
@@ -75,30 +75,55 @@ typedef Matrix<int,      4, 4> Matrix4x4i;
 typedef Matrix<float,    4, 4> Matrix4x4f;
 typedef Matrix<double,   4, 4> Matrix4x4d;
 
+template <class _type, u32 _rows_1, u32 _rows_2>
+UNIFIED_CONSTEXPR Matrix<_type, _rows_1, _rows_2> operator*(Matrix<_type, _rows_1, _rows_2> l, const _type &r) {
+    for (u32 row = 0; row < l.rows(); row++) {
+        for (u32 col = 0; col < l.columns(); col++) {
+            l[row][col] *= r;
+        }
+    }
+    return l;
+}
+
+template <class _type, u32 _rows_1, u32 _rows_2>
+UNIFIED_CONSTEXPR Matrix<_type, _rows_1, _rows_2> operator*=(Matrix<_type, _rows_1, _rows_2> &l, const _type &r) {
+    return (l = l * r);
+}
+
 template <class _type, u32 _rows_1, u32 _rows_2>
 UNIFIED_CONSTEXPR Point<_type, _rows_2> operator*(const Matrix<_type, _rows_1, _rows_2> &l, const Point<_type, _rows_2> &r) {
     Point<_type, _rows_2> result;
     for (u32 row = 0; row < l.rows(); row++) {
         for (u32 col = 0; col < l.columns(); col++) {
-            result[row] += r[col] * l(row, col);
+            result[row] += r[col] * l[row][col];
         }
     }
     return result;
 }
 
+template <class _type, u32 _rows_1, u32 _rows_2>
+UNIFIED_CONSTEXPR Point<_type, _rows_2> operator*=(Matrix<_type, _rows_1, _rows_2> &l, const Point<_type, _rows_2> &r) {
+    return (l = l * r);
+}
+
 template <class _type, u32 _rows_1, u32 _rows_2, u32 _columns>
 UNIFIED_CONSTEXPR Matrix<_type, _rows_1, _rows_2> operator*(const Matrix<_type, _rows_1, _rows_2> &l, const Matrix<_type, _rows_2, _columns> &r) {
     Matrix<_type, _rows_1, _rows_2> result;
     for (u32 row = 0; row < l.rows(); row++) {
         for (u32 col2 = 0; col2 < r.columns(); col2++) {
             for (u32 col = 0; col < l.columns(); col++) {
-                result(row, col2) += l(row, col) * r(col, col2);
+                result[row][col2] += l[row][col] * r[col][col2];
             }
         }
     }
     return result;
 }
 
+template <class _type, u32 _rows_1, u32 _rows_2, u32 _columns>
+UNIFIED_CONSTEXPR Matrix<_type, _rows_1, _rows_2> operator*=(Matrix<_type, _rows_1, _rows_2> &l, const Matrix<_type, _rows_2, _columns> &r) {
+    return (l = l * r);
+}
+
 UNIFIED_END_NAMESPACE
 
 #endif

include/unified/graphics/2d/camera.hpp

@@ -17,7 +17,7 @@ class Camera
 
     virtual ~Camera() { }
 
-    const Projection &get_projection() const;
+    Projection &get_projection();
 
 protected:
 

src/graphics/2d/camera.cpp

@@ -4,11 +4,11 @@ UNIFIED_BEGIN_NAMESPACE
 UNIFIED_GRAPHICS_2D_BEGIN_NAMESPACE
 
 Camera::Camera() :
-    _projection({ { 1.0, 0.0 }, { 0.0, 1.0 } }) { }
+    _projection({ { 1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, 0.0, 1.0 } }) { }
 
 Camera::Camera(const Projection &projection) : _projection(projection) { }
 
-const Projection &Camera::get_projection() const {
+Projection &Camera::get_projection() {
     return _projection;
 }