progress component and progress system

headers/enduro2d/high/_all.hpp

@@ -43,12 +43,14 @@
 #include "components/layout.hpp"
 #include "components/model_renderer.hpp"
 #include "components/named.hpp"
+#include "components/progress_handle.hpp"
+#include "components/progress.hpp"
 #include "components/renderer.hpp"
 #include "components/scene.hpp"
-#include "components/scrollbar.hpp"
 #include "components/scrollbar_handle.hpp"
-#include "components/slider.hpp"
+#include "components/scrollbar.hpp"
 #include "components/slider_handle.hpp"
+#include "components/slider.hpp"
 #include "components/spine_player.hpp"
 #include "components/sprite_renderer.hpp"
 #include "components/toggle_group.hpp"

headers/enduro2d/high/_high.hpp

@@ -63,6 +63,8 @@ namespace e2d
     class layout;
     class model_renderer;
     class named;
+    class progress;
+    class progress_handle;
     class renderer;
     class scene;
     class scrollbar;
@@ -93,6 +95,7 @@ namespace e2d
     class gizmos_system;
     class label_system;
     class layout_system;
+    class progress_system;
     class render_system;
     class script_system;
     class scrollbar_system;

headers/enduro2d/high/components/progress.hpp

@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#pragma once
+
+#include "_components.hpp"
+
+namespace e2d
+{
+    class progress final {
+    public:
+        ENUM_HPP_CLASS_DECL(directions, u8,
+            (row)
+            (row_reversed)
+            (column)
+            (column_reversed))
+    public:
+        progress() = default;
+
+        progress& value(f32 value) noexcept;
+        [[nodiscard]] f32 value() const noexcept;
+
+        progress& direction(directions value) noexcept;
+        [[nodiscard]] directions direction() const noexcept;
+    private:
+        f32 value_ = 0.f;
+        directions direction_ = directions::row;
+    };
+
+    ENUM_HPP_REGISTER_TRAITS(progress::directions)
+}
+
+namespace e2d
+{
+    template <>
+    class factory_loader<progress> final : factory_loader<> {
+    public:
+        static const char* schema_source;
+
+        bool operator()(
+            progress& component,
+            const fill_context& ctx) const;
+
+        bool operator()(
+            asset_dependencies& dependencies,
+            const collect_context& ctx) const;
+    };
+}
+
+namespace e2d
+{
+    template <>
+    class component_inspector<progress> final : component_inspector<> {
+    public:
+        static const char* title;
+
+        void operator()(gcomponent<progress>& c) const;
+    };
+}
+
+namespace e2d
+{
+    inline progress& progress::value(f32 value) noexcept {
+        value_ = math::saturate(value);
+        return *this;
+    }
+
+    inline f32 progress::value() const noexcept {
+        return value_;
+    }
+
+    inline progress& progress::direction(directions value) noexcept {
+        direction_ = value;
+        return *this;
+    }
+
+    inline progress::directions progress::direction() const noexcept {
+        return direction_;
+    }
+}

headers/enduro2d/high/components/progress_handle.hpp

@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#pragma once
+
+#include "_components.hpp"
+
+namespace e2d
+{
+    class progress_handle final {
+    public:
+        progress_handle() = default;
+    };
+}
+
+namespace e2d
+{
+    template <>
+    class factory_loader<progress_handle> final : factory_loader<> {
+    public:
+        static const char* schema_source;
+
+        bool operator()(
+            progress_handle& component,
+            const fill_context& ctx) const;
+
+        bool operator()(
+            asset_dependencies& dependencies,
+            const collect_context& ctx) const;
+    };
+}
+
+namespace e2d
+{
+    template <>
+    class component_inspector<progress_handle> final : component_inspector<> {
+    public:
+        static const char* title;
+
+        void operator()(gcomponent<progress_handle>& c) const;
+    };
+}

headers/enduro2d/high/systems/progress_system.hpp

@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#pragma once
+
+#include "_systems.hpp"
+
+namespace e2d
+{
+    class progress_system final
+        : public ecs::system<ecs::before<systems::update_event>> {
+    public:
+        progress_system();
+        ~progress_system() noexcept;
+
+        void process(
+            ecs::registry& owner,
+            const ecs::before<systems::update_event>& trigger) override;
+    private:
+        class internal_state;
+        std::unique_ptr<internal_state> state_;
+    };
+}

samples/bin/library/prefabs/progress_h_prefab.json

@@ -0,0 +1,62 @@
+{
+    "prefab" : "widget_prefab.json",
+    "components" : {
+        "named" : {
+            "name" : "progress_h"
+        },
+        "progress" : {
+            "direction" : "row"
+        },
+        "widget" : {
+            "size" : [300,20]
+        }
+    },
+    "children" : [{
+        "prefab" : "wsprite_prefab.json",
+        "components" : {
+            "named" : {
+                "name" : "background"
+            },
+            "sprite_renderer" : {
+                "tint" : [255,0,0,255],
+                "sprite" : "../sprites/panel_sprite.json"
+            },
+            "widget" : {
+                "size" : [300,20]
+            }
+        }
+    },{
+        "prefab" : "widget_prefab.json",
+        "components" : {
+            "named" : {
+                "name" : "handle_area"
+            },
+            "actor" : {
+                "translation" : [0,0]
+            },
+            "widget" : {
+                "size" : [300,20]
+            }
+        },
+        "children" : [{
+            "prefab" : "wsprite_prefab.json",
+            "components" : {
+                "named" : {
+                    "name" : "handle"
+                },
+                "actor" : {
+                    "translation" : [0,0]
+                },
+                "widget" : {
+                    "size" : [0,20]
+                },
+                "progress_handle" : {
+                },
+                "sprite_renderer" : {
+                    "tint" : [0,0,255,255],
+                    "sprite" : "../sprites/panel_sprite.json"
+                }
+            }
+        }]
+    }]
+}

samples/bin/library/prefabs/progress_v_prefab.json

@@ -0,0 +1,62 @@
+{
+    "prefab" : "widget_prefab.json",
+    "components" : {
+        "named" : {
+            "name" : "progress_v"
+        },
+        "progress" : {
+            "direction" : "column"
+        },
+        "widget" : {
+            "size" : [20,300]
+        }
+    },
+    "children" : [{
+        "prefab" : "wsprite_prefab.json",
+        "components" : {
+            "named" : {
+                "name" : "background"
+            },
+            "sprite_renderer" : {
+                "tint" : [255,0,0,255],
+                "sprite" : "../sprites/panel_sprite.json"
+            },
+            "widget" : {
+                "size" : [20,300]
+            }
+        }
+    },{
+        "prefab" : "widget_prefab.json",
+        "components" : {
+            "named" : {
+                "name" : "handle_area"
+            },
+            "actor" : {
+                "translation" : [0,0]
+            },
+            "widget" : {
+                "size" : [20,300]
+            }
+        },
+        "children" : [{
+            "prefab" : "wsprite_prefab.json",
+            "components" : {
+                "named" : {
+                    "name" : "handle"
+                },
+                "actor" : {
+                    "translation" : [0,0]
+                },
+                "widget" : {
+                    "size" : [20,0]
+                },
+                "progress_handle" : {
+                },
+                "sprite_renderer" : {
+                    "tint" : [0,0,255,255],
+                    "sprite" : "../sprites/panel_sprite.json"
+                }
+            }
+        }]
+    }]
+}

samples/bin/library/scenes/sample_10.json

@@ -97,6 +97,9 @@
         "components" : {
             "actor" : {
                 "translation" : [0,-300]
+            },
+            "scrollbar" : {
+                "value" : 0.25
             }
         }
     },{
@@ -104,6 +107,29 @@
         "components" : {
             "actor" : {
                 "translation" : [300,-300]
+            },
+            "scrollbar" : {
+                "value" : 0.25
+            }
+        }
+    },{
+        "prefab" : "../prefabs/progress_h_prefab.json",
+        "components" : {
+            "actor" : {
+                "translation" : [50,-350]
+            },
+            "progress" : {
+                "value" : 0.25
+            }
+        }
+    },{
+        "prefab" : "../prefabs/progress_v_prefab.json",
+        "components" : {
+            "actor" : {
+                "translation" : [350,-350]
+            },
+            "progress" : {
+                "value" : 0.25
             }
         }
     }]

samples/bin/library/scripts/emmy/components/progress.lua

@@ -0,0 +1,33 @@
+---@class progress
+local progress = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false,
+
+    ---@type number
+    value = 0.0,
+
+    ---@type progress_directions
+    direction = progress.directions.row
+}
+
+---@class progress_directions
+progress.directions = {
+    row = "row",
+    row_reversed = "row_reversed",
+    column = "column",
+    column_reversed = "column_reversed"
+}
+
+---@overload fun(self: progress)
+---@param self progress
+function progress.enable(self) end
+
+---@overload fun(self: progress)
+---@param self progress
+function progress.disable(self) end
+
+---@type progress
+_G.progress = _G.progress or progress

samples/bin/library/scripts/emmy/components/progress_handle.lua

@@ -0,0 +1,19 @@
+---@class progress_handle
+local progress_handle = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false
+}
+
+---@overload fun(self: progress_handle)
+---@param self progress_handle
+function progress_handle.enable(self) end
+
+---@overload fun(self: progress_handle)
+---@param self progress_handle
+function progress_handle.disable(self) end
+
+---@type progress_handle
+_G.progress_handle = _G.progress_handle or progress_handle

samples/bin/library/scripts/emmy/high/gobject.lua

@@ -42,6 +42,12 @@ local gobject = {
     ---@type named
     named = nil,
 
+    ---@type progress
+    progress = nil,
+
+    ---@type progress_handle
+    progress_handle = nil,
+
     ---@type renderer
     renderer = nil,
 

sources/enduro2d/high/bindings/high_binds/_high_binds.hpp

@@ -28,12 +28,14 @@ namespace e2d::bindings::high
     void bind_layout(sol::state& l);
     void bind_model_renderer(sol::state& l);
     void bind_named(sol::state& l);
+    void bind_progress_handle(sol::state& l);
+    void bind_progress(sol::state& l);
     void bind_renderer(sol::state& l);
     void bind_scene(sol::state& l);
-    void bind_scrollbar(sol::state& l);
     void bind_scrollbar_handle(sol::state& l);
-    void bind_slider(sol::state& l);
+    void bind_scrollbar(sol::state& l);
     void bind_slider_handle(sol::state& l);
+    void bind_slider(sol::state& l);
     void bind_spine_player(sol::state& l);
     void bind_sprite_renderer(sol::state& l);
     void bind_toggle_group(sol::state& l);
@@ -63,12 +65,14 @@ namespace e2d::bindings
         high::bind_layout(l);
         high::bind_model_renderer(l);
         high::bind_named(l);
+        high::bind_progress_handle(l);
+        high::bind_progress(l);
         high::bind_renderer(l);
         high::bind_scene(l);
-        high::bind_scrollbar(l);
         high::bind_scrollbar_handle(l);
-        high::bind_slider(l);
+        high::bind_scrollbar(l);
         high::bind_slider_handle(l);
+        high::bind_slider(l);
         high::bind_spine_player(l);
         high::bind_sprite_renderer(l);
         high::bind_toggle_group(l);

sources/enduro2d/high/bindings/high_binds/components/progress_binds.cpp

@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include "../_high_binds.hpp"
+
+#include <enduro2d/high/gobject.hpp>
+#include <enduro2d/high/components/disabled.hpp>
+#include <enduro2d/high/components/progress.hpp>
+
+namespace e2d::bindings::high
+{
+    void bind_progress(sol::state& l) {
+        l.new_usertype<gcomponent<progress>>("progress",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<progress>& c){
+                c.component<disabled<progress>>().remove();
+            },
+
+            "disable", [](gcomponent<progress>& c){
+                c.component<disabled<progress>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<progress>& c) -> bool {
+                    return !c.component<disabled<progress>>().exists();
+                },
+                [](gcomponent<progress>& c, bool yesno){
+                    if ( yesno ) {
+                        c.component<disabled<progress>>().remove();
+                    } else {
+                        c.component<disabled<progress>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<progress>& c) -> bool {
+                    return c.component<disabled<progress>>().exists();
+                },
+                [](gcomponent<progress>& c, bool yesno){
+                    if ( yesno ) {
+                        c.component<disabled<progress>>().ensure();
+                    } else {
+                        c.component<disabled<progress>>().remove();
+                    }
+                }
+            ),
+
+            "value", sol::property(
+                [](const gcomponent<progress>& c) -> f32 {
+                    return c->value();
+                },
+                [](gcomponent<progress>& c, f32 v){
+                    c->value(v);
+                }),
+
+            "direction", sol::property(
+                [](const gcomponent<progress>& c) -> progress::directions {
+                    return c->direction();
+                },
+                [](gcomponent<progress>& c, progress::directions v){
+                    c->direction(v);
+                })
+        );
+    }
+}

sources/enduro2d/high/bindings/high_binds/components/progress_handle_binds.cpp

@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include "../_high_binds.hpp"
+
+#include <enduro2d/high/gobject.hpp>
+#include <enduro2d/high/components/disabled.hpp>
+#include <enduro2d/high/components/progress_handle.hpp>
+
+namespace e2d::bindings::high
+{
+    void bind_progress_handle(sol::state& l) {
+        l.new_usertype<gcomponent<progress_handle>>("progress_handle",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<progress_handle>& c){
+                c.component<disabled<progress_handle>>().remove();
+            },
+
+            "disable", [](gcomponent<progress_handle>& c){
+                c.component<disabled<progress_handle>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<progress_handle>& c) -> bool {
+                    return !c.component<disabled<progress_handle>>().exists();
+                },
+                [](gcomponent<progress_handle>& c, bool yesno){
+                    if ( yesno ) {
+                        c.component<disabled<progress_handle>>().remove();
+                    } else {
+                        c.component<disabled<progress_handle>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<progress_handle>& c) -> bool {
+                    return c.component<disabled<progress_handle>>().exists();
+                },
+                [](gcomponent<progress_handle>& c, bool yesno){
+                    if ( yesno ) {
+                        c.component<disabled<progress_handle>>().ensure();
+                    } else {
+                        c.component<disabled<progress_handle>>().remove();
+                    }
+                }
+            )
+        );
+    }
+}

sources/enduro2d/high/bindings/high_binds/gobject_binds.cpp

@@ -17,12 +17,14 @@
 #include <enduro2d/high/components/label.hpp>
 #include <enduro2d/high/components/model_renderer.hpp>
 #include <enduro2d/high/components/named.hpp>
+#include <enduro2d/high/components/progress_handle.hpp>
+#include <enduro2d/high/components/progress.hpp>
 #include <enduro2d/high/components/renderer.hpp>
 #include <enduro2d/high/components/scene.hpp>
-#include <enduro2d/high/components/scrollbar.hpp>
 #include <enduro2d/high/components/scrollbar_handle.hpp>
-#include <enduro2d/high/components/slider.hpp>
+#include <enduro2d/high/components/scrollbar.hpp>
 #include <enduro2d/high/components/slider_handle.hpp>
+#include <enduro2d/high/components/slider.hpp>
 #include <enduro2d/high/components/spine_player.hpp>
 #include <enduro2d/high/components/sprite_renderer.hpp>
 #include <enduro2d/high/components/toggle_group.hpp>
@@ -52,19 +54,21 @@ namespace e2d::bindings::high
             "behaviour", sol::property([](gobject& go){ return component_wrapper<behaviour>{go}; }),
             "button", sol::property([](gobject& go){ return component_wrapper<button>{go}; }),
             "camera", sol::property([](gobject& go){ return component_wrapper<camera>{go}; }),
-            "rect_collider", sol::property([](gobject& go){ return component_wrapper<rect_collider>{go}; }),
             "circle_collider", sol::property([](gobject& go){ return component_wrapper<circle_collider>{go}; }),
-            "polygon_collider", sol::property([](gobject& go){ return component_wrapper<polygon_collider>{go}; }),
             "flipbook_player", sol::property([](gobject& go){ return component_wrapper<flipbook_player>{go}; }),
             "label", sol::property([](gobject& go){ return component_wrapper<label>{go}; }),
             "model_renderer", sol::property([](gobject& go){ return component_wrapper<model_renderer>{go}; }),
             "named", sol::property([](gobject& go){ return component_wrapper<named>{go}; }),
+            "polygon_collider", sol::property([](gobject& go){ return component_wrapper<polygon_collider>{go}; }),
+            "progress_handle", sol::property([](gobject& go){ return component_wrapper<progress_handle>{go}; }),
+            "progress", sol::property([](gobject& go){ return component_wrapper<progress>{go}; }),
+            "rect_collider", sol::property([](gobject& go){ return component_wrapper<rect_collider>{go}; }),
             "renderer", sol::property([](gobject& go){ return component_wrapper<renderer>{go}; }),
             "scene", sol::property([](gobject& go){ return component_wrapper<scene>{go}; }),
-            "scrollbar", sol::property([](gobject& go){ return component_wrapper<scrollbar>{go}; }),
             "scrollbar_handle", sol::property([](gobject& go){ return component_wrapper<scrollbar_handle>{go}; }),
-            "slider", sol::property([](gobject& go){ return component_wrapper<slider>{go}; }),
+            "scrollbar", sol::property([](gobject& go){ return component_wrapper<scrollbar>{go}; }),
             "slider_handle", sol::property([](gobject& go){ return component_wrapper<slider_handle>{go}; }),
+            "slider", sol::property([](gobject& go){ return component_wrapper<slider>{go}; }),
             "spine_player", sol::property([](gobject& go){ return component_wrapper<spine_player>{go}; }),
             "sprite_renderer", sol::property([](gobject& go){ return component_wrapper<sprite_renderer>{go}; }),
             "toggle_group", sol::property([](gobject& go){ return component_wrapper<toggle_group>{go}; }),

sources/enduro2d/high/components/progress.cpp

@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <enduro2d/high/components/progress.hpp>
+
+namespace e2d
+{
+    const char* factory_loader<progress>::schema_source = R"json({
+        "type" : "object",
+        "required" : [],
+        "additionalProperties" : false,
+        "properties" : {
+            "value" : { "type" : "number" },
+            "direction" : { "$ref": "#/definitions/directions" }
+        },
+        "definitions" : {
+            "directions" : {
+                "type" : "string",
+                "enum" : [
+                    "row",
+                    "row_reversed",
+                    "column",
+                    "column_reversed"
+                ]
+            }
+        }
+    })json";
+
+    bool factory_loader<progress>::operator()(
+        progress& component,
+        const fill_context& ctx) const
+    {
+        if ( ctx.root.HasMember("value") ) {
+            f32 value = component.value();
+            if ( !json_utils::try_parse_value(ctx.root["value"], value) ) {
+                the<debug>().error("progress: Incorrect formatting of 'value' property");
+                return false;
+            }
+            component.value(value);
+        }
+
+        if ( ctx.root.HasMember("direction") ) {
+            progress::directions direction = component.direction();
+            if ( !json_utils::try_parse_value(ctx.root["direction"], direction) ) {
+                the<debug>().error("progress: Incorrect formatting of 'direction' property");
+                return false;
+            }
+            component.direction(direction);
+        }
+
+        return true;
+    }
+
+    bool factory_loader<progress>::operator()(
+        asset_dependencies& dependencies,
+        const collect_context& ctx) const
+    {
+        E2D_UNUSED(dependencies, ctx);
+        return true;
+    }
+}
+
+namespace e2d
+{
+    const char* component_inspector<progress>::title = ICON_FA_SLIDERS_H " progress";
+
+    void component_inspector<progress>::operator()(gcomponent<progress>& c) const {
+        if ( f32 value = c->value();
+            ImGui::SliderFloat("value", &value, 0.f, 1.f) )
+        {
+            c->value(value);
+        }
+
+        if ( progress::directions direction = c->direction();
+            imgui_utils::show_enum_combo_box("direction", &direction) )
+        {
+            c->direction(direction);
+        }
+    }
+}

sources/enduro2d/high/components/progress_handle.cpp

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <enduro2d/high/components/progress_handle.hpp>
+
+namespace e2d
+{
+    const char* factory_loader<progress_handle>::schema_source = R"json({
+        "type" : "object",
+        "required" : [],
+        "additionalProperties" : false,
+        "properties" : {}
+    })json";
+
+    bool factory_loader<progress_handle>::operator()(
+        progress_handle& component,
+        const fill_context& ctx) const
+    {
+        E2D_UNUSED(component, ctx);
+        return true;
+    }
+
+    bool factory_loader<progress_handle>::operator()(
+        asset_dependencies& dependencies,
+        const collect_context& ctx) const
+    {
+        E2D_UNUSED(dependencies, ctx);
+        return true;
+    }
+}
+
+namespace e2d
+{
+    const char* component_inspector<progress_handle>::title = ICON_FA_HAND_ROCK " progress_handle";
+
+    void component_inspector<progress_handle>::operator()(gcomponent<progress_handle>& c) const {
+        E2D_UNUSED(c);
+    }
+}

sources/enduro2d/high/starter.cpp

@@ -26,6 +26,8 @@
 #include <enduro2d/high/components/layout.hpp>
 #include <enduro2d/high/components/model_renderer.hpp>
 #include <enduro2d/high/components/named.hpp>
+#include <enduro2d/high/components/progress_handle.hpp>
+#include <enduro2d/high/components/progress.hpp>
 #include <enduro2d/high/components/renderer.hpp>
 #include <enduro2d/high/components/scene.hpp>
 #include <enduro2d/high/components/scrollbar_handle.hpp>
@@ -46,6 +48,7 @@
 #include <enduro2d/high/systems/gizmos_system.hpp>
 #include <enduro2d/high/systems/label_system.hpp>
 #include <enduro2d/high/systems/layout_system.hpp>
+#include <enduro2d/high/systems/progress_system.hpp>
 #include <enduro2d/high/systems/render_system.hpp>
 #include <enduro2d/high/systems/script_system.hpp>
 #include <enduro2d/high/systems/scrollbar_system.hpp>
@@ -88,6 +91,7 @@ namespace
                 .feature<struct widget_feature>(ecs::feature()
                     .add_system<button_system>()
                     .add_system<toggle_system>()
+                    .add_system<progress_system>()
                     .add_system<scrollbar_system>()
                     .add_system<slider_system>()
                     .add_system<widget_system>())
@@ -231,6 +235,8 @@ namespace e2d
             .register_component<layout::dirty>("layout.dirty")
             .register_component<model_renderer>("model_renderer")
             .register_component<named>("named")
+            .register_component<progress>("progress")
+            .register_component<progress_handle>("progress_handle")
             .register_component<renderer>("renderer")
             .register_component<scene>("scene")
             .register_component<scrollbar>("scrollbar")
@@ -264,7 +270,7 @@ namespace e2d
             .register_component<button>("button")
             //.register_component<button::pressed>("button.pressed")
             .register_component<camera>("camera")
-            //.register_component<camera::gizmos>("camera.input")
+            //.register_component<camera::input>("camera.input")
             //.register_component<camera::gizmos>("camera.gizmos")
             .register_component<rect_collider>("rect_collider")
             .register_component<circle_collider>("circle_collider")
@@ -276,6 +282,8 @@ namespace e2d
             //.register_component<layout::dirty>("layout.dirty")
             .register_component<model_renderer>("model_renderer")
             .register_component<named>("named")
+            .register_component<progress>("progress")
+            .register_component<progress_handle>("progress_handle")
             .register_component<renderer>("renderer")
             .register_component<scene>("scene")
             .register_component<scrollbar>("scrollbar")

sources/enduro2d/high/systems/progress_system.cpp

@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2020, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <enduro2d/high/systems/progress_system.hpp>
+
+#include <enduro2d/high/components/actor.hpp>
+#include <enduro2d/high/components/disabled.hpp>
+#include <enduro2d/high/components/progress.hpp>
+#include <enduro2d/high/components/progress_handle.hpp>
+#include <enduro2d/high/components/widget.hpp>
+
+namespace
+{
+    using namespace e2d;
+
+    void update_progress_states(ecs::registry& owner) {
+        owner.for_joined_components<progress, actor>([](
+            const ecs::const_entity&,
+            const progress& s,
+            const actor& a)
+        {
+            gcomponent<progress_handle> handle_h =
+                nodes::find_component_from_children<progress_handle>(
+                    a.node(),
+                    nodes::options().recursive(true));
+
+            if ( !handle_h ) {
+                return;
+            }
+
+            gcomponent<actor> handle_a = handle_h.component<actor>();
+            if ( !handle_a || !handle_a->node() ) {
+                return;
+            }
+
+            gcomponent<widget> handle_w = handle_h.component<widget>();
+            if ( !handle_w ) {
+                return;
+            }
+
+            gcomponent<widget> handle_area_w = handle_a->node()->parent()
+                ? handle_a->node()->parent()->owner().component<widget>()
+                : gcomponent<widget>();
+
+            if ( !handle_area_w ) {
+                return;
+            }
+
+            const v2f& area_size = handle_area_w->size();
+
+            switch ( s.direction() ) {
+            case progress::directions::row:
+                handle_a->node()->transform({
+                    v2f::zero(),
+                    0.f,
+                    v2f::unit()});
+                widgets::change_size(handle_w, {
+                    s.value() * area_size.x,
+                    area_size.y});
+                break;
+            case progress::directions::row_reversed:
+                handle_a->node()->transform({
+                    v2f::unit_x() * (1.f - s.value()) * area_size.x,
+                    0.f,
+                    v2f::unit()});
+                widgets::change_size(handle_w, {
+                    s.value() * area_size.x,
+                    area_size.y});
+                break;
+            case progress::directions::column:
+                handle_a->node()->transform({
+                    v2f::zero(),
+                    0.f,
+                    v2f::unit()});
+                widgets::change_size(handle_w, {
+                    area_size.x,
+                    s.value() * area_size.y});
+                break;
+            case progress::directions::column_reversed:
+                handle_a->node()->transform({
+                    v2f::unit_y() * (1.f - s.value()) * area_size.y,
+                    0.f,
+                    v2f::unit()});
+                widgets::change_size(handle_w, {
+                    area_size.x,
+                    s.value() * area_size.y});
+                break;
+            default:
+                E2D_ASSERT_MSG(false, "unexpected progress direction type");
+                break;
+            }
+        }, !ecs::exists<disabled<progress>>());
+    }
+}
+
+namespace e2d
+{
+    //
+    // progress_system::internal_state
+    //
+
+    class progress_system::internal_state final : private noncopyable {
+    public:
+        internal_state() = default;
+        ~internal_state() noexcept = default;
+
+        void process_update(ecs::registry& owner) {
+            update_progress_states(owner);
+        }
+    };
+
+    //
+    // progress_system
+    //
+
+    progress_system::progress_system()
+    : state_(new internal_state()) {}
+    progress_system::~progress_system() noexcept = default;
+
+    void progress_system::process(
+        ecs::registry& owner,
+        const ecs::before<systems::update_event>& trigger)
+    {
+        E2D_UNUSED(trigger);
+        E2D_PROFILER_SCOPE("progress_system.process_update");
+        state_->process_update(owner);
+    }
+}