mod(bounce): bounce example improved (again)

Author: beryll1um

CMakeLists.txt

@@ -67,8 +67,8 @@ option(UNIFORM_BUILD_EXAMPLES "Build the ${UNIFIED_PROJECT} test programs" TRUE)
 if (UNIFORM_BUILD_EXAMPLES)
     message("-- Build the ${UNIFIED_PROJECT} test programs")
     set(UNIFIED_EXAMPLES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/examples")
-    add_subdirectory("${UNIFIED_EXAMPLES_DIR}/bounce")
-    add_subdirectory("${UNIFIED_EXAMPLES_DIR}/interfaces")
-    add_subdirectory("${UNIFIED_EXAMPLES_DIR}/layers")
-    add_subdirectory("${UNIFIED_EXAMPLES_DIR}/texture")
+    directories_list(EXAMPLE_DIRECTORIES ${UNIFIED_EXAMPLES_DIR})
+    foreach(EXAMPLE_NAME ${EXAMPLE_DIRECTORIES})
+        add_subdirectory("${UNIFIED_EXAMPLES_DIR}/${EXAMPLE_NAME}")
+    endforeach()
 endif ()

examples/bounce/bounce.cpp

@@ -1,9 +1,7 @@
 #include <unified.hpp>
 
+#include <unified/graphics/2d/camera.hpp>
 #include <unified/graphics/2d/drawable/vertex_array.hpp>
-#include <unified/graphics/camera.hpp>
-
-#include <unified/core/math/point4.hpp>
 
 #include <imgui_layer/imgui_layer.hpp>
 
@@ -17,10 +15,10 @@ class ExampleBounce : public Application
 {
 public:
 
-    Camera camera;
+    Graphics2D::Camera camera;
 
-    Point2d position;
-    Point4d velocity;
+    Color color;
+    Point2d position, velocity;
 
     Graphics::Vertex2d circle[32];
     const u32 circle_vertices_count = sizeof(circle) / sizeof(*circle);
@@ -29,55 +27,58 @@ class ExampleBounce : public Application
         set_viewport(event.size);
     }
 
-public:
+    void keyboard_handle() {
+        if (get_key_action(Keyboard::Code::W) == Keyboard::Action::Press)
+            velocity.y += 0.05;
 
-    ExampleBounce() : Application("ExampleBounce", VideoMode(600, 600), !Window::Resizable) {
-        Modules::ImGuiLayer::Create(this);
-        push_layer<CubeLayer>(this);
-        push_layer<ImGuiLayer>(this);
-        set_frame_limit(60);
+        if (get_key_action(Keyboard::Code::S) == Keyboard::Action::Press)
+            velocity.y -= 0.05;
+
+        if (get_key_action(Keyboard::Code::A) == Keyboard::Action::Press)
+            velocity.x -= 0.05;
+
+        if (get_key_action(Keyboard::Code::D) == Keyboard::Action::Press)
+            velocity.x += 0.05;
+    }
+
+    void calculate_circle_position() {
         for (u32 i = 0; i < circle_vertices_count; ++i) {
-            circle[i].color = { 1.f, 0.f, 1.f, 1.f }; 
+            double theta = 6.28 * float(i) / circle_vertices_count;
+            circle[i].point = { position.x + 0.1 * std::cos(theta), position.y + 0.1 * std::sin(theta) };
         }
     }
 
-    ~ExampleBounce() {
-        Modules::ImGuiLayer::Destroy();
+    void calculate_circle_color() {
+        for (u32 i = 0; i < circle_vertices_count; ++i) {
+            circle[i].color = color;
+        }
     }
 
-    virtual bool OnUpdate(Time elapsed) override {
-        clear();
+public:
 
-        auto offset = camera.get_projection() * (velocity * static_cast<double>(elapsed.asMilliseconds()));
-        auto estimate_position = position + Point2d(offset.x, offset.y);
-        
-        if (estimate_position.x >= 0.9 || estimate_position.x <= -0.9) {
-            velocity.x = -(velocity.x / 2.0);
-        } else if (estimate_position.y >= 0.9 || estimate_position.y <= -0.9) {
-            velocity.y = -(velocity.y / 2.0);
-        } else {            
-            position = estimate_position;
+    ExampleBounce() : Application("ExampleBounce", VideoMode(600, 600), Window::Floating) {
+        push_layer<CubeLayer>(this);
+        push_layer<ImGuiLayer>(this);
+        set_frame_limit(60);
+    }
 
-            if (this->get_key_action(Keyboard::Code::W) == Keyboard::Action::Press)
-                velocity.y += 0.0001;
+    virtual bool OnUpdate(Time elapsed) override {
+        clear();
 
-            if (this->get_key_action(Keyboard::Code::S) == Keyboard::Action::Press)
-                velocity.y -= 0.0001;
+        keyboard_handle();
 
-            if (this->get_key_action(Keyboard::Code::A) == Keyboard::Action::Press)
-                velocity.x -= 0.0001;
+        auto estimated_position = position + camera.get_projection() * velocity * elapsed.asSeconds();
 
-            if (this->get_key_action(Keyboard::Code::D) == Keyboard::Action::Press)
-                velocity.x += 0.0001;
+        if (estimated_position.x >= 0.9 || estimated_position.x <= -0.9)
+            velocity.x = -(velocity.x / 2.0);
+        else if (estimated_position.y >= 0.9 || estimated_position.y <= -0.9)
+            velocity.y = -(velocity.y / 2.0);
+        else
+            position = estimated_position, calculate_circle_position();
 
-            for (u32 i = 0; i < circle_vertices_count; ++i) {
-                double theta = 2.0 * 3.14 * float(i) / circle_vertices_count;
-                circle[i].point = { position.x + (0.1 * std::cos(theta)), position.y + (0.1 * std::sin(theta)) };
-            }
-        }
+        calculate_circle_color();
 
         process_layers();
-
         swap_buffers();
         return poll_events();
     }
@@ -96,7 +97,9 @@ class CubeLayer : public Layer
 
     Graphics2D::VertexArray vertex_array;
 
-    CubeLayer(ExampleBounce *application) : application(application), vertex_array(PrimitiveType::Polygon, 32) { }
+    CubeLayer(ExampleBounce *application) : application(application), vertex_array(PrimitiveType::Polygon, 32) {
+        std::fill(application->circle, application->circle + 32, Vertex2d({ 1.f, 0.f, 1.f, 1.f }));
+    }
 
     virtual void OnUpdate(Time) override {
         vertex_array.write(application->circle, sizeof(application->circle));
@@ -111,13 +114,26 @@ class ImGuiLayer : public Modules::ImGuiLayer
 
     ExampleBounce *application;
 
-    ImGuiLayer(ExampleBounce *application) : application(application) { }
+    ImGuiLayer(ExampleBounce *application) : application(application) {
+        Create(application);
+    }
 
     virtual void OnUpdate(Time) override {
         ImGui::Begin("ExampleBounce");
+        if (ImGui::CollapsingHeader("Info")) {
+            ImGui::Text("Position: %lf, %lf", application->position.x, application->position.y);
+            ImGui::Text("Velocity: %lf, %lf", application->velocity.x, application->velocity.y);
+        }
+        if (ImGui::CollapsingHeader("Properties")) {
+            ImGui::ColorEdit3("Ball", (float*)&application->color);
+        }
         ImGui::End();
     }
 
+    ~ImGuiLayer() {
+        Destroy();
+    }
+
 };
 
 Application *UNIFIED_NAMESPACE::CreateApplication() {

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

@@ -0,0 +1,31 @@
+#ifndef _UNIFIED_GRAPHICS_2D_CAMERA_HPP
+#define _UNIFIED_GRAPHICS_2D_CAMERA_HPP
+
+# include <unified/core/math/matrix.hpp>
+
+UNIFIED_BEGIN_NAMESPACE
+UNIFIED_GRAPHICS_2D_BEGIN_NAMESPACE
+
+typedef Matrix<double, 2, 2> Projection;
+
+class Camera
+{
+public:
+
+    Camera();
+    Camera(const Projection &projection);
+
+    virtual ~Camera() { }
+
+    const Projection &get_projection() const;
+
+protected:
+
+    Projection _projection;
+
+};
+
+UNIFIED_GRAPHICS_2D_END_NAMESPACE
+UNIFIED_END_NAMESPACE
+
+#endif

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

@@ -16,6 +16,8 @@ struct Vertex<_type, 2>
 
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 2> &point) : point(point), color(), texture() { }
 
+    UNIFIED_CONSTEXPR Vertex(const Color &color) : point(), color(color), texture() { }
+
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 2> &point, const Color &color) : point(point), color(color), texture() { }
 
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 2> &point, const Point<_type, 2> &vertex) : point(point), color(), texture(vertex) { }

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

@@ -0,0 +1,31 @@
+#ifndef _UNIFIED_GRAPHICS_3D_CAMERA_HPP
+#define _UNIFIED_GRAPHICS_3D_CAMERA_HPP
+
+# include <unified/core/math/matrix.hpp>
+
+UNIFIED_BEGIN_NAMESPACE
+UNIFIED_GRAPHICS_3D_BEGIN_NAMESPACE
+
+typedef Matrix<double, 4, 4> Projection;
+
+class Camera
+{
+public:
+
+    Camera();
+    Camera(const Projection &projection);
+
+    virtual ~Camera() { }
+
+    const Projection &get_projection() const;
+
+protected:
+
+    Projection _projection;
+
+};
+
+UNIFIED_GRAPHICS_3D_END_NAMESPACE
+UNIFIED_END_NAMESPACE
+
+#endif

include/unified/graphics/3d/vertex.hpp

@@ -16,6 +16,8 @@ struct Vertex<_type, 3>
 
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 3> &point) : point(point), color(), texture() { }
 
+    UNIFIED_CONSTEXPR Vertex(const Color &color) : point(), color(color), texture() { }
+
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 3> &point, const Color &color) : point(point), color(color), texture() { }
 
     UNIFIED_CONSTEXPR Vertex(const Point<_type, 3> &point, const Point<_type, 2> &vertex) : point(point), color(), texture(vertex) { }

src/graphics/2d/camera.cpp

@@ -0,0 +1,16 @@
+#include <unified/graphics/2d/camera.hpp>
+
+UNIFIED_BEGIN_NAMESPACE
+UNIFIED_GRAPHICS_2D_BEGIN_NAMESPACE
+
+Camera::Camera() :
+    _projection({ { 1.0, 0.0 }, { 0.0, 1.0 } }) { }
+
+Camera::Camera(const Projection &projection) : _projection(projection) { }
+
+const Projection &Camera::get_projection() const {
+    return _projection;
+}
+
+UNIFIED_GRAPHICS_2D_END_NAMESPACE
+UNIFIED_END_NAMESPACE

src/graphics/3d/camera.cpp

@@ -0,0 +1,16 @@
+#include <unified/graphics/3d/camera.hpp>
+
+UNIFIED_BEGIN_NAMESPACE
+UNIFIED_GRAPHICS_3D_BEGIN_NAMESPACE
+
+Camera::Camera() :
+    _projection({ { 1.0, 0.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0, 0.0 }, { 0.0, 0.0, 0.0, 1.0 } }) { }
+
+Camera::Camera(const Projection &projection) : _projection(projection) { }
+
+const Projection &Camera::get_projection() const {
+    return _projection;
+}
+
+UNIFIED_GRAPHICS_3D_END_NAMESPACE
+UNIFIED_END_NAMESPACE