From 49cfa0b8000a78eb41306eb457096b7ad8e83bed Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Sun, 1 Dec 2019 18:16:42 +0700
Subject: [PATCH 01/19] dummy profiler module

---
 headers/enduro2d/core/_all.hpp     |  1 +
 headers/enduro2d/core/_core.hpp    |  1 +
 headers/enduro2d/core/profiler.hpp | 21 +++++++++++++++++++++
 sources/enduro2d/core/engine.cpp   |  6 ++++++
 sources/enduro2d/core/profiler.cpp | 20 ++++++++++++++++++++
 5 files changed, 49 insertions(+)
 create mode 100644 headers/enduro2d/core/profiler.hpp
 create mode 100644 sources/enduro2d/core/profiler.cpp

diff --git a/headers/enduro2d/core/_all.hpp b/headers/enduro2d/core/_all.hpp
index af113a40..2b0721a7 100644
--- a/headers/enduro2d/core/_all.hpp
+++ b/headers/enduro2d/core/_all.hpp
@@ -16,6 +16,7 @@
 #include "input.hpp"
 #include "network.hpp"
 #include "platform.hpp"
+#include "profiler.hpp"
 #include "render.hpp"
 #include "render.inl"
 #include "vfs.hpp"
diff --git a/headers/enduro2d/core/_core.hpp b/headers/enduro2d/core/_core.hpp
index a993592d..be0a4675 100644
--- a/headers/enduro2d/core/_core.hpp
+++ b/headers/enduro2d/core/_core.hpp
@@ -44,6 +44,7 @@ namespace e2d
     class input;
     class network;
     class platform;
+    class profiler;
     class render;
     class shader;
     class texture;
diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
new file mode 100644
index 00000000..1579a564
--- /dev/null
+++ b/headers/enduro2d/core/profiler.hpp
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#pragma once
+
+#include "_core.hpp"
+
+namespace e2d
+{
+    class profiler final : public module<profiler> {
+    public:
+        profiler();
+        ~profiler() noexcept final;
+    private:
+        class internal_state;
+        std::unique_ptr<internal_state> state_;
+    };
+}
diff --git a/sources/enduro2d/core/engine.cpp b/sources/enduro2d/core/engine.cpp
index 3b9833fc..6522d475 100644
--- a/sources/enduro2d/core/engine.cpp
+++ b/sources/enduro2d/core/engine.cpp
@@ -13,6 +13,7 @@
 #include <enduro2d/core/input.hpp>
 #include <enduro2d/core/network.hpp>
 #include <enduro2d/core/platform.hpp>
+#include <enduro2d/core/profiler.hpp>
 #include <enduro2d/core/render.hpp>
 #include <enduro2d/core/vfs.hpp>
 #include <enduro2d/core/window.hpp>
@@ -374,6 +375,10 @@ namespace e2d
     engine::engine(int argc, char *argv[], const parameters& params)
     : state_(new internal_state(params))
     {
+        // setup profiler
+
+        safe_module_initialize<profiler>();
+
         // setup platform
 
         safe_module_initialize<platform>(argc, argv);
@@ -479,6 +484,7 @@ namespace e2d
         modules::shutdown<debug>();
         modules::shutdown<deferrer>();
         modules::shutdown<platform>();
+        modules::shutdown<profiler>();
     }
 
     bool engine::start(application_uptr app) {
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
new file mode 100644
index 00000000..f2d83ec6
--- /dev/null
+++ b/sources/enduro2d/core/profiler.cpp
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <enduro2d/core/profiler.hpp>
+
+namespace e2d
+{
+    class profiler::internal_state final : private e2d::noncopyable {
+    public:
+        internal_state() = default;
+        ~internal_state() noexcept = default;
+    };
+
+    profiler::profiler()
+    : state_(new internal_state()) {}
+    profiler::~profiler() noexcept = default;
+}

From 199768ddf54f7e98cbd54f7a288fad2f801aaeb8 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Mon, 2 Dec 2019 01:32:47 +0700
Subject: [PATCH 02/19] utils: little defer refactoring

---
 headers/enduro2d/utils/defer.hpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/headers/enduro2d/utils/defer.hpp b/headers/enduro2d/utils/defer.hpp
index 0993630b..e569ffe9 100644
--- a/headers/enduro2d/utils/defer.hpp
+++ b/headers/enduro2d/utils/defer.hpp
@@ -13,12 +13,8 @@ namespace e2d
     namespace impl
     {
         template < typename F >
-        class defer_impl {
+        class defer_impl final : noncopyable {
         public:
-            defer_impl() = delete;
-            defer_impl(const defer_impl&) = delete;
-            defer_impl& operator=(const defer_impl&) = delete;
-
             explicit defer_impl(F f)
             : f_(std::move(f)) {}
 
@@ -44,4 +40,4 @@ namespace e2d
 }
 
 #define E2D_DEFER(lambda)\
-    auto E2D_PP_CAT(e2d_defer_, __LINE__) = ::e2d::make_defer(lambda)
+    auto E2D_PP_CAT(e2d_generated_defer_, __LINE__) = ::e2d::make_defer(lambda)

From be7114f4b28662834319e16abea11b3424108b47 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Mon, 2 Dec 2019 10:08:27 +0700
Subject: [PATCH 03/19] some str_view vs buffer_view improvements

---
 headers/enduro2d/high/luasol.hpp       |  1 +
 headers/enduro2d/utils/buffer_view.hpp |  8 --------
 headers/enduro2d/utils/filesystem.hpp  |  1 +
 headers/enduro2d/utils/streams.hpp     |  5 +++++
 sources/enduro2d/high/luasol.cpp       | 13 ++++++++++---
 sources/enduro2d/utils/filesystem.cpp  |  5 +++++
 sources/enduro2d/utils/streams.cpp     | 14 ++++++++++++++
 7 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/headers/enduro2d/high/luasol.hpp b/headers/enduro2d/high/luasol.hpp
index f06883b7..a030f176 100644
--- a/headers/enduro2d/high/luasol.hpp
+++ b/headers/enduro2d/high/luasol.hpp
@@ -24,6 +24,7 @@ namespace e2d
         template < typename F >
         decltype(auto) with_state(F&& f) const;
 
+        std::optional<script> load_script(str_view src);
         std::optional<script> load_script(buffer_view src);
         std::optional<script> load_script(const input_stream_uptr& src);
     private:
diff --git a/headers/enduro2d/utils/buffer_view.hpp b/headers/enduro2d/utils/buffer_view.hpp
index 6f5284e7..7d2b81d1 100644
--- a/headers/enduro2d/utils/buffer_view.hpp
+++ b/headers/enduro2d/utils/buffer_view.hpp
@@ -27,9 +27,6 @@ namespace e2d
         template < typename T >
         buffer_view(const vector<T>& buffer) noexcept;
 
-        template < typename Char >
-        buffer_view(const basic_string<Char>& buffer) noexcept;
-
         template < typename T, std::size_t N >
         buffer_view(const std::array<T,N>& buffer) noexcept;
 
@@ -60,11 +57,6 @@ namespace e2d
     : data_(buffer.data())
     , size_(buffer.size() * sizeof(T)) {}
 
-    template < typename Char >
-    buffer_view::buffer_view(const basic_string<Char>& buffer) noexcept
-    : data_(buffer.data())
-    , size_(buffer.size() * sizeof(Char)) {}
-
     template < typename T, std::size_t N >
     buffer_view::buffer_view(const std::array<T,N>& buffer) noexcept
     : data_(buffer.data())
diff --git a/headers/enduro2d/utils/filesystem.hpp b/headers/enduro2d/utils/filesystem.hpp
index d5ab3635..7e928a77 100644
--- a/headers/enduro2d/utils/filesystem.hpp
+++ b/headers/enduro2d/utils/filesystem.hpp
@@ -76,6 +76,7 @@ namespace e2d::filesystem
 
     bool try_read_all(str& dst, str_view path) noexcept;
     bool try_read_all(buffer& dst, str_view path) noexcept;
+    bool try_write_all(str_view src, str_view path, bool append) noexcept;
     bool try_write_all(buffer_view src, str_view path, bool append) noexcept;
 
     ENUM_HPP_CLASS_DECL(predef_path, u8,
diff --git a/headers/enduro2d/utils/streams.hpp b/headers/enduro2d/utils/streams.hpp
index 3b392810..4ca53cf1 100644
--- a/headers/enduro2d/utils/streams.hpp
+++ b/headers/enduro2d/utils/streams.hpp
@@ -81,6 +81,7 @@ namespace e2d
 
         output_sequence& seek(std::ptrdiff_t offset, bool relative) noexcept;
         output_sequence& write(const void* src, std::size_t size) noexcept;
+        output_sequence& write_all(str_view src) noexcept;
         output_sequence& write_all(buffer_view src) noexcept;
 
         output_sequence& flush() noexcept;
@@ -113,6 +114,10 @@ namespace e2d::streams
         buffer& dst,
         const input_stream_uptr& stream) noexcept;
 
+    bool try_write_tail(
+        str_view src,
+        const output_stream_uptr& stream) noexcept;
+
     bool try_write_tail(
         buffer_view src,
         const output_stream_uptr& stream) noexcept;
diff --git a/sources/enduro2d/high/luasol.cpp b/sources/enduro2d/high/luasol.cpp
index 1955e4ea..fa479db7 100644
--- a/sources/enduro2d/high/luasol.cpp
+++ b/sources/enduro2d/high/luasol.cpp
@@ -38,12 +38,11 @@ namespace e2d
         state_.collect_garbage();
     }
 
-    std::optional<script> luasol::load_script(buffer_view src) {
+    std::optional<script> luasol::load_script(str_view src) {
         E2D_ASSERT(is_in_main_thread());
 
         sol::load_result result = state_.load_buffer(
-            reinterpret_cast<const char*>(src.data()),
-            src.size());
+            src.data(), src.size());
 
         if ( !result.valid() ) {
             sol::error err = result;
@@ -56,6 +55,14 @@ namespace e2d
         return script(sol::protected_function(result));
     }
 
+    std::optional<script> luasol::load_script(buffer_view src) {
+        E2D_ASSERT(is_in_main_thread());
+
+        return load_script(str_view(
+            reinterpret_cast<const char*>(src.data()),
+            src.size()));
+    }
+
     std::optional<script> luasol::load_script(const input_stream_uptr& src) {
         E2D_ASSERT(is_in_main_thread());
 
diff --git a/sources/enduro2d/utils/filesystem.cpp b/sources/enduro2d/utils/filesystem.cpp
index c64d8662..3d9b98a5 100644
--- a/sources/enduro2d/utils/filesystem.cpp
+++ b/sources/enduro2d/utils/filesystem.cpp
@@ -105,6 +105,11 @@ namespace e2d::filesystem
             dst, make_read_file(path));
     }
 
+    bool try_write_all(str_view src, str_view path, bool append) noexcept {
+        return streams::try_write_tail(
+            src, make_write_file(path, append));
+    }
+
     bool try_write_all(buffer_view src, str_view path, bool append) noexcept {
         return streams::try_write_tail(
             src, make_write_file(path, append));
diff --git a/sources/enduro2d/utils/streams.cpp b/sources/enduro2d/utils/streams.cpp
index 4d775f56..c6cefe78 100644
--- a/sources/enduro2d/utils/streams.cpp
+++ b/sources/enduro2d/utils/streams.cpp
@@ -170,6 +170,12 @@ namespace e2d
         return *this;
     }
 
+    output_sequence& output_sequence::write_all(str_view src) noexcept {
+        return success_
+            ? write(src.data(), src.size())
+            : *this;
+    }
+
     output_sequence& output_sequence::write_all(buffer_view src) noexcept {
         return success_
             ? write(src.data(), src.size())
@@ -222,6 +228,14 @@ namespace e2d::streams
             : false;
     }
 
+    bool try_write_tail(str_view src, const output_stream_uptr& stream) noexcept {
+        return stream
+            ? output_sequence(*stream)
+                .write_all(src)
+                .success()
+            : false;
+    }
+
     bool try_write_tail(buffer_view src, const output_stream_uptr& stream) noexcept {
         return stream
             ? output_sequence(*stream)

From dbf86793f0da592865b6920b298b495a1f80ce06 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Mon, 2 Dec 2019 11:12:01 +0700
Subject: [PATCH 04/19] basic profiler events and sink registration

---
 headers/enduro2d/core/profiler.hpp | 67 ++++++++++++++++++++++++
 sources/enduro2d/core/profiler.cpp | 82 +++++++++++++++++++++++++++++-
 2 files changed, 148 insertions(+), 1 deletion(-)

diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
index 1579a564..b084d8fb 100644
--- a/headers/enduro2d/core/profiler.hpp
+++ b/headers/enduro2d/core/profiler.hpp
@@ -11,11 +11,78 @@
 namespace e2d
 {
     class profiler final : public module<profiler> {
+    public:
+        struct begin_scope_info {
+            str name;
+            u64 ts = 0;
+            u64 tid = 0;
+        };
+
+        struct end_scope_info {
+            u64 ts = 0;
+            u64 tid = 0;
+        };
+
+        struct thread_event_info {
+            str name;
+            u64 ts = 0;
+            u64 tid = 0;
+        };
+
+        struct global_event_info {
+            str name;
+            u64 ts = 0;
+            u64 tid = 0;
+        };
+
+        using event_info = std::variant<
+            begin_scope_info,
+            end_scope_info,
+            thread_event_info,
+            global_event_info>;
+    public:
+        class sink : private e2d::noncopyable {
+        public:
+            virtual ~sink() noexcept = default;
+            virtual void on_event(const event_info& event) noexcept = 0;
+        };
+        using sink_uptr = std::unique_ptr<sink>;
+    public:
+        class scope final : private e2d::noncopyable {
+        public:
+            scope(profiler& profiler, str name);
+            ~scope() noexcept;
+        private:
+            profiler& profiler_;
+        };
     public:
         profiler();
         ~profiler() noexcept final;
+
+        void begin_scope(str name) noexcept;
+        void end_scope() noexcept;
+
+        void thread_event(str name) noexcept;
+        void global_event(str name) noexcept;
+    public:
+        template < typename T, typename... Args >
+        T& register_sink(Args&&... args);
+        sink& register_sink(sink_uptr sink);
+        void unregister_sink(const sink& sink) noexcept;
     private:
         class internal_state;
         std::unique_ptr<internal_state> state_;
     };
 }
+
+#define E2D_PROFILER_SCOPE(name)\
+    auto E2D_PP_CAT(e2d_generated_profiler_scope_, __LINE__) = ::e2d::profiler::scope(the<profiler>(), name)
+
+namespace e2d
+{
+    template < typename T, typename... Args >
+    T& profiler::register_sink(Args&&... args) {
+        return static_cast<T&>(
+            register_sink(std::make_unique<T>(std::forward<Args>(args)...)));
+    }
+}
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
index f2d83ec6..5353ac78 100644
--- a/sources/enduro2d/core/profiler.cpp
+++ b/sources/enduro2d/core/profiler.cpp
@@ -6,15 +6,95 @@
 
 #include <enduro2d/core/profiler.hpp>
 
+namespace e2d
+{
+    profiler::scope::scope(profiler& profiler, str name)
+    : profiler_(profiler) {
+        profiler_.begin_scope(std::move(name));
+    }
+
+    profiler::scope::~scope() noexcept {
+        profiler_.end_scope();
+    }
+}
+
 namespace e2d
 {
     class profiler::internal_state final : private e2d::noncopyable {
     public:
         internal_state() = default;
         ~internal_state() noexcept = default;
-    };
 
+        sink& register_sink(sink_uptr sink) {
+            E2D_ASSERT(sink);
+            std::lock_guard<std::recursive_mutex> guard(rmutex_);
+            sinks_.push_back(std::move(sink));
+            return *sinks_.back();
+        }
+
+        void unregister_sink(const sink& sink) noexcept {
+            std::lock_guard<std::recursive_mutex> guard(rmutex_);
+            for ( auto iter = sinks_.begin(); iter != sinks_.end(); ) {
+                if ( iter->get() == &sink ) {
+                    iter = sinks_.erase(iter);
+                } else {
+                    ++iter;
+                }
+            }
+        }
+
+        void emit_event(event_info event) noexcept {
+            std::lock_guard<std::recursive_mutex> guard(rmutex_);
+            for ( const auto& sink : sinks_ ) {
+                if ( sink ) {
+                    sink->on_event(event);
+                }
+            }
+        }
+    private:
+        vector<sink_uptr> sinks_;
+        std::recursive_mutex rmutex_;
+    };
+}
+
+namespace e2d
+{
     profiler::profiler()
     : state_(new internal_state()) {}
     profiler::~profiler() noexcept = default;
+
+    profiler::sink& profiler::register_sink(sink_uptr sink) {
+        return state_->register_sink(std::move(sink));
+    }
+
+    void profiler::unregister_sink(const sink& sink) noexcept {
+        state_->unregister_sink(sink);
+    }
+
+    void profiler::begin_scope(str name) noexcept {
+        state_->emit_event(begin_scope_info{
+            std::move(name),
+            math::numeric_cast<u64>(time::now_us().value),
+            std::hash<std::thread::id>()(std::this_thread::get_id())});
+    }
+
+    void profiler::end_scope() noexcept {
+        state_->emit_event(end_scope_info{
+            math::numeric_cast<u64>(time::now_us().value),
+            std::hash<std::thread::id>()(std::this_thread::get_id())});
+    }
+
+    void profiler::thread_event(str name) noexcept {
+        state_->emit_event(thread_event_info{
+            std::move(name),
+            math::numeric_cast<u64>(time::now_us().value),
+            std::hash<std::thread::id>()(std::this_thread::get_id())});
+    }
+
+    void profiler::global_event(str name) noexcept {
+        state_->emit_event(global_event_info{
+            std::move(name),
+            math::numeric_cast<u64>(time::now_us().value),
+            std::hash<std::thread::id>()(std::this_thread::get_id())});
+    }
 }

From 5cebd08df6d6c4f613a216b9a5c995fc221bc593 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 26 Dec 2019 04:34:25 +0700
Subject: [PATCH 05/19] fix minimized working

---
 sources/enduro2d/core/dbgui.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sources/enduro2d/core/dbgui.cpp b/sources/enduro2d/core/dbgui.cpp
index 1a02d7f1..c6fa9300 100644
--- a/sources/enduro2d/core/dbgui.cpp
+++ b/sources/enduro2d/core/dbgui.cpp
@@ -179,10 +179,10 @@ namespace e2d
 
             io.DisplaySize =
                 window_.real_size().cast_to<f32>();
-
-            io.DisplayFramebufferScale =
-                window_.framebuffer_size().cast_to<f32>() /
-                window_.real_size().cast_to<f32>();
+            
+            io.DisplayFramebufferScale = io.DisplaySize.x > 0.f && io.DisplaySize.y > 0.f
+                ? window_.framebuffer_size().cast_to<f32>() / v2f(io.DisplaySize)
+                : v2f(1.f, 1.f);
 
             window_.set_cursor_shape(
                 convert_imgui_mouse_cursor(

From 0c20db62b5852df13f811d39a647bc12ab9807a3 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 26 Dec 2019 07:28:54 +0700
Subject: [PATCH 06/19] remove cancel from defer, add buffer_view overload for
 create_shader function

---
 headers/enduro2d/core/render.hpp                    |  4 ++++
 headers/enduro2d/utils/defer.hpp                    |  9 +--------
 sources/enduro2d/core/render_impl/render_none.cpp   |  8 ++++++++
 sources/enduro2d/core/render_impl/render_opengl.cpp | 11 +++++++++++
 untests/sources/untests_utils/buffer.cpp            |  6 +++---
 5 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/headers/enduro2d/core/render.hpp b/headers/enduro2d/core/render.hpp
index e708ffff..e65402b1 100644
--- a/headers/enduro2d/core/render.hpp
+++ b/headers/enduro2d/core/render.hpp
@@ -906,6 +906,10 @@ namespace e2d
         shader_ptr create_shader(
             str_view vertex_source,
             str_view fragment_source);
+        
+        shader_ptr create_shader(
+            buffer_view vertex_source,
+            buffer_view fragment_source);
 
         shader_ptr create_shader(
             const input_stream_uptr& vertex_stream,
diff --git a/headers/enduro2d/utils/defer.hpp b/headers/enduro2d/utils/defer.hpp
index e569ffe9..4e680a54 100644
--- a/headers/enduro2d/utils/defer.hpp
+++ b/headers/enduro2d/utils/defer.hpp
@@ -19,17 +19,10 @@ namespace e2d
             : f_(std::move(f)) {}
 
             ~defer_impl() noexcept(std::is_nothrow_invocable_v<F>) {
-                if ( !cancelled_ ) {
-                    f_();
-                }
-            }
-
-            void cancel() noexcept {
-                cancelled_ = true;
+                f_();
             }
         private:
             F f_;
-            bool cancelled_{false};
         };
     }
 
diff --git a/sources/enduro2d/core/render_impl/render_none.cpp b/sources/enduro2d/core/render_impl/render_none.cpp
index 4713cfd7..11cd3f50 100644
--- a/sources/enduro2d/core/render_impl/render_none.cpp
+++ b/sources/enduro2d/core/render_impl/render_none.cpp
@@ -180,6 +180,14 @@ namespace e2d
         return nullptr;
     }
 
+    shader_ptr render::create_shader(
+        buffer_view vertex_source,
+        buffer_view fragment_source)
+    {
+        E2D_UNUSED(vertex_source, fragment_source);
+        return nullptr;
+    }
+
     shader_ptr render::create_shader(
         const input_stream_uptr& vertex_stream,
         const input_stream_uptr& fragment_stream)
diff --git a/sources/enduro2d/core/render_impl/render_opengl.cpp b/sources/enduro2d/core/render_impl/render_opengl.cpp
index 25580953..6d97d659 100644
--- a/sources/enduro2d/core/render_impl/render_opengl.cpp
+++ b/sources/enduro2d/core/render_impl/render_opengl.cpp
@@ -531,6 +531,17 @@ namespace e2d
                 state_->dbg(), std::move(ps)));
     }
 
+    shader_ptr render::create_shader(
+        buffer_view vertex_source,
+        buffer_view fragment_source)
+    {
+        E2D_ASSERT(is_in_main_thread());
+
+        return create_shader(
+            str_view(reinterpret_cast<const char*>(vertex_source.data()), vertex_source.size()),
+            str_view(reinterpret_cast<const char*>(fragment_source.data()), fragment_source.size()));
+    }
+
     shader_ptr render::create_shader(
         const input_stream_uptr& vertex,
         const input_stream_uptr& fragment)
diff --git a/untests/sources/untests_utils/buffer.cpp b/untests/sources/untests_utils/buffer.cpp
index 3345d160..dd8329df 100644
--- a/untests/sources/untests_utils/buffer.cpp
+++ b/untests/sources/untests_utils/buffer.cpp
@@ -221,10 +221,10 @@ TEST_CASE("buffer_view") {
         REQUIRE(v5.data() == b2.data());
         REQUIRE(v5.size() == 20);
 
-        str32 b3 = make_utf32("hello");
+        u32 b3[3] = {10, 20, 30};
         buffer_view v6(b3);
-        REQUIRE(v6.data() == b3.data());
-        REQUIRE(v6.size() == 20);
+        REQUIRE(v6.data() == &b3[0]);
+        REQUIRE(v6.size() == 12);
     }
     {
         const char* s0 = "hell";

From ad53361085ab4b9c3809c8a98aed32c948482461 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 26 Dec 2019 07:55:47 +0700
Subject: [PATCH 07/19] fix some warnings

---
 .../render_system_drawer.cpp                   | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/sources/enduro2d/high/systems/render_system_impl/render_system_drawer.cpp b/sources/enduro2d/high/systems/render_system_impl/render_system_drawer.cpp
index 18bcdba8..97ac41c2 100644
--- a/sources/enduro2d/high/systems/render_system_impl/render_system_drawer.cpp
+++ b/sources/enduro2d/high/systems/render_system_impl/render_system_drawer.cpp
@@ -192,8 +192,8 @@ namespace e2d::render_system_impl
 
             float* uvs = nullptr;
             unsigned short* indices = nullptr;
-            std::size_t index_count = 0;
-            std::size_t vertex_count = 0;
+            int index_count = 0;
+            int vertex_count = 0;
             const spAtlasPage* atlas_page = nullptr;
             const spColor* attachment_color = nullptr;
 
@@ -208,8 +208,10 @@ namespace e2d::render_system_impl
 
                 try {
                     vertex_count = 8;
-                    if ( temp_vertices.size() < vertex_count ) {
-                        temp_vertices.resize(math::max(temp_vertices.size() * 2u, vertex_count));
+                    if ( temp_vertices.size() < math::numeric_cast<std::size_t>(vertex_count) ) {
+                        temp_vertices.resize(math::max(
+                            temp_vertices.size() * 2u,
+                            math::numeric_cast<std::size_t>(vertex_count)));
                     }
                 } catch (...) {
                     property_cache_.clear();
@@ -239,8 +241,10 @@ namespace e2d::render_system_impl
 
                 try {
                     vertex_count = mesh->super.worldVerticesLength;
-                    if ( temp_vertices.size() < vertex_count ) {
-                        temp_vertices.resize(math::max(temp_vertices.size() * 2u, vertex_count));
+                    if ( temp_vertices.size() < math::numeric_cast<std::size_t>(vertex_count) ) {
+                        temp_vertices.resize(math::max(
+                            temp_vertices.size() * 2u,
+                            math::numeric_cast<std::size_t>(vertex_count)));
                     }
                 } catch (...) {
                     property_cache_.clear();
@@ -417,7 +421,7 @@ namespace e2d::render_system_impl
                 batcher_.batch(
                     mat_a,
                     property_cache_,
-                    indices, index_count,
+                    indices, math::numeric_cast<std::size_t>(index_count),
                     batch_vertices.data(), batch_vertex_count);
             } catch (...) {
                 property_cache_.clear();

From 17b11d1ee758a503c2603bb7868a810832aab968 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 26 Dec 2019 09:17:09 +0700
Subject: [PATCH 08/19] record profiler events

---
 headers/enduro2d/core/profiler.hpp |  99 ++++++++++++++++++++++----
 sources/enduro2d/core/engine.cpp   |  11 +--
 sources/enduro2d/core/profiler.cpp | 109 ++++++++++++++---------------
 3 files changed, 147 insertions(+), 72 deletions(-)

diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
index b084d8fb..89b2aec2 100644
--- a/headers/enduro2d/core/profiler.hpp
+++ b/headers/enduro2d/core/profiler.hpp
@@ -14,25 +14,25 @@ namespace e2d
     public:
         struct begin_scope_info {
             str name;
-            u64 ts = 0;
-            u64 tid = 0;
+            std::thread::id tid;
+            std::chrono::steady_clock::time_point tp;
         };
 
         struct end_scope_info {
-            u64 ts = 0;
-            u64 tid = 0;
+            std::thread::id tid;
+            std::chrono::steady_clock::time_point tp;
         };
 
         struct thread_event_info {
             str name;
-            u64 ts = 0;
-            u64 tid = 0;
+            std::thread::id tid;
+            std::chrono::steady_clock::time_point tp;
         };
 
         struct global_event_info {
             str name;
-            u64 ts = 0;
-            u64 tid = 0;
+            std::thread::id tid;
+            std::chrono::steady_clock::time_point tp;
         };
 
         using event_info = std::variant<
@@ -56,7 +56,7 @@ namespace e2d
             profiler& profiler_;
         };
     public:
-        profiler();
+        profiler(deferrer& d);
         ~profiler() noexcept final;
 
         void begin_scope(str name) noexcept;
@@ -64,22 +64,97 @@ namespace e2d
 
         void thread_event(str name) noexcept;
         void global_event(str name) noexcept;
+    public:
+        struct recording_info {
+            vector<event_info> events;
+        };
+
+        template < typename Rep, typename Period >
+        stdex::promise<recording_info> record_for(
+            const std::chrono::duration<Rep, Period>& timeout_duration);
+
+        template < typename Clock, typename Duration >
+        stdex::promise<recording_info> record_until(
+            const std::chrono::time_point<Clock, Duration>& timeout_time);
     public:
         template < typename T, typename... Args >
         T& register_sink(Args&&... args);
         sink& register_sink(sink_uptr sink);
         void unregister_sink(const sink& sink) noexcept;
     private:
-        class internal_state;
-        std::unique_ptr<internal_state> state_;
+        deferrer& deferrer_;
+        vector<sink_uptr> sinks_;
+        std::recursive_mutex rmutex_;
     };
 }
 
 #define E2D_PROFILER_SCOPE(name)\
-    auto E2D_PP_CAT(e2d_generated_profiler_scope_, __LINE__) = ::e2d::profiler::scope(the<profiler>(), name)
+    auto E2D_PP_CAT(e2d_generated_profiler_scope_, __LINE__) =\
+        ::e2d::profiler::scope(the<profiler>(), name)
 
 namespace e2d
 {
+    template < typename Rep, typename Period >
+    stdex::promise<profiler::recording_info> profiler::record_for(
+        const std::chrono::duration<Rep, Period>& timeout_duration)
+    {
+        return record_until(std::chrono::steady_clock::now() + timeout_duration);
+    }
+
+    template < typename Clock, typename Duration >
+    stdex::promise<profiler::recording_info> profiler::record_until(
+        const std::chrono::time_point<Clock, Duration>& timeout_time)
+    {
+        using promise_t = stdex::promise<recording_info>;
+        using time_point_t = std::chrono::time_point<Clock, Duration>;
+
+        class temp_sink final : public sink {
+        public:
+            temp_sink(time_point_t time_point)
+            : time_point_(time_point) {}
+
+            void on_event(const event_info& event) noexcept final {
+                try {
+                    info_.events.push_back(event);
+
+                    if ( std::holds_alternative<begin_scope_info>(event) ) {
+                        ++depth_;
+                    } else if ( std::holds_alternative<end_scope_info>(event) ) {
+                        E2D_ASSERT(depth_);
+                        --depth_;
+                    }
+
+                    if ( !depth_ && time_point_ <= Clock::now() ) {
+                        promise_.resolve(std::move(info_));
+                    }
+                } catch (...) {
+                    promise_.reject(std::current_exception());
+                }
+            }
+
+            promise_t& promise() noexcept {
+                return promise_;
+            }
+
+            const promise_t& promise() const noexcept {
+                return promise_;
+            }
+        private:
+            promise_t promise_;
+            recording_info info_;
+            std::size_t depth_{0u};
+            time_point_t time_point_;
+        };
+
+        temp_sink& s = register_sink<temp_sink>(timeout_time);
+        return s.promise().then([&s, this](auto&& info){
+            return deferrer_.do_in_main_thread([&s, this](auto&& info){
+                unregister_sink(s);
+                return std::forward<decltype(info)>(info);
+            }, std::forward<decltype(info)>(info));
+        });
+    }
+
     template < typename T, typename... Args >
     T& profiler::register_sink(Args&&... args) {
         return static_cast<T&>(
diff --git a/sources/enduro2d/core/engine.cpp b/sources/enduro2d/core/engine.cpp
index 6522d475..03029f8a 100644
--- a/sources/enduro2d/core/engine.cpp
+++ b/sources/enduro2d/core/engine.cpp
@@ -375,10 +375,6 @@ namespace e2d
     engine::engine(int argc, char *argv[], const parameters& params)
     : state_(new internal_state(params))
     {
-        // setup profiler
-
-        safe_module_initialize<profiler>();
-
         // setup platform
 
         safe_module_initialize<platform>(argc, argv);
@@ -387,6 +383,11 @@ namespace e2d
 
         safe_module_initialize<deferrer>();
 
+        // setup profiler
+
+        safe_module_initialize<profiler>(
+            the<deferrer>());
+
         // setup debug
 
         safe_module_initialize<debug>();
@@ -482,9 +483,9 @@ namespace e2d
         modules::shutdown<input>();
         modules::shutdown<vfs>();
         modules::shutdown<debug>();
+        modules::shutdown<profiler>();
         modules::shutdown<deferrer>();
         modules::shutdown<platform>();
-        modules::shutdown<profiler>();
     }
 
     bool engine::start(application_uptr app) {
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
index 5353ac78..eead2314 100644
--- a/sources/enduro2d/core/profiler.cpp
+++ b/sources/enduro2d/core/profiler.cpp
@@ -20,81 +20,80 @@ namespace e2d
 
 namespace e2d
 {
-    class profiler::internal_state final : private e2d::noncopyable {
-    public:
-        internal_state() = default;
-        ~internal_state() noexcept = default;
-
-        sink& register_sink(sink_uptr sink) {
-            E2D_ASSERT(sink);
-            std::lock_guard<std::recursive_mutex> guard(rmutex_);
-            sinks_.push_back(std::move(sink));
-            return *sinks_.back();
-        }
-
-        void unregister_sink(const sink& sink) noexcept {
-            std::lock_guard<std::recursive_mutex> guard(rmutex_);
-            for ( auto iter = sinks_.begin(); iter != sinks_.end(); ) {
-                if ( iter->get() == &sink ) {
-                    iter = sinks_.erase(iter);
-                } else {
-                    ++iter;
-                }
-            }
-        }
-
-        void emit_event(event_info event) noexcept {
-            std::lock_guard<std::recursive_mutex> guard(rmutex_);
-            for ( const auto& sink : sinks_ ) {
-                if ( sink ) {
-                    sink->on_event(event);
-                }
-            }
-        }
-    private:
-        vector<sink_uptr> sinks_;
-        std::recursive_mutex rmutex_;
-    };
-}
-
-namespace e2d
-{
-    profiler::profiler()
-    : state_(new internal_state()) {}
+    profiler::profiler(deferrer& d)
+    : deferrer_(d) {}
     profiler::~profiler() noexcept = default;
 
     profiler::sink& profiler::register_sink(sink_uptr sink) {
-        return state_->register_sink(std::move(sink));
+        E2D_ASSERT(sink);
+        std::lock_guard guard(rmutex_);
+        sinks_.push_back(std::move(sink));
+        return *sinks_.back();
     }
 
     void profiler::unregister_sink(const sink& sink) noexcept {
-        state_->unregister_sink(sink);
+        std::lock_guard guard(rmutex_);
+        for ( auto iter = sinks_.begin(); iter != sinks_.end(); ) {
+            if ( iter->get() == &sink ) {
+                iter = sinks_.erase(iter);
+            } else {
+                ++iter;
+            }
+        }
     }
 
     void profiler::begin_scope(str name) noexcept {
-        state_->emit_event(begin_scope_info{
+        begin_scope_info event{
             std::move(name),
-            math::numeric_cast<u64>(time::now_us().value),
-            std::hash<std::thread::id>()(std::this_thread::get_id())});
+            std::this_thread::get_id(),
+            std::chrono::steady_clock::now()};
+        
+        std::lock_guard guard(rmutex_);
+        for ( const auto& sink : sinks_ ) {
+            if ( sink ) {
+                sink->on_event(event);
+            }
+        }
     }
 
     void profiler::end_scope() noexcept {
-        state_->emit_event(end_scope_info{
-            math::numeric_cast<u64>(time::now_us().value),
-            std::hash<std::thread::id>()(std::this_thread::get_id())});
+        end_scope_info event{
+            std::this_thread::get_id(),
+            std::chrono::steady_clock::now()};
+        
+        std::lock_guard guard(rmutex_);
+        for ( const auto& sink : sinks_ ) {
+            if ( sink ) {
+                sink->on_event(event);
+            }
+        }
     }
 
     void profiler::thread_event(str name) noexcept {
-        state_->emit_event(thread_event_info{
+        thread_event_info event{
             std::move(name),
-            math::numeric_cast<u64>(time::now_us().value),
-            std::hash<std::thread::id>()(std::this_thread::get_id())});
+            std::this_thread::get_id(),
+            std::chrono::steady_clock::now()};
+        
+        std::lock_guard guard(rmutex_);
+        for ( const auto& sink : sinks_ ) {
+            if ( sink ) {
+                sink->on_event(event);
+            }
+        }
     }
 
     void profiler::global_event(str name) noexcept {
-        state_->emit_event(global_event_info{
+        global_event_info event{
             std::move(name),
-            math::numeric_cast<u64>(time::now_us().value),
-            std::hash<std::thread::id>()(std::this_thread::get_id())});
+            std::this_thread::get_id(),
+            std::chrono::steady_clock::now()};
+        
+        std::lock_guard guard(rmutex_);
+        for ( const auto& sink : sinks_ ) {
+            if ( sink ) {
+                sink->on_event(event);
+            }
+        }
     }
 }

From 2520e64760afa1cf99cad2281154c93c0e2d14de Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Sat, 28 Dec 2019 06:00:07 +0700
Subject: [PATCH 09/19] save profiler recording info to chrome tracing format

---
 headers/enduro2d/core/profiler.hpp | 53 ++++++++++++-----
 sources/enduro2d/core/profiler.cpp | 92 ++++++++++++++++++++++++++++--
 2 files changed, 126 insertions(+), 19 deletions(-)

diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
index 89b2aec2..4540079d 100644
--- a/headers/enduro2d/core/profiler.hpp
+++ b/headers/enduro2d/core/profiler.hpp
@@ -15,24 +15,24 @@ namespace e2d
         struct begin_scope_info {
             str name;
             std::thread::id tid;
-            std::chrono::steady_clock::time_point tp;
+            std::chrono::microseconds tp;
         };
 
         struct end_scope_info {
             std::thread::id tid;
-            std::chrono::steady_clock::time_point tp;
+            std::chrono::microseconds tp;
         };
 
         struct thread_event_info {
             str name;
             std::thread::id tid;
-            std::chrono::steady_clock::time_point tp;
+            std::chrono::microseconds tp;
         };
 
         struct global_event_info {
             str name;
             std::thread::id tid;
-            std::chrono::steady_clock::time_point tp;
+            std::chrono::microseconds tp;
         };
 
         using event_info = std::variant<
@@ -83,6 +83,7 @@ namespace e2d
         void unregister_sink(const sink& sink) noexcept;
     private:
         deferrer& deferrer_;
+        std::size_t depth_{0u};
         vector<sink_uptr> sinks_;
         std::recursive_mutex rmutex_;
     };
@@ -92,6 +93,12 @@ namespace e2d
     auto E2D_PP_CAT(e2d_generated_profiler_scope_, __LINE__) =\
         ::e2d::profiler::scope(the<profiler>(), name)
 
+#define E2D_PROFILER_THREAD_EVENT(name)\
+    the<profiler>().thread_event(name)
+
+#define E2D_PROFILER_GLOBAL_EVENT(name)\
+    the<profiler>().global_event(name)
+
 namespace e2d
 {
     template < typename Rep, typename Period >
@@ -110,20 +117,25 @@ namespace e2d
 
         class temp_sink final : public sink {
         public:
-            temp_sink(time_point_t time_point)
-            : time_point_(time_point) {}
+            temp_sink(std::size_t depth, time_point_t time_point)
+            : depth_(depth)
+            , time_point_(time_point) {}
 
             void on_event(const event_info& event) noexcept final {
+                const bool skip = info_.events.empty() && depth_;
+                
+                if ( std::holds_alternative<begin_scope_info>(event) ) {
+                    ++depth_;
+                } else if ( std::holds_alternative<end_scope_info>(event) ) {
+                    E2D_ASSERT(depth_);
+                    --depth_;
+                }
+
                 try {
-                    info_.events.push_back(event);
-
-                    if ( std::holds_alternative<begin_scope_info>(event) ) {
-                        ++depth_;
-                    } else if ( std::holds_alternative<end_scope_info>(event) ) {
-                        E2D_ASSERT(depth_);
-                        --depth_;
+                    if ( !skip ) {
+                        info_.events.push_back(event);
                     }
-
+                    
                     if ( !depth_ && time_point_ <= Clock::now() ) {
                         promise_.resolve(std::move(info_));
                     }
@@ -146,7 +158,7 @@ namespace e2d
             time_point_t time_point_;
         };
 
-        temp_sink& s = register_sink<temp_sink>(timeout_time);
+        temp_sink& s = register_sink<temp_sink>(depth_, timeout_time);
         return s.promise().then([&s, this](auto&& info){
             return deferrer_.do_in_main_thread([&s, this](auto&& info){
                 unregister_sink(s);
@@ -161,3 +173,14 @@ namespace e2d
             register_sink(std::make_unique<T>(std::forward<Args>(args)...)));
     }
 }
+
+namespace e2d::profilers
+{
+    bool try_save_recording_info(
+        const profiler::recording_info& src,
+        buffer& dst) noexcept;
+    
+    bool try_save_recording_info(
+        const profiler::recording_info& src,
+        const output_stream_uptr& dst) noexcept;
+}
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
index eead2314..ab999b35 100644
--- a/sources/enduro2d/core/profiler.cpp
+++ b/sources/enduro2d/core/profiler.cpp
@@ -6,6 +6,60 @@
 
 #include <enduro2d/core/profiler.hpp>
 
+namespace
+{
+    using namespace e2d;
+
+    str recording_info_to_json(const profiler::recording_info& src) {
+        str dst("{\"traceEvents\":[\n");
+        for ( std::size_t i = 0; i < src.events.size(); ++i ) {
+            std::visit(utils::overloaded {
+                [&dst](const profiler::begin_scope_info& e){
+                    char buf[512] = {'\0'};
+                    strings::format(buf, std::size(buf),
+                        "  {\"name\":\"%0\", \"ph\":\"B\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        e.name,
+                        e.tp.count(),
+                        std::hash<std::thread::id>()(e.tid));
+                    dst += buf;
+                },
+                [&dst](const profiler::end_scope_info& e){
+                    char buf[512] = {'\0'};
+                    strings::format(buf, std::size(buf),
+                        "  {\"ph\":\"E\", \"ts\":%0, \"tid\":%1, \"pid\":0}",
+                        e.tp.count(),
+                        std::hash<std::thread::id>()(e.tid));
+                    dst += buf;
+                },
+                [&dst](const profiler::thread_event_info& e){
+                    char buf[512] = {'\0'};
+                    strings::format(buf, std::size(buf),
+                        "  {\"name\":\"%0\", \"ph\":\"i\", \"s\":\"t\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        e.name,
+                        e.tp.count(),
+                        std::hash<std::thread::id>()(e.tid));
+                    dst += buf;
+                },
+                [&dst](const profiler::global_event_info& e){
+                    char buf[512] = {'\0'};
+                    strings::format(buf, std::size(buf),
+                        "  {\"name\":\"%0\", \"ph\":\"i\", \"s\":\"g\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        e.name,
+                        e.tp.count(),
+                        std::hash<std::thread::id>()(e.tid));
+                    dst += buf;
+                }
+            }, src.events[i]);
+
+            if ( i < src.events.size() - 1u ) {
+                dst += ",\n";
+            }
+        }
+        dst += "\n]}";
+        return dst;
+    }
+}
+
 namespace e2d
 {
     profiler::scope::scope(profiler& profiler, str name)
@@ -43,10 +97,12 @@ namespace e2d
     }
 
     void profiler::begin_scope(str name) noexcept {
+        ++depth_;
+
         begin_scope_info event{
             std::move(name),
             std::this_thread::get_id(),
-            std::chrono::steady_clock::now()};
+            time::to_chrono(time::now_us())};
         
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
@@ -57,9 +113,12 @@ namespace e2d
     }
 
     void profiler::end_scope() noexcept {
+        E2D_ASSERT(depth_);
+        --depth_;
+
         end_scope_info event{
             std::this_thread::get_id(),
-            std::chrono::steady_clock::now()};
+            time::to_chrono(time::now_us())};
         
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
@@ -73,7 +132,7 @@ namespace e2d
         thread_event_info event{
             std::move(name),
             std::this_thread::get_id(),
-            std::chrono::steady_clock::now()};
+            time::to_chrono(time::now_us())};
         
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
@@ -87,7 +146,7 @@ namespace e2d
         global_event_info event{
             std::move(name),
             std::this_thread::get_id(),
-            std::chrono::steady_clock::now()};
+            time::to_chrono(time::now_us())};
         
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
@@ -97,3 +156,28 @@ namespace e2d
         }
     }
 }
+
+namespace e2d::profilers
+{
+    bool try_save_recording_info(
+        const profiler::recording_info& src,
+        buffer& dst) noexcept
+    {
+        try {
+            str json = recording_info_to_json(src);
+            dst.assign(json.data(), json.size());
+            return true;
+        } catch (...) {
+            return false;
+        }
+    }
+    
+    bool try_save_recording_info(
+        const profiler::recording_info& src,
+        const output_stream_uptr& dst) noexcept
+    {
+        buffer file_data;
+        return try_save_recording_info(src, file_data)
+            && streams::try_write_tail(file_data, dst);
+    }
+}

From c2bfbfcce7a465b2c26b4b2a331852564b16e2d6 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Sat, 28 Dec 2019 07:45:13 +0700
Subject: [PATCH 10/19] add basic profiler scopes

---
 headers/enduro2d/core/deferrer.hpp            |  2 +
 sources/enduro2d/core/dbgui.cpp               |  2 +
 sources/enduro2d/core/dbgui_impl/dbgui.hpp    |  1 +
 sources/enduro2d/core/deferrer.cpp            |  7 +++
 sources/enduro2d/core/engine.cpp              |  7 ++-
 sources/enduro2d/core/input.cpp               |  3 +
 sources/enduro2d/core/window_impl/window.hpp  |  1 +
 .../enduro2d/core/window_impl/window_glfw.cpp |  2 +
 sources/enduro2d/high/starter.cpp             | 59 +++++++++++++++----
 .../enduro2d/high/systems/flipbook_system.cpp |  1 +
 .../enduro2d/high/systems/label_system.cpp    |  1 +
 .../enduro2d/high/systems/render_system.cpp   |  1 +
 .../enduro2d/high/systems/script_system.cpp   |  2 +
 .../enduro2d/high/systems/spine_system.cpp    |  1 +
 14 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/headers/enduro2d/core/deferrer.hpp b/headers/enduro2d/core/deferrer.hpp
index f7489d62..5eb80f82 100644
--- a/headers/enduro2d/core/deferrer.hpp
+++ b/headers/enduro2d/core/deferrer.hpp
@@ -33,6 +33,8 @@ namespace e2d
 
         template < typename T >
         void active_safe_wait_promise(const stdex::promise<T>& promise) noexcept;
+
+        void frame_tick() noexcept;
     private:
         stdex::jobber worker_;
         stdex::scheduler scheduler_;
diff --git a/sources/enduro2d/core/dbgui.cpp b/sources/enduro2d/core/dbgui.cpp
index c6fa9300..96737ea4 100644
--- a/sources/enduro2d/core/dbgui.cpp
+++ b/sources/enduro2d/core/dbgui.cpp
@@ -448,6 +448,7 @@ namespace e2d
     }
 
     void dbgui::frame_tick() {
+        E2D_PROFILER_SCOPE("dbgui.frame_tick");
         state_->frame_tick();
 
         if ( visible() ) {
@@ -456,6 +457,7 @@ namespace e2d
     }
 
     void dbgui::frame_render() {
+        E2D_PROFILER_SCOPE("dbgui.frame_render");
         state_->frame_render();
     }
 }
diff --git a/sources/enduro2d/core/dbgui_impl/dbgui.hpp b/sources/enduro2d/core/dbgui_impl/dbgui.hpp
index 59e7e2c2..48b98422 100644
--- a/sources/enduro2d/core/dbgui_impl/dbgui.hpp
+++ b/sources/enduro2d/core/dbgui_impl/dbgui.hpp
@@ -11,6 +11,7 @@
 #include <enduro2d/core/debug.hpp>
 #include <enduro2d/core/engine.hpp>
 #include <enduro2d/core/input.hpp>
+#include <enduro2d/core/profiler.hpp>
 #include <enduro2d/core/render.hpp>
 #include <enduro2d/core/window.hpp>
 
diff --git a/sources/enduro2d/core/deferrer.cpp b/sources/enduro2d/core/deferrer.cpp
index 68251529..5a34a1a6 100644
--- a/sources/enduro2d/core/deferrer.cpp
+++ b/sources/enduro2d/core/deferrer.cpp
@@ -6,6 +6,8 @@
 
 #include <enduro2d/core/deferrer.hpp>
 
+#include <enduro2d/core/profiler.hpp>
+
 namespace e2d
 {
     deferrer::deferrer()
@@ -26,4 +28,9 @@ namespace e2d
     const stdex::scheduler& deferrer::scheduler() const noexcept {
         return scheduler_;
     }
+
+    void deferrer::frame_tick() noexcept {
+        E2D_PROFILER_SCOPE("deferrer.frame_tick");
+        scheduler_.process_all_tasks();
+    }
 }
diff --git a/sources/enduro2d/core/engine.cpp b/sources/enduro2d/core/engine.cpp
index 03029f8a..964ea43b 100644
--- a/sources/enduro2d/core/engine.cpp
+++ b/sources/enduro2d/core/engine.cpp
@@ -320,6 +320,8 @@ namespace e2d
         }
     public:
         void calculate_end_frame_timers() noexcept {
+            E2D_PROFILER_SCOPE("engine.wait_for_target_fps");
+
             const auto second_us = time::second_us<u64>();
 
             const auto minimal_delta_time_us =
@@ -499,7 +501,7 @@ namespace e2d
         while ( true ) {
             try {
                 the<dbgui>().frame_tick();
-                the<deferrer>().scheduler().process_all_tasks();
+                the<deferrer>().frame_tick();
 
                 if ( !app->frame_tick() ) {
                     break;
@@ -517,8 +519,11 @@ namespace e2d
                 app->shutdown();
                 throw;
             }
+            
             the<input>().frame_tick();
             window::poll_events();
+
+            E2D_PROFILER_GLOBAL_EVENT("engine.end_of_frame");
         }
 
         app->shutdown();
diff --git a/sources/enduro2d/core/input.cpp b/sources/enduro2d/core/input.cpp
index d355a6cf..9fcdd1ed 100644
--- a/sources/enduro2d/core/input.cpp
+++ b/sources/enduro2d/core/input.cpp
@@ -6,6 +6,8 @@
 
 #include <enduro2d/core/input.hpp>
 
+#include <enduro2d/core/profiler.hpp>
+
 namespace e2d
 {
     //
@@ -364,6 +366,7 @@ namespace e2d
     }
 
     void input::frame_tick() noexcept {
+        E2D_PROFILER_SCOPE("input.frame_tick");
         state_->mouse.state_->frame_tick();
         state_->keyboard.state_->frame_tick();
     }
diff --git a/sources/enduro2d/core/window_impl/window.hpp b/sources/enduro2d/core/window_impl/window.hpp
index cf066637..92167dc4 100644
--- a/sources/enduro2d/core/window_impl/window.hpp
+++ b/sources/enduro2d/core/window_impl/window.hpp
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <enduro2d/core/debug.hpp>
+#include <enduro2d/core/profiler.hpp>
 #include <enduro2d/core/window.hpp>
 
 #define E2D_WINDOW_MODE_NONE 1
diff --git a/sources/enduro2d/core/window_impl/window_glfw.cpp b/sources/enduro2d/core/window_impl/window_glfw.cpp
index 408da1e7..710a35eb 100644
--- a/sources/enduro2d/core/window_impl/window_glfw.cpp
+++ b/sources/enduro2d/core/window_impl/window_glfw.cpp
@@ -691,6 +691,7 @@ namespace e2d
     }
 
     void window::swap_buffers() noexcept {
+        E2D_PROFILER_SCOPE("window.swap_buffers");
         std::lock_guard<std::recursive_mutex> guard(state_->rmutex);
         E2D_ASSERT(
             state_->window &&
@@ -699,6 +700,7 @@ namespace e2d
     }
 
     bool window::poll_events() noexcept {
+        E2D_PROFILER_SCOPE("window.poll_events");
         return glfw_state::poll_events();
     }
 
diff --git a/sources/enduro2d/high/starter.cpp b/sources/enduro2d/high/starter.cpp
index 41a8d2cf..e2c4f587 100644
--- a/sources/enduro2d/high/starter.cpp
+++ b/sources/enduro2d/high/starter.cpp
@@ -70,31 +70,68 @@ namespace
         }
 
         bool frame_tick() final {
+            E2D_PROFILER_SCOPE("application.frame_tick");
+
+            world& w = the<world>();
             engine& e = the<engine>();
+
             const f32 dt = e.delta_time();
             const f32 time = e.time();
 
-            ecs::registry& registry = the<world>().registry();
-            registry.process_event(systems::pre_update_event{dt,time});
-            registry.process_event(systems::update_event{dt,time});
-            registry.process_event(systems::post_update_event{dt,time});
+            {
+                E2D_PROFILER_SCOPE("ecs.pre_update");
+                w.registry().process_event(systems::pre_update_event{dt,time});
+            }
+
+            {
+                E2D_PROFILER_SCOPE("ecs.update");
+                w.registry().process_event(systems::update_event{dt,time});
+            }
+
+            {
+                E2D_PROFILER_SCOPE("ecs.post_update");
+                w.registry().process_event(systems::post_update_event{dt,time});
+            }
 
             return !the<window>().should_close()
                 || (application_ && !application_->on_should_close());
         }
 
         void frame_render() final {
-            ecs::registry& registry = the<world>().registry();
-            registry.process_event(systems::pre_render_event{});
-            registry.process_event(systems::render_event{});
-            registry.process_event(systems::post_render_event{});
+            E2D_PROFILER_SCOPE("application.frame_render");
+           
+            world& w = the<world>();
+
+            {
+                E2D_PROFILER_SCOPE("ecs.pre_render");
+                w.registry().process_event(systems::pre_render_event{});
+            }
+
+            {
+                E2D_PROFILER_SCOPE("ecs.render");
+                w.registry().process_event(systems::render_event{});
+            }
+
+            {
+                E2D_PROFILER_SCOPE("ecs.post_render");
+                w.registry().process_event(systems::post_render_event{});
+            }
         }
 
         void frame_finalize() final {
+            E2D_PROFILER_SCOPE("application.frame_finalize");
+
             world& w = the<world>();
-            ecs::registry& registry = w.registry();
-            registry.process_event(systems::frame_finalize_event{});
-            w.finalize_instances();
+
+            {
+                E2D_PROFILER_SCOPE("ecs.frame_finalize");
+                w.registry().process_event(systems::frame_finalize_event{});
+            }
+
+            {
+                E2D_PROFILER_SCOPE("world.finalize_instances");
+                w.finalize_instances();
+            }
         }
     private:
         starter::application_uptr application_;
diff --git a/sources/enduro2d/high/systems/flipbook_system.cpp b/sources/enduro2d/high/systems/flipbook_system.cpp
index b1aa8067..c79a1730 100644
--- a/sources/enduro2d/high/systems/flipbook_system.cpp
+++ b/sources/enduro2d/high/systems/flipbook_system.cpp
@@ -100,6 +100,7 @@ namespace e2d
         ecs::registry& owner,
         const ecs::after<systems::update_event>& trigger)
     {
+        E2D_PROFILER_SCOPE("flipbook_system.process");
         state_->process(trigger.event.dt, owner);
     }
 }
diff --git a/sources/enduro2d/high/systems/label_system.cpp b/sources/enduro2d/high/systems/label_system.cpp
index 0164deaa..d0e273d4 100644
--- a/sources/enduro2d/high/systems/label_system.cpp
+++ b/sources/enduro2d/high/systems/label_system.cpp
@@ -396,6 +396,7 @@ namespace e2d
         const ecs::after<systems::update_event>& trigger)
     {
         E2D_UNUSED(trigger);
+        E2D_PROFILER_SCOPE("label_system.process");
         state_->process(owner);
     }
 }
diff --git a/sources/enduro2d/high/systems/render_system.cpp b/sources/enduro2d/high/systems/render_system.cpp
index 7f82e91f..8462475a 100644
--- a/sources/enduro2d/high/systems/render_system.cpp
+++ b/sources/enduro2d/high/systems/render_system.cpp
@@ -93,6 +93,7 @@ namespace e2d
         const ecs::after<systems::render_event>& trigger)
     {
         E2D_UNUSED(trigger);
+        E2D_PROFILER_SCOPE("render_system.process");
         state_->process(owner);
     }
 }
diff --git a/sources/enduro2d/high/systems/script_system.cpp b/sources/enduro2d/high/systems/script_system.cpp
index 142f48dd..da5d62d8 100644
--- a/sources/enduro2d/high/systems/script_system.cpp
+++ b/sources/enduro2d/high/systems/script_system.cpp
@@ -123,6 +123,7 @@ namespace e2d
         const systems::update_event& event)
     {
         E2D_UNUSED(event);
+        E2D_PROFILER_SCOPE("script_system.process");
         state_->update_process(owner);
     }
 
@@ -131,6 +132,7 @@ namespace e2d
         const ecs::before<systems::update_event>& trigger)
     {
         E2D_UNUSED(trigger);
+        E2D_PROFILER_SCOPE("script_system.process");
         state_->process_events(owner);
     }
 }
diff --git a/sources/enduro2d/high/systems/spine_system.cpp b/sources/enduro2d/high/systems/spine_system.cpp
index 4ec2d47f..f46517f5 100644
--- a/sources/enduro2d/high/systems/spine_system.cpp
+++ b/sources/enduro2d/high/systems/spine_system.cpp
@@ -258,6 +258,7 @@ namespace e2d
         ecs::registry& owner,
         const ecs::after<systems::update_event>& trigger)
     {
+        E2D_PROFILER_SCOPE("spine_system.process");
         state_->process(trigger.event.dt, owner);
     }
 }

From 53519a9bc518481eda3f56ad317383c48101d66e Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Sun, 29 Dec 2019 00:31:05 +0700
Subject: [PATCH 11/19] update promise module

---
 headers/enduro2d/core/_core.hpp | 2 --
 modules/promise.hpp             | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/headers/enduro2d/core/_core.hpp b/headers/enduro2d/core/_core.hpp
index be0a4675..b36cd0a4 100644
--- a/headers/enduro2d/core/_core.hpp
+++ b/headers/enduro2d/core/_core.hpp
@@ -12,7 +12,6 @@
 
 #include <curly.hpp/curly.hpp>
 
-#include <promise.hpp/invoke.hpp>
 #include <promise.hpp/jobber.hpp>
 #include <promise.hpp/promise.hpp>
 #include <promise.hpp/scheduler.hpp>
@@ -26,7 +25,6 @@ namespace e2d
 
     namespace stdex
     {
-        using namespace invoke_hpp;
         using namespace jobber_hpp;
         using namespace promise_hpp;
         using namespace scheduler_hpp;
diff --git a/modules/promise.hpp b/modules/promise.hpp
index 8ed2aad2..388fcb3e 160000
--- a/modules/promise.hpp
+++ b/modules/promise.hpp
@@ -1 +1 @@
-Subproject commit 8ed2aad253dab8b198cd61f1050cf83411524436
+Subproject commit 388fcb3ead7bf057f89ace08807b705ab3944af0

From 3cb489073702a1bf37b4e23d86b75e2c97689ed4 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Sun, 29 Dec 2019 00:34:04 +0700
Subject: [PATCH 12/19] utils: add schemepath function for url

---
 headers/enduro2d/utils/url.hpp        | 2 ++
 sources/enduro2d/utils/url.cpp        | 9 +++++++++
 untests/sources/untests_utils/url.cpp | 4 ++++
 3 files changed, 15 insertions(+)

diff --git a/headers/enduro2d/utils/url.hpp b/headers/enduro2d/utils/url.hpp
index 457f6427..4e1c5102 100644
--- a/headers/enduro2d/utils/url.hpp
+++ b/headers/enduro2d/utils/url.hpp
@@ -38,6 +38,8 @@ namespace e2d
 
         const str& scheme() const noexcept;
         const str& path() const noexcept;
+        
+        str schemepath() const;
 
         url& operator+=(str_view path);
         url& operator/=(str_view path);
diff --git a/sources/enduro2d/utils/url.cpp b/sources/enduro2d/utils/url.cpp
index ef8b23c8..c59a88ed 100644
--- a/sources/enduro2d/utils/url.cpp
+++ b/sources/enduro2d/utils/url.cpp
@@ -135,6 +135,15 @@ namespace e2d
         return path_;
     }
 
+    str url::schemepath() const {
+        str result;
+        result.reserve(scheme_.size() + scheme_separator.size() + path_.size());
+        result.append(scheme_);
+        result.append(scheme_separator);
+        result.append(path_);
+        return result;
+    }
+
     url& url::operator+=(str_view path) {
         return concat(path);
     }
diff --git a/untests/sources/untests_utils/url.cpp b/untests/sources/untests_utils/url.cpp
index c82ee0ec..028ad4b7 100644
--- a/untests/sources/untests_utils/url.cpp
+++ b/untests/sources/untests_utils/url.cpp
@@ -19,24 +19,28 @@ TEST_CASE("url") {
         REQUIRE(u.empty());
         REQUIRE(u.scheme().empty());
         REQUIRE(u.path().empty());
+        REQUIRE(u.schemepath() == "://");
     }
     {
         url u("://file");
         REQUIRE(!u.empty());
         REQUIRE(u.scheme().empty());
         REQUIRE(u.path() == "file");
+        REQUIRE(u.schemepath() == "://file");
     }
     {
         url u("file://");
         REQUIRE(u.empty());
         REQUIRE(u.scheme() == "file");
         REQUIRE(u.path().empty());
+        REQUIRE(u.schemepath() == "file://");
     }
     {
         url u("file://test_file");
         REQUIRE(!u.empty());
         REQUIRE(u.scheme() == "file");
         REQUIRE(u.path() == "test_file");
+        REQUIRE(u.schemepath() == "file://test_file");
     }
     {
         url u("dir/file");

From 349d88bc055024282c22a9f45edcb8ba6bb45d03 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Sun, 29 Dec 2019 00:36:43 +0700
Subject: [PATCH 13/19] vfs worker access

---
 headers/enduro2d/core/vfs.hpp |  9 ++++++---
 sources/enduro2d/core/vfs.cpp | 11 ++++++++++-
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/headers/enduro2d/core/vfs.hpp b/headers/enduro2d/core/vfs.hpp
index 08f4fdc1..d7850c03 100644
--- a/headers/enduro2d/core/vfs.hpp
+++ b/headers/enduro2d/core/vfs.hpp
@@ -25,9 +25,6 @@ namespace e2d
 
     class vfs final : public module<vfs> {
     public:
-        vfs();
-        ~vfs() noexcept final;
-
         class file_source : private e2d::noncopyable {
         public:
             virtual ~file_source() noexcept = default;
@@ -38,6 +35,12 @@ namespace e2d
             virtual bool trace(str_view path, filesystem::trace_func func) const = 0;
         };
         using file_source_uptr = std::unique_ptr<file_source>;
+    public:
+        vfs();
+        ~vfs() noexcept final;
+
+        stdex::jobber& worker() noexcept;
+        const stdex::jobber& worker() const noexcept;
 
         template < typename T, typename... Args >
         bool register_scheme(str_view scheme, Args&&... args);
diff --git a/sources/enduro2d/core/vfs.cpp b/sources/enduro2d/core/vfs.cpp
index 6fdeaded..506303e0 100644
--- a/sources/enduro2d/core/vfs.cpp
+++ b/sources/enduro2d/core/vfs.cpp
@@ -108,9 +108,18 @@ namespace e2d
 
     vfs::vfs()
     : state_(new state()){}
-
     vfs::~vfs() noexcept = default;
 
+    stdex::jobber& vfs::worker() noexcept {
+        std::lock_guard<std::mutex> guard(state_->mutex);
+        return state_->worker;
+    }
+
+    const stdex::jobber& vfs::worker() const noexcept {
+        std::lock_guard<std::mutex> guard(state_->mutex);
+        return state_->worker;
+    }
+
     bool vfs::register_scheme(str_view scheme, file_source_uptr source) {
         std::lock_guard<std::mutex> guard(state_->mutex);
         return (source && source->valid())

From 0766d75ba740afeb1ccb842f7939b0a48f02c289 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 9 Jan 2020 13:26:29 +0700
Subject: [PATCH 14/19] little less overloaded core functionality

---
 headers/enduro2d/core/audio.hpp               |  5 +-
 headers/enduro2d/core/input.hpp               | 14 ----
 headers/enduro2d/core/render.hpp              |  7 --
 headers/enduro2d/core/vfs.hpp                 |  4 +-
 headers/enduro2d/core/window.hpp              | 16 ++++-
 samples/sources/sample_00/sample_00.cpp       | 19 +++--
 samples/sources/sample_01/sample_01.cpp       | 12 ++--
 samples/sources/sample_02/sample_02.cpp       | 12 ++--
 samples/sources/sample_05/sample_05.cpp       |  4 +-
 .../enduro2d/core/audio_impl/audio_bass.cpp   | 19 +----
 .../enduro2d/core/audio_impl/audio_none.cpp   |  9 +--
 sources/enduro2d/core/input.cpp               | 28 --------
 .../enduro2d/core/render_impl/render_none.cpp | 13 ----
 .../core/render_impl/render_opengl.cpp        | 25 -------
 sources/enduro2d/core/vfs.cpp                 | 20 +++---
 sources/enduro2d/core/window.cpp              | 70 ++++++++++++-------
 sources/enduro2d/high/assets/sound_asset.cpp  |  2 +-
 untests/sources/untests_core/vfs.cpp          | 34 +++++----
 18 files changed, 117 insertions(+), 196 deletions(-)

diff --git a/headers/enduro2d/core/audio.hpp b/headers/enduro2d/core/audio.hpp
index cccfcbab..824dbe16 100644
--- a/headers/enduro2d/core/audio.hpp
+++ b/headers/enduro2d/core/audio.hpp
@@ -83,12 +83,9 @@ namespace e2d
         audio(debug& d);
         ~audio() noexcept;
 
-        [[nodiscard]] sound_stream_ptr preload_stream(
+        [[nodiscard]] sound_stream_ptr create_stream(
             buffer_view sound_data);
 
-        [[nodiscard]] sound_stream_ptr preload_stream(
-            const input_stream_uptr& file_stream);
-
         [[nodiscard]] sound_stream_ptr create_stream(
             input_stream_uptr file_stream);
 
diff --git a/headers/enduro2d/core/input.hpp b/headers/enduro2d/core/input.hpp
index 3517b91f..7af711a8 100644
--- a/headers/enduro2d/core/input.hpp
+++ b/headers/enduro2d/core/input.hpp
@@ -8,8 +8,6 @@
 
 #include "_core.hpp"
 
-#include "window.hpp"
-
 namespace e2d
 {
     class mouse final : private noncopyable {
@@ -120,16 +118,4 @@ namespace e2d
         class internal_state;
         std::unique_ptr<internal_state> state_;
     };
-
-    class window_input_source : public window::event_listener {
-    public:
-        window_input_source(input& input) noexcept;
-        void on_input_char(char32_t uchar) noexcept final;
-        void on_move_cursor(const v2f& pos) noexcept final;
-        void on_mouse_scroll(const v2f& delta) noexcept final;
-        void on_mouse_button(mouse_button btn, mouse_button_action act) noexcept final;
-        void on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept final;
-    private:
-        input& input_;
-    };
 }
diff --git a/headers/enduro2d/core/render.hpp b/headers/enduro2d/core/render.hpp
index e65402b1..c535d7e2 100644
--- a/headers/enduro2d/core/render.hpp
+++ b/headers/enduro2d/core/render.hpp
@@ -911,16 +911,9 @@ namespace e2d
             buffer_view vertex_source,
             buffer_view fragment_source);
 
-        shader_ptr create_shader(
-            const input_stream_uptr& vertex_stream,
-            const input_stream_uptr& fragment_stream);
-
         texture_ptr create_texture(
             const image& image);
 
-        texture_ptr create_texture(
-            const input_stream_uptr& image_stream);
-
         texture_ptr create_texture(
             const v2u& size,
             const pixel_declaration& decl);
diff --git a/headers/enduro2d/core/vfs.hpp b/headers/enduro2d/core/vfs.hpp
index d7850c03..24094ac5 100644
--- a/headers/enduro2d/core/vfs.hpp
+++ b/headers/enduro2d/core/vfs.hpp
@@ -55,10 +55,10 @@ namespace e2d
         input_stream_uptr read(const url& url) const;
         output_stream_uptr write(const url& url, bool append) const;
 
-        bool load(const url& url, buffer& dst) const;
+        std::optional<buffer> load(const url& url) const;
         stdex::promise<buffer> load_async(const url& url) const;
 
-        bool load_as_string(const url& url, str& dst) const;
+        std::optional<str> load_as_string(const url& url) const;
         stdex::promise<str> load_as_string_async(const url& url) const;
 
         template < typename Iter >
diff --git a/headers/enduro2d/core/window.hpp b/headers/enduro2d/core/window.hpp
index 32c0781d..ddbb7501 100644
--- a/headers/enduro2d/core/window.hpp
+++ b/headers/enduro2d/core/window.hpp
@@ -89,9 +89,9 @@ namespace e2d
         std::unique_ptr<state> state_;
     };
 
-    class window_trace_event_listener final : public window::event_listener {
+    class window_event_tracer final : public window::event_listener {
     public:
-        window_trace_event_listener(debug& debug) noexcept;
+        window_event_tracer(debug& debug) noexcept;
         void on_input_char(char32_t uchar) noexcept final;
         void on_move_cursor(const v2f& pos) noexcept final;
         void on_mouse_scroll(const v2f& delta) noexcept final;
@@ -105,6 +105,18 @@ namespace e2d
     private:
         debug& debug_;
     };
+    
+    class window_input_source final : public window::event_listener {
+    public:
+        window_input_source(input& input) noexcept;
+        void on_input_char(char32_t uchar) noexcept final;
+        void on_move_cursor(const v2f& pos) noexcept final;
+        void on_mouse_scroll(const v2f& delta) noexcept final;
+        void on_mouse_button(mouse_button btn, mouse_button_action act) noexcept final;
+        void on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept final;
+    private:
+        input& input_;
+    };
 }
 
 ENUM_HPP_REGISTER_TRAITS(e2d::window::cursor_shapes)
diff --git a/samples/sources/sample_00/sample_00.cpp b/samples/sources/sample_00/sample_00.cpp
index e85e2519..a3ddca95 100644
--- a/samples/sources/sample_00/sample_00.cpp
+++ b/samples/sources/sample_00/sample_00.cpp
@@ -96,13 +96,20 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
+            
+            image texture1_image;
+            if ( !images::try_load_image(texture1_image, the<vfs>().read(url("ships://ship (2).png"))) ) {
+                return false;
+            }
 
-            shader_ = the<render>().create_shader(
-                vs_source_cstr, fs_source_cstr);
-            texture1_ = the<render>().create_texture(
-                the<vfs>().read(url("ships://ship (2).png")));
-            texture2_ = the<render>().create_texture(
-                the<vfs>().read(url("ships://ship (19).png")));
+            image texture2_image;
+            if ( !images::try_load_image(texture2_image, the<vfs>().read(url("ships://ship (19).png"))) ) {
+                return false;
+            }
+
+            shader_ = the<render>().create_shader(vs_source_cstr, fs_source_cstr);
+            texture1_ = the<render>().create_texture(texture1_image);
+            texture2_ = the<render>().create_texture(texture2_image);
 
             if ( !shader_ || !texture1_ || !texture2_ ) {
                 return false;
diff --git a/samples/sources/sample_01/sample_01.cpp b/samples/sources/sample_01/sample_01.cpp
index 63f315b7..6e9a9930 100644
--- a/samples/sources/sample_01/sample_01.cpp
+++ b/samples/sources/sample_01/sample_01.cpp
@@ -156,12 +156,14 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
+            
+            image texture_image;
+            if ( !images::try_load_image(texture_image, the<vfs>().read(url("ships://ship (3).png"))) ) {
+                return false;
+            }
 
-            shader_ = the<render>().create_shader(
-                vs_source_cstr, fs_source_cstr);
-
-            texture_ = the<render>().create_texture(
-                the<vfs>().read(url("ships://ship (3).png")));
+            shader_ = the<render>().create_shader(vs_source_cstr, fs_source_cstr);
+            texture_ = the<render>().create_texture(texture_image);
 
             if ( !shader_ || !texture_ ) {
                 return false;
diff --git a/samples/sources/sample_02/sample_02.cpp b/samples/sources/sample_02/sample_02.cpp
index 1fd0a8a3..3f953597 100644
--- a/samples/sources/sample_02/sample_02.cpp
+++ b/samples/sources/sample_02/sample_02.cpp
@@ -111,12 +111,14 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
+            
+            image texture_image;
+            if ( !images::try_load_image(texture_image, the<vfs>().read(url("ships://ship (3).png"))) ) {
+                return false;
+            }
 
-            shader_ = the<render>().create_shader(
-                vs_source_cstr, fs_source_cstr);
-
-            texture_ = the<render>().create_texture(
-                the<vfs>().read(url("ships://ship (3).png")));
+            shader_ = the<render>().create_shader(vs_source_cstr, fs_source_cstr);
+            texture_ = the<render>().create_texture(texture_image);
 
             if ( !shader_ || !texture_ ) {
                 return false;
diff --git a/samples/sources/sample_05/sample_05.cpp b/samples/sources/sample_05/sample_05.cpp
index 5d736c47..24917718 100644
--- a/samples/sources/sample_05/sample_05.cpp
+++ b/samples/sources/sample_05/sample_05.cpp
@@ -20,8 +20,8 @@ namespace
                 "audio",
                 url("rpgaudio://Audio"));
             
-            auto sstream1 = the<audio>().preload_stream(the<vfs>().read(url("audio://chop.ogg")));
-            auto sstream2 = the<audio>().create_stream(the<vfs>().read(url("audio://footstep00.ogg")));
+            auto sstream1 = the<audio>().create_stream(the<vfs>().read(url("audio://chop.ogg")));
+            auto sstream2 = the<audio>().create_stream(*the<vfs>().load(url("audio://footstep00.ogg")));
 
             if ( !sstream1 || !sstream2 ) {
                 return false;
diff --git a/sources/enduro2d/core/audio_impl/audio_bass.cpp b/sources/enduro2d/core/audio_impl/audio_bass.cpp
index d5706051..a00d401f 100644
--- a/sources/enduro2d/core/audio_impl/audio_bass.cpp
+++ b/sources/enduro2d/core/audio_impl/audio_bass.cpp
@@ -143,7 +143,7 @@ namespace e2d
     audio::~audio() noexcept {
     }
 
-    sound_stream_ptr audio::preload_stream(
+    sound_stream_ptr audio::create_stream(
         buffer_view sound_data)
     {
         if ( !state_->initialized() ) {
@@ -176,23 +176,6 @@ namespace e2d
                 state_->dbg(), sample, nullptr));
     }
 
-    sound_stream_ptr audio::preload_stream(
-        const input_stream_uptr& file_stream)
-    {
-        if ( !state_->initialized() ) {
-            state_->dbg().error("AUDIO: Not initialized");
-            return nullptr;
-        }
-
-        buffer file_data;
-        if ( !streams::try_read_tail(file_data, file_stream) ) {
-            state_->dbg().error("AUDIO: Failed to read file");
-            return nullptr;
-        }
-
-        return preload_stream(buffer_view(file_data));
-    }
-
     sound_stream_ptr audio::create_stream(
         input_stream_uptr file_stream)
     {
diff --git a/sources/enduro2d/core/audio_impl/audio_none.cpp b/sources/enduro2d/core/audio_impl/audio_none.cpp
index d2ced646..75069dc9 100644
--- a/sources/enduro2d/core/audio_impl/audio_none.cpp
+++ b/sources/enduro2d/core/audio_impl/audio_none.cpp
@@ -119,20 +119,13 @@ namespace e2d
     audio::~audio() noexcept {
     }
 
-    sound_stream_ptr audio::preload_stream(
+    sound_stream_ptr audio::create_stream(
         buffer_view sound_data)
     {
         E2D_UNUSED(sound_data);
         return nullptr;
     }
 
-    sound_stream_ptr audio::preload_stream(
-        const input_stream_uptr& file_stream)
-    {
-        E2D_UNUSED(file_stream);
-        return nullptr;
-    }
-
     sound_stream_ptr audio::create_stream(
         input_stream_uptr file_stream)
     {
diff --git a/sources/enduro2d/core/input.cpp b/sources/enduro2d/core/input.cpp
index 9fcdd1ed..fb917c63 100644
--- a/sources/enduro2d/core/input.cpp
+++ b/sources/enduro2d/core/input.cpp
@@ -370,32 +370,4 @@ namespace e2d
         state_->mouse.state_->frame_tick();
         state_->keyboard.state_->frame_tick();
     }
-
-    //
-    // class window_input_source
-    //
-
-    window_input_source::window_input_source(input& input) noexcept
-    : input_(input) {}
-
-    void window_input_source::on_input_char(char32_t uchar) noexcept {
-        input_.post_event(input::input_char_event{uchar});
-    }
-
-    void window_input_source::on_move_cursor(const v2f& pos) noexcept {
-        input_.post_event(input::move_cursor_event{pos});
-    }
-
-    void window_input_source::on_mouse_scroll(const v2f& delta) noexcept {
-        input_.post_event(input::mouse_scroll_event{delta});
-    }
-
-    void window_input_source::on_mouse_button(mouse_button btn, mouse_button_action act) noexcept {
-        input_.post_event(input::mouse_button_event{btn, act});
-    }
-
-    void window_input_source::on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept {
-        E2D_UNUSED(scancode);
-        input_.post_event(input::keyboard_key_event{key, act});
-    }
 }
diff --git a/sources/enduro2d/core/render_impl/render_none.cpp b/sources/enduro2d/core/render_impl/render_none.cpp
index 11cd3f50..666dfd2c 100644
--- a/sources/enduro2d/core/render_impl/render_none.cpp
+++ b/sources/enduro2d/core/render_impl/render_none.cpp
@@ -188,24 +188,11 @@ namespace e2d
         return nullptr;
     }
 
-    shader_ptr render::create_shader(
-        const input_stream_uptr& vertex_stream,
-        const input_stream_uptr& fragment_stream)
-    {
-        E2D_UNUSED(vertex_stream, fragment_stream);
-        return nullptr;
-    }
-
     texture_ptr render::create_texture(const image& image) {
         E2D_UNUSED(image);
         return nullptr;
     }
 
-    texture_ptr render::create_texture(const input_stream_uptr& image_stream) {
-        E2D_UNUSED(image_stream);
-        return nullptr;
-    }
-
     texture_ptr render::create_texture(const v2u& size, const pixel_declaration& decl) {
         E2D_UNUSED(size, decl);
         return nullptr;
diff --git a/sources/enduro2d/core/render_impl/render_opengl.cpp b/sources/enduro2d/core/render_impl/render_opengl.cpp
index 6d97d659..ea0b497b 100644
--- a/sources/enduro2d/core/render_impl/render_opengl.cpp
+++ b/sources/enduro2d/core/render_impl/render_opengl.cpp
@@ -542,19 +542,6 @@ namespace e2d
             str_view(reinterpret_cast<const char*>(fragment_source.data()), fragment_source.size()));
     }
 
-    shader_ptr render::create_shader(
-        const input_stream_uptr& vertex,
-        const input_stream_uptr& fragment)
-    {
-        E2D_ASSERT(is_in_main_thread());
-
-        str vertex_source, fragment_source;
-        return streams::try_read_tail(vertex_source, vertex)
-            && streams::try_read_tail(fragment_source, fragment)
-            ? create_shader(vertex_source, fragment_source)
-            : nullptr;
-    }
-
     texture_ptr render::create_texture(
         const image& image)
     {
@@ -633,18 +620,6 @@ namespace e2d
                 state_->dbg(), std::move(id), image.size(), decl));
     }
 
-    texture_ptr render::create_texture(
-        const input_stream_uptr& image_stream)
-    {
-        E2D_ASSERT(is_in_main_thread());
-
-        image image;
-        if ( !images::try_load_image(image, image_stream) ) {
-            return nullptr;
-        }
-        return create_texture(image);
-    }
-
     texture_ptr render::create_texture(
         const v2u& size,
         const pixel_declaration& decl)
diff --git a/sources/enduro2d/core/vfs.cpp b/sources/enduro2d/core/vfs.cpp
index 506303e0..e37e2d5b 100644
--- a/sources/enduro2d/core/vfs.cpp
+++ b/sources/enduro2d/core/vfs.cpp
@@ -172,12 +172,10 @@ namespace e2d
             }, output_stream_uptr());
     }
 
-    bool vfs::load(const url& url, buffer& dst) const {
-        return load_async(url)
-            .then([&dst](auto&& src){
-                dst = std::forward<decltype(src)>(src);
-                return true;
-            }).get_or_default(false);
+    std::optional<buffer> vfs::load(const url& url) const {
+        return load_async(url).then([](auto&& src){
+            return std::optional(std::forward<decltype(src)>(src));
+        }).get_or_default(std::nullopt);
     }
 
     stdex::promise<buffer> vfs::load_async(const url& url) const {
@@ -191,12 +189,10 @@ namespace e2d
         });
     }
 
-    bool vfs::load_as_string(const url& url, str& dst) const {
-        return load_as_string_async(url)
-            .then([&dst](auto&& src){
-                dst = std::forward<decltype(src)>(src);
-                return true;
-            }).get_or_default(false);
+    std::optional<str> vfs::load_as_string(const url& url) const {
+        return load_as_string_async(url).then([](auto&& src){
+            return std::optional(std::forward<decltype(src)>(src));
+        }).get_or_default(std::nullopt);
     }
 
     stdex::promise<str> vfs::load_as_string_async(const url& url) const {
diff --git a/sources/enduro2d/core/window.cpp b/sources/enduro2d/core/window.cpp
index b1f29867..d0cd79c8 100644
--- a/sources/enduro2d/core/window.cpp
+++ b/sources/enduro2d/core/window.cpp
@@ -7,13 +7,10 @@
 #include <enduro2d/core/window.hpp>
 
 #include <enduro2d/core/debug.hpp>
+#include <enduro2d/core/input.hpp>
 
 namespace e2d
 {
-    //
-    // class window::event_listener
-    //
-
     void window::event_listener::on_input_char(char32_t uchar) noexcept {
         E2D_UNUSED(uchar);
     }
@@ -52,56 +49,77 @@ namespace e2d
     void window::event_listener::on_window_minimize(bool minimized) noexcept {
         E2D_UNUSED(minimized);
     }
+}
 
-    //
-    // class trace_window_event_listener
-    //
-
-    window_trace_event_listener::window_trace_event_listener(debug& debug) noexcept
+namespace e2d
+{
+    window_event_tracer::window_event_tracer(debug& debug) noexcept
     : debug_(debug) {}
 
-    void window_trace_event_listener::on_input_char(char32_t uchar) noexcept {
+    void window_event_tracer::on_input_char(char32_t uchar) noexcept {
         debug_.trace("WINDOW: on_input_char(uchar: %0)", str32_view(&uchar, 1));
     }
 
-    void window_trace_event_listener::on_move_cursor(const v2f& pos) noexcept {
+    void window_event_tracer::on_move_cursor(const v2f& pos) noexcept {
         debug_.trace("WINDOW: on_move_cursor(pos: %0)", pos);
     }
 
-    void window_trace_event_listener::on_mouse_scroll(const v2f& delta) noexcept {
+    void window_event_tracer::on_mouse_scroll(const v2f& delta) noexcept {
         debug_.trace("WINDOW: on_scroll(delta: %0)", delta);
     }
 
-    void window_trace_event_listener::on_mouse_button(mouse_button btn, mouse_button_action act) noexcept {
-        debug_.trace("WINDOW: on_mouse_button(btn: %0 act: %1)",
-            btn,
-            act);
+    void window_event_tracer::on_mouse_button(mouse_button btn, mouse_button_action act) noexcept {
+        debug_.trace("WINDOW: on_mouse_button(btn: %0 act: %1)", btn, act);
     }
 
-    void window_trace_event_listener::on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept {
-        debug_.trace("WINDOW: on_keyboard_key(key: %0 scancode: %1 act: %2)",
-            key,
-            scancode,
-            act);
+    void window_event_tracer::on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept {
+        debug_.trace("WINDOW: on_keyboard_key(key: %0 scancode: %1 act: %2)", key, scancode, act);
     }
 
-    void window_trace_event_listener::on_window_size(const v2u& size) noexcept {
+    void window_event_tracer::on_window_size(const v2u& size) noexcept {
         debug_.trace("WINDOW: on_window_size(size: %0)", size);
     }
 
-    void window_trace_event_listener::on_framebuffer_size(const v2u& size) noexcept {
+    void window_event_tracer::on_framebuffer_size(const v2u& size) noexcept {
         debug_.trace("WINDOW: on_framebuffer_size(size: %0)", size);
     }
 
-    void window_trace_event_listener::on_window_close() noexcept {
+    void window_event_tracer::on_window_close() noexcept {
         debug_.trace("WINDOW: on_window_close()");
     }
 
-    void window_trace_event_listener::on_window_focus(bool focused) noexcept {
+    void window_event_tracer::on_window_focus(bool focused) noexcept {
         debug_.trace("WINDOW: on_window_focus(focused: %0)", focused);
     }
 
-    void window_trace_event_listener::on_window_minimize(bool minimized) noexcept {
+    void window_event_tracer::on_window_minimize(bool minimized) noexcept {
         debug_.trace("WINDOW: on_window_minimize(minimized: %0)", minimized);
     }
 }
+
+namespace e2d
+{
+    window_input_source::window_input_source(input& input) noexcept
+    : input_(input) {}
+
+    void window_input_source::on_input_char(char32_t uchar) noexcept {
+        input_.post_event(input::input_char_event{uchar});
+    }
+
+    void window_input_source::on_move_cursor(const v2f& pos) noexcept {
+        input_.post_event(input::move_cursor_event{pos});
+    }
+
+    void window_input_source::on_mouse_scroll(const v2f& delta) noexcept {
+        input_.post_event(input::mouse_scroll_event{delta});
+    }
+
+    void window_input_source::on_mouse_button(mouse_button btn, mouse_button_action act) noexcept {
+        input_.post_event(input::mouse_button_event{btn, act});
+    }
+
+    void window_input_source::on_keyboard_key(keyboard_key key, u32 scancode, keyboard_key_action act) noexcept {
+        E2D_UNUSED(scancode);
+        input_.post_event(input::keyboard_key_event{key, act});
+    }
+}
diff --git a/sources/enduro2d/high/assets/sound_asset.cpp b/sources/enduro2d/high/assets/sound_asset.cpp
index 8262d16c..64b67f31 100644
--- a/sources/enduro2d/high/assets/sound_asset.cpp
+++ b/sources/enduro2d/high/assets/sound_asset.cpp
@@ -77,7 +77,7 @@ namespace
             return library.load_asset_async<binary_asset>(sound_address)
             .then([](const binary_asset::load_result& sound_data){
                 return the<deferrer>().do_in_worker_thread([sound_data](){
-                    sound_stream_ptr content = the<audio>().preload_stream(
+                    sound_stream_ptr content = the<audio>().create_stream(
                         sound_data->content());
                     if ( !content ) {
                         throw sound_asset_loading_exception();
diff --git a/untests/sources/untests_core/vfs.cpp b/untests/sources/untests_core/vfs.cpp
index 8309297f..ec1c4c71 100644
--- a/untests/sources/untests_core/vfs.cpp
+++ b/untests/sources/untests_core/vfs.cpp
@@ -33,15 +33,15 @@ TEST_CASE("vfs"){
             REQUIRE(v.read({"file", nofile_path}) == input_stream_uptr());
         }
         {
-            buffer b0;
-            REQUIRE(v.load({"file", file_path}, b0));
+            auto b0 = v.load({"file", file_path});
+            REQUIRE(b0);
             REQUIRE(b0 == buffer{"hello", 5});
 
             auto b1 = v.load_async({"file", file_path}).get();
             REQUIRE(b1 == buffer{"hello", 5});
 
-            str b2;
-            REQUIRE(v.load_as_string({"file", file_path}, b2));
+            auto b2 = v.load_as_string({"file", file_path});
+            REQUIRE(b2);
             REQUIRE(b2 == "hello");
 
             auto b3 = v.load_as_string_async({"file", file_path}).get();
@@ -135,15 +135,15 @@ TEST_CASE("vfs"){
                 REQUIRE(b == buffer("hello", 5));
             }
             {
-                buffer b0;
-                REQUIRE(v.load(url("archive://test.txt"), b0));
+                auto b0 = v.load(url("archive://test.txt"));
+                REQUIRE(b0);
                 REQUIRE(b0 == buffer("hello", 5));
 
                 auto b1 = v.load_async(url("archive://test.txt")).get();
                 REQUIRE(b1 == buffer("hello", 5));
 
-                str b2;
-                REQUIRE(v.load_as_string(url("archive://test.txt"), b2));
+                auto b2 = v.load_as_string(url("archive://test.txt"));
+                REQUIRE(b2);
                 REQUIRE(b2 == "hello");
 
                 auto b3 = v.load_as_string_async(url("archive://test.txt")).get();
@@ -157,15 +157,15 @@ TEST_CASE("vfs"){
                 REQUIRE(b == buffer("world", 5));
             }
             {
-                buffer b0;
-                REQUIRE(v.load(url("archive://folder/file.txt"), b0));
+                auto b0 = v.load(url("archive://folder/file.txt"));
+                REQUIRE(b0);
                 REQUIRE(b0 == buffer("world", 5));
 
                 auto b1 = v.load_async(url("archive://folder/file.txt")).get();
                 REQUIRE(b1 == buffer("world", 5));
 
-                str b2;
-                REQUIRE(v.load_as_string(url("archive://folder/file.txt"), b2));
+                auto b2 = v.load_as_string(url("archive://folder/file.txt"));
+                REQUIRE(b2);
                 REQUIRE(b2 == "world");
 
                 auto b3 = v.load_as_string_async(url("archive://folder/file.txt")).get();
@@ -174,17 +174,15 @@ TEST_CASE("vfs"){
             {
                 REQUIRE(v.read(url("archive://TEst.txt")) == input_stream_uptr());
 
-                buffer b0;
-                REQUIRE_FALSE(v.load(url("archive://TEst.txt"), b0));
-                REQUIRE(b0.empty());
+                auto b0 = v.load(url("archive://TEst.txt"));
+                REQUIRE_FALSE(b0);
 
                 REQUIRE_THROWS_AS(
                     v.load_async(url("archive://TEst.txt")).get(),
                     vfs_load_async_exception);
 
-                str b2;
-                REQUIRE_FALSE(v.load_as_string(url("archive://TEst.txt"), b2));
-                REQUIRE(b2.empty());
+                auto b2 = v.load_as_string(url("archive://TEst.txt"));
+                REQUIRE_FALSE(b2);
 
                 REQUIRE_THROWS_AS(
                     v.load_as_string_async(url("archive://TEst.txt")).get(),

From 5bdc65681e619252b3700422b2dd694a36d7fff3 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 9 Jan 2020 17:09:39 +0700
Subject: [PATCH 15/19] add profiler event args

---
 headers/enduro2d/core/profiler.hpp | 49 +++++++++++++---
 sources/enduro2d/core/profiler.cpp | 94 +++++++++++++++++++++++++-----
 2 files changed, 121 insertions(+), 22 deletions(-)

diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
index 4540079d..282d348d 100644
--- a/headers/enduro2d/core/profiler.hpp
+++ b/headers/enduro2d/core/profiler.hpp
@@ -12,8 +12,11 @@ namespace e2d
 {
     class profiler final : public module<profiler> {
     public:
+        using args_t = flat_map<str, str>;
+
         struct begin_scope_info {
             str name;
+            args_t args;
             std::thread::id tid;
             std::chrono::microseconds tp;
         };
@@ -25,12 +28,14 @@ namespace e2d
 
         struct thread_event_info {
             str name;
+            args_t args;
             std::thread::id tid;
             std::chrono::microseconds tp;
         };
 
         struct global_event_info {
             str name;
+            args_t args;
             std::thread::id tid;
             std::chrono::microseconds tp;
         };
@@ -48,22 +53,27 @@ namespace e2d
         };
         using sink_uptr = std::unique_ptr<sink>;
     public:
-        class scope final : private e2d::noncopyable {
+        class auto_scope final : private e2d::noncopyable {
         public:
-            scope(profiler& profiler, str name);
-            ~scope() noexcept;
+            auto_scope(profiler* profiler, str name);
+            auto_scope(profiler* profiler, str name, args_t args);
+            ~auto_scope() noexcept;
         private:
-            profiler& profiler_;
+            profiler* profiler_ = nullptr;
         };
     public:
         profiler(deferrer& d);
         ~profiler() noexcept final;
 
         void begin_scope(str name) noexcept;
+        void begin_scope(str name, args_t args) noexcept;
         void end_scope() noexcept;
 
         void thread_event(str name) noexcept;
+        void thread_event(str name, args_t args) noexcept;
+
         void global_event(str name) noexcept;
+        void global_event(str name, args_t args) noexcept;
     public:
         struct recording_info {
             vector<event_info> events;
@@ -90,14 +100,37 @@ namespace e2d
 }
 
 #define E2D_PROFILER_SCOPE(name)\
-    auto E2D_PP_CAT(e2d_generated_profiler_scope_, __LINE__) =\
-        ::e2d::profiler::scope(the<profiler>(), name)
+    auto E2D_PP_CAT(e2d_generated_profiler_auto_scope_, __LINE__) =\
+        ::e2d::profiler::auto_scope(\
+            modules::is_initialized<profiler>() ? &the<profiler>() : nullptr,\
+            name);
+
+#define E2D_PROFILER_SCOPE_EX(name, ...)\
+    auto E2D_PP_CAT(e2d_generated_profiler_auto_scope_, __LINE__) =\
+        ::e2d::profiler::auto_scope(\
+            modules::is_initialized<profiler>() ? &the<profiler>() : nullptr,\
+            name,\
+            __VA_ARGS__);
 
 #define E2D_PROFILER_THREAD_EVENT(name)\
-    the<profiler>().thread_event(name)
+    if ( modules::is_initialized<profiler>() ) {\
+        the<profiler>().thread_event(name);\
+    }
+
+#define E2D_PROFILER_THREAD_EVENT_EX(name, ...)\
+    if ( modules::is_initialized<profiler>() ) {\
+        the<profiler>().thread_event(name, __VA_ARGS___);\
+    }
 
 #define E2D_PROFILER_GLOBAL_EVENT(name)\
-    the<profiler>().global_event(name)
+    if ( modules::is_initialized<profiler>() ) {\
+        the<profiler>().global_event(name);\
+    }
+
+#define E2D_PROFILER_GLOBAL_EVENT_EX(name, ...)\
+    if ( modules::is_initialized<profiler>() ) {\
+        the<profiler>().global_event(name, __VA_ARGS__);\
+    }
 
 namespace e2d
 {
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
index ab999b35..b1e9ce10 100644
--- a/sources/enduro2d/core/profiler.cpp
+++ b/sources/enduro2d/core/profiler.cpp
@@ -6,27 +6,64 @@
 
 #include <enduro2d/core/profiler.hpp>
 
+#include <enduro2d/core/deferrer.hpp>
+#include <enduro2d/core/engine.hpp>
+#include <enduro2d/core/vfs.hpp>
+
 namespace
 {
     using namespace e2d;
 
+    str recording_args_to_json(const profiler::args_t& args) {
+        str dst = "{";
+        for ( auto iter = args.begin(); iter != args.end(); ) {
+            dst += strings::rformat("\"%0\":\"%1\"", iter->first, iter->second);
+            if ( ++iter != args.end() ) {
+                dst += ",";
+            }
+        }
+        dst += "}";
+        return dst;
+    }
+
     str recording_info_to_json(const profiler::recording_info& src) {
         str dst("{\"traceEvents\":[\n");
-        for ( std::size_t i = 0; i < src.events.size(); ++i ) {
+        
+        dst += strings::rformat(
+            "  {\"name\":\"thread_name\",\"ph\":\"M\",\"tid\":%0,\"pid\":0,\"args\":{\"name\":\"%1\"}},\n",
+            std::hash<std::thread::id>()(the<engine>().main_thread()),
+            "Main");
+
+        for ( std::thread::id tid : the<vfs>().worker().thread_ids() ) {
+            dst += strings::rformat(
+                "  {\"name\":\"thread_name\",\"ph\":\"M\",\"tid\":%0,\"pid\":0,\"args\":{\"name\":\"%1\"}},\n",
+                std::hash<std::thread::id>()(tid),
+                "VFS");
+        }
+
+        for ( std::thread::id tid : the<deferrer>().worker().thread_ids() ) {
+            dst += strings::rformat(
+                "  {\"name\":\"thread_name\",\"ph\":\"M\",\"tid\":%0,\"pid\":0,\"args\":{\"name\":\"%1\"}},\n",
+                std::hash<std::thread::id>()(tid),
+                "Worker");
+        }
+
+        for ( auto iter = src.events.begin(); iter != src.events.end(); ) {
             std::visit(utils::overloaded {
                 [&dst](const profiler::begin_scope_info& e){
                     char buf[512] = {'\0'};
                     strings::format(buf, std::size(buf),
-                        "  {\"name\":\"%0\", \"ph\":\"B\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        "  {\"name\":\"%0\",\"ph\":\"B\",\"ts\":%1,\"tid\":%2,\"pid\":0,\"cat\":\"\",\"args\":%3}",
                         e.name,
                         e.tp.count(),
-                        std::hash<std::thread::id>()(e.tid));
+                        std::hash<std::thread::id>()(e.tid),
+                        recording_args_to_json(e.args));
                     dst += buf;
                 },
                 [&dst](const profiler::end_scope_info& e){
                     char buf[512] = {'\0'};
                     strings::format(buf, std::size(buf),
-                        "  {\"ph\":\"E\", \"ts\":%0, \"tid\":%1, \"pid\":0}",
+                        "  {\"ph\":\"E\",\"ts\":%0,\"tid\":%1,\"pid\":0,\"cat\":\"\"}",
                         e.tp.count(),
                         std::hash<std::thread::id>()(e.tid));
                     dst += buf;
@@ -34,27 +71,30 @@ namespace
                 [&dst](const profiler::thread_event_info& e){
                     char buf[512] = {'\0'};
                     strings::format(buf, std::size(buf),
-                        "  {\"name\":\"%0\", \"ph\":\"i\", \"s\":\"t\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        "  {\"name\":\"%0\",\"ph\":\"i\",\"s\":\"t\",\"ts\":%1,\"tid\":%2,\"pid\":0,\"cat\":\"\",\"args\":%3}",
                         e.name,
                         e.tp.count(),
-                        std::hash<std::thread::id>()(e.tid));
+                        std::hash<std::thread::id>()(e.tid),
+                        recording_args_to_json(e.args));
                     dst += buf;
                 },
                 [&dst](const profiler::global_event_info& e){
                     char buf[512] = {'\0'};
                     strings::format(buf, std::size(buf),
-                        "  {\"name\":\"%0\", \"ph\":\"i\", \"s\":\"g\", \"ts\":%1, \"tid\":%2, \"pid\":0}",
+                        "  {\"name\":\"%0\",\"ph\":\"i\",\"s\":\"g\",\"ts\":%1,\"tid\":%2,\"pid\":0,\"cat\":\"\",\"args\":%3}",
                         e.name,
                         e.tp.count(),
-                        std::hash<std::thread::id>()(e.tid));
+                        std::hash<std::thread::id>()(e.tid),
+                        recording_args_to_json(e.args));
                     dst += buf;
                 }
-            }, src.events[i]);
+            }, *iter);
 
-            if ( i < src.events.size() - 1u ) {
+            if ( ++iter != src.events.end() ) {
                 dst += ",\n";
             }
         }
+
         dst += "\n]}";
         return dst;
     }
@@ -62,13 +102,24 @@ namespace
 
 namespace e2d
 {
-    profiler::scope::scope(profiler& profiler, str name)
+    profiler::auto_scope::auto_scope(profiler* profiler, str name)
     : profiler_(profiler) {
-        profiler_.begin_scope(std::move(name));
+        if ( profiler_ ) {
+            profiler_->begin_scope(std::move(name));
+        }
     }
 
-    profiler::scope::~scope() noexcept {
-        profiler_.end_scope();
+    profiler::auto_scope::auto_scope(profiler* profiler, str name, args_t args)
+    : profiler_(profiler) {
+        if ( profiler_ ) {
+            profiler_->begin_scope(std::move(name), std::move(args));
+        }
+    }
+
+    profiler::auto_scope::~auto_scope() noexcept {
+        if ( profiler_ ) {
+            profiler_->end_scope();
+        }
     }
 }
 
@@ -97,10 +148,15 @@ namespace e2d
     }
 
     void profiler::begin_scope(str name) noexcept {
+        return begin_scope(std::move(name), {});
+    }
+
+    void profiler::begin_scope(str name, args_t args) noexcept {
         ++depth_;
 
         begin_scope_info event{
             std::move(name),
+            std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
         
@@ -129,8 +185,13 @@ namespace e2d
     }
 
     void profiler::thread_event(str name) noexcept {
+        return thread_event(std::move(name), {});
+    }
+
+    void profiler::thread_event(str name, args_t args) noexcept {
         thread_event_info event{
             std::move(name),
+            std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
         
@@ -143,8 +204,13 @@ namespace e2d
     }
 
     void profiler::global_event(str name) noexcept {
+        return global_event(std::move(name), {});
+    }
+
+    void profiler::global_event(str name, args_t args) noexcept {
         global_event_info event{
             std::move(name),
+            std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
         

From ca5c5cf7c62e11d636c41a8d44694cdefe6fb282 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 9 Jan 2020 17:38:25 +0700
Subject: [PATCH 16/19] add audio, render and vfs profiler events

---
 sources/enduro2d/core/audio_impl/audio.hpp    |  3 +-
 .../enduro2d/core/audio_impl/audio_bass.cpp   |  6 ++
 sources/enduro2d/core/render_impl/render.hpp  |  1 +
 .../core/render_impl/render_opengl.cpp        | 74 ++++++++++++++-----
 sources/enduro2d/core/vfs.cpp                 | 14 ++++
 5 files changed, 77 insertions(+), 21 deletions(-)

diff --git a/sources/enduro2d/core/audio_impl/audio.hpp b/sources/enduro2d/core/audio_impl/audio.hpp
index 110169cd..1509f5b7 100644
--- a/sources/enduro2d/core/audio_impl/audio.hpp
+++ b/sources/enduro2d/core/audio_impl/audio.hpp
@@ -6,8 +6,9 @@
 
 #pragma once
 
-#include <enduro2d/core/debug.hpp>
 #include <enduro2d/core/audio.hpp>
+#include <enduro2d/core/debug.hpp>
+#include <enduro2d/core/profiler.hpp>
 
 #define E2D_AUDIO_MODE_NONE 1
 #define E2D_AUDIO_MODE_BASS 2
diff --git a/sources/enduro2d/core/audio_impl/audio_bass.cpp b/sources/enduro2d/core/audio_impl/audio_bass.cpp
index a00d401f..bd83c57b 100644
--- a/sources/enduro2d/core/audio_impl/audio_bass.cpp
+++ b/sources/enduro2d/core/audio_impl/audio_bass.cpp
@@ -156,6 +156,8 @@ namespace e2d
             return nullptr;
         }
 
+        E2D_PROFILER_SCOPE("audio.create_stream");
+
         HSAMPLE sample = BASS_SampleLoad(
             TRUE,
             sound_data.data(),
@@ -189,6 +191,8 @@ namespace e2d
             return nullptr;
         }
 
+        E2D_PROFILER_SCOPE("audio.create_stream");
+
         BASS_FILEPROCS file_procs = {
             sound_stream_close_proc,
             sound_stream_length_proc,
@@ -226,6 +230,8 @@ namespace e2d
             return nullptr;
         }
 
+        E2D_PROFILER_SCOPE("audio.create_source");
+
         HCHANNEL channel = stream->state().stream()
             ? stream->state().sound()
             : BASS_SampleGetChannel(stream->state().sound(), FALSE);
diff --git a/sources/enduro2d/core/render_impl/render.hpp b/sources/enduro2d/core/render_impl/render.hpp
index 1923edf0..0069c1a6 100644
--- a/sources/enduro2d/core/render_impl/render.hpp
+++ b/sources/enduro2d/core/render_impl/render.hpp
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <enduro2d/core/debug.hpp>
+#include <enduro2d/core/profiler.hpp>
 #include <enduro2d/core/render.hpp>
 #include <enduro2d/core/window.hpp>
 
diff --git a/sources/enduro2d/core/render_impl/render_opengl.cpp b/sources/enduro2d/core/render_impl/render_opengl.cpp
index ea0b497b..52d22e83 100644
--- a/sources/enduro2d/core/render_impl/render_opengl.cpp
+++ b/sources/enduro2d/core/render_impl/render_opengl.cpp
@@ -497,33 +497,51 @@ namespace e2d
     {
         E2D_ASSERT(is_in_main_thread());
 
-        gl_shader_id vs = gl_compile_shader(
-            state_->dbg(),
-            vertex_shader_header_cstr(device_capabilities().profile),
-            vertex_source,
-            GL_VERTEX_SHADER);
+        gl_shader_id vs(state_->dbg());
 
-        if ( vs.empty() ) {
-            return nullptr;
+        {
+            E2D_PROFILER_SCOPE("render.compile_vertex_shader");
+
+            vs = gl_compile_shader(
+                state_->dbg(),
+                vertex_shader_header_cstr(device_capabilities().profile),
+                vertex_source,
+                GL_VERTEX_SHADER);
+
+            if ( vs.empty() ) {
+                return nullptr;
+            }
         }
 
-        gl_shader_id fs = gl_compile_shader(
-            state_->dbg(),
-            fragment_shader_header_cstr(device_capabilities().profile),
-            fragment_source,
-            GL_FRAGMENT_SHADER);
+        gl_shader_id fs(state_->dbg());
+        
+        {
+            E2D_PROFILER_SCOPE("render.compile_fragment_shader");
 
-        if ( fs.empty() ) {
-            return nullptr;
+            fs = gl_compile_shader(
+                state_->dbg(),
+                fragment_shader_header_cstr(device_capabilities().profile),
+                fragment_source,
+                GL_FRAGMENT_SHADER);
+
+            if ( fs.empty() ) {
+                return nullptr;
+            }
         }
 
-        gl_program_id ps = gl_link_program(
-            state_->dbg(),
-            std::move(vs),
-            std::move(fs));
+        gl_program_id ps(state_->dbg());
 
-        if ( ps.empty() ) {
-            return nullptr;
+        {
+            E2D_PROFILER_SCOPE("render.link_shader_program");
+
+            ps = gl_link_program(
+                state_->dbg(),
+                std::move(vs),
+                std::move(fs));
+
+            if ( ps.empty() ) {
+                return nullptr;
+            }
         }
 
         return std::make_shared<shader>(
@@ -583,6 +601,11 @@ namespace e2d
             }
         }
 
+        E2D_PROFILER_SCOPE_EX("render.create_texture_from_image", {
+            {"size", strings::rformat("%0", image.size())},
+            {"format", strings::rformat("%0", image.format())}
+        });
+
         gl_texture_id id = gl_texture_id::create(state_->dbg(), GL_TEXTURE_2D);
         if ( id.empty() ) {
             state_->dbg().error("RENDER: Failed to create texture:\n"
@@ -659,6 +682,11 @@ namespace e2d
             }
         }
 
+        E2D_PROFILER_SCOPE_EX("render.create_empty_texture", {
+            {"size", strings::rformat("%0", size)},
+            {"format", strings::rformat("%0", decl.type())}
+        });
+
         gl_texture_id id = gl_texture_id::create(state_->dbg(), GL_TEXTURE_2D);
         if ( id.empty() ) {
             state_->dbg().error("RENDER: Failed to create texture:\n"
@@ -723,6 +751,8 @@ namespace e2d
             return nullptr;
         }
 
+        E2D_PROFILER_SCOPE("render.create_index_buffer");
+
         gl_buffer_id id = gl_buffer_id::create(state_->dbg(), GL_ELEMENT_ARRAY_BUFFER);
         if ( id.empty() ) {
             state_->dbg().error("RENDER: Failed to create index buffer:\n"
@@ -757,6 +787,8 @@ namespace e2d
             return nullptr;
         }
 
+        E2D_PROFILER_SCOPE("render.create_vertex_buffer");
+
         gl_buffer_id id = gl_buffer_id::create(state_->dbg(), GL_ARRAY_BUFFER);
         if ( id.empty() ) {
             state_->dbg().error("RENDER: Failed to create vertex buffer:\n"
@@ -813,6 +845,8 @@ namespace e2d
             }
         }
 
+        E2D_PROFILER_SCOPE("render.create_render_target");
+
         gl_framebuffer_id id = gl_framebuffer_id::create(state_->dbg(), GL_FRAMEBUFFER);
         if ( id.empty() ) {
             state_->dbg().error("RENDER: Failed to create framebuffer:\n",
diff --git a/sources/enduro2d/core/vfs.cpp b/sources/enduro2d/core/vfs.cpp
index e37e2d5b..15e73bea 100644
--- a/sources/enduro2d/core/vfs.cpp
+++ b/sources/enduro2d/core/vfs.cpp
@@ -6,6 +6,8 @@
 
 #include <enduro2d/core/vfs.hpp>
 
+#include <enduro2d/core/profiler.hpp>
+
 #include <3rdparty/miniz/miniz.h>
 
 namespace
@@ -173,6 +175,9 @@ namespace e2d
     }
 
     std::optional<buffer> vfs::load(const url& url) const {
+        E2D_PROFILER_SCOPE_EX("vfs.sync_load", {
+            {"url", url.schemepath()}
+        });
         return load_async(url).then([](auto&& src){
             return std::optional(std::forward<decltype(src)>(src));
         }).get_or_default(std::nullopt);
@@ -180,6 +185,9 @@ namespace e2d
 
     stdex::promise<buffer> vfs::load_async(const url& url) const {
         return state_->worker.async([this, url](){
+            E2D_PROFILER_SCOPE_EX("vfs.load_async", {
+                {"url", url.schemepath()}
+            });
             buffer content;
             const input_stream_uptr stream = read(url);
             if ( !stream || !streams::try_read_tail(content, stream) ) {
@@ -190,6 +198,9 @@ namespace e2d
     }
 
     std::optional<str> vfs::load_as_string(const url& url) const {
+        E2D_PROFILER_SCOPE_EX("vfs.sync_load_as_string", {
+            {"url", url.schemepath()}
+        });
         return load_as_string_async(url).then([](auto&& src){
             return std::optional(std::forward<decltype(src)>(src));
         }).get_or_default(std::nullopt);
@@ -197,6 +208,9 @@ namespace e2d
 
     stdex::promise<str> vfs::load_as_string_async(const url& url) const {
         return state_->worker.async([this, url](){
+            E2D_PROFILER_SCOPE_EX("vfs.load_as_string_async", {
+                {"url", url.schemepath()}
+            });
             str content;
             const input_stream_uptr stream = read(url);
             if ( !stream || !streams::try_read_tail(content, stream) ) {

From 0c16d58253024929830c88abddc7e0bcdbd06167 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Thu, 9 Jan 2020 18:31:24 +0700
Subject: [PATCH 17/19] add some high profiler events

---
 headers/enduro2d/high/luasol.hpp              |   1 -
 sources/enduro2d/high/assets/font_asset.cpp   |  19 +-
 sources/enduro2d/high/assets/image_asset.cpp  |  12 +-
 sources/enduro2d/high/assets/json_asset.cpp   |  12 +-
 sources/enduro2d/high/assets/mesh_asset.cpp   |  12 +-
 sources/enduro2d/high/assets/script_asset.cpp |  12 +-
 sources/enduro2d/high/assets/shader_asset.cpp |  23 +-
 sources/enduro2d/high/assets/shape_asset.cpp  |  12 +-
 sources/enduro2d/high/assets/spine_asset.cpp  | 228 ++++++++++--------
 .../enduro2d/high/assets/texture_asset.cpp    |  12 +-
 sources/enduro2d/high/assets/xml_asset.cpp    |  12 +-
 sources/enduro2d/high/luasol.cpp              |  14 +-
 .../enduro2d/high/systems/render_system.cpp   |   8 +
 sources/enduro2d/high/world.cpp               |   5 +
 14 files changed, 241 insertions(+), 141 deletions(-)

diff --git a/headers/enduro2d/high/luasol.hpp b/headers/enduro2d/high/luasol.hpp
index a030f176..30086a56 100644
--- a/headers/enduro2d/high/luasol.hpp
+++ b/headers/enduro2d/high/luasol.hpp
@@ -26,7 +26,6 @@ namespace e2d
 
         std::optional<script> load_script(str_view src);
         std::optional<script> load_script(buffer_view src);
-        std::optional<script> load_script(const input_stream_uptr& src);
     private:
         sol::state state_;
     };
diff --git a/sources/enduro2d/high/assets/font_asset.cpp b/sources/enduro2d/high/assets/font_asset.cpp
index 79e07cf4..f29501a8 100644
--- a/sources/enduro2d/high/assets/font_asset.cpp
+++ b/sources/enduro2d/high/assets/font_asset.cpp
@@ -26,8 +26,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<binary_asset>(address)
-        .then([](const binary_asset::load_result& font_data){
-            return the<deferrer>().do_in_worker_thread([font_data](){
+        .then([
+            address = str(address)
+        ](const binary_asset::load_result& font_data){
+            return the<deferrer>().do_in_worker_thread([
+                font_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("font_asset.parsing", {
+                    {"address", address}
+                });
                 font content;
                 if ( !fonts::try_load_font(content, font_data->content()) ) {
                     throw font_asset_loading_exception();
@@ -35,15 +43,14 @@ namespace e2d
                 return content;
             });
         })
-        .then([
+        .then_tuple([
             &library,
             parent_address = path::parent_path(address)
         ](const font& content){
-            return stdex::make_tuple_promise(std::make_tuple(
+            return std::make_tuple(
                 stdex::make_resolved_promise(content),
                 library.load_asset_async<texture_asset>(
-                    path::combine(parent_address, content.info().atlas_file))
-            ));
+                    path::combine(parent_address, content.info().atlas_file)));
         })
         .then([](const std::tuple<
             font,
diff --git a/sources/enduro2d/high/assets/image_asset.cpp b/sources/enduro2d/high/assets/image_asset.cpp
index 15373d86..8b715ea9 100644
--- a/sources/enduro2d/high/assets/image_asset.cpp
+++ b/sources/enduro2d/high/assets/image_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<binary_asset>(address)
-        .then([](const binary_asset::load_result& image_data){
-            return the<deferrer>().do_in_worker_thread([image_data](){
+        .then([
+            address = str(address)
+        ](const binary_asset::load_result& image_data){
+            return the<deferrer>().do_in_worker_thread([
+                image_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("image_asset.load_async", {
+                    {"address", address}
+                });
                 image content;
                 if ( !images::try_load_image(content, image_data->content()) ) {
                     throw image_asset_loading_exception();
diff --git a/sources/enduro2d/high/assets/json_asset.cpp b/sources/enduro2d/high/assets/json_asset.cpp
index cadb241b..388af53a 100644
--- a/sources/enduro2d/high/assets/json_asset.cpp
+++ b/sources/enduro2d/high/assets/json_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<text_asset>(address)
-        .then([](const text_asset::load_result& json_data){
-            return the<deferrer>().do_in_worker_thread([json_data](){
+        .then([
+            address = str(address)
+        ](const text_asset::load_result& json_data){
+            return the<deferrer>().do_in_worker_thread([
+                json_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("json_asset.parsing", {
+                    {"address", address}
+                });
                 auto json = std::make_shared<rapidjson::Document>();
                 if ( json->Parse(json_data->content().c_str()).HasParseError() ) {
                     throw json_asset_loading_exception();
diff --git a/sources/enduro2d/high/assets/mesh_asset.cpp b/sources/enduro2d/high/assets/mesh_asset.cpp
index 7d4a9306..c49afdd2 100644
--- a/sources/enduro2d/high/assets/mesh_asset.cpp
+++ b/sources/enduro2d/high/assets/mesh_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<binary_asset>(address)
-        .then([](const binary_asset::load_result& mesh_data){
-            return the<deferrer>().do_in_worker_thread([mesh_data](){
+        .then([
+            address = str(address)
+        ](const binary_asset::load_result& mesh_data){
+            return the<deferrer>().do_in_worker_thread([
+                mesh_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("mesh_asset.parsing", {
+                    {"address", address}
+                });
                 mesh content;
                 if ( !meshes::try_load_mesh(content, mesh_data->content()) ) {
                     throw mesh_asset_loading_exception();
diff --git a/sources/enduro2d/high/assets/script_asset.cpp b/sources/enduro2d/high/assets/script_asset.cpp
index 1ee62b9d..e17420df 100644
--- a/sources/enduro2d/high/assets/script_asset.cpp
+++ b/sources/enduro2d/high/assets/script_asset.cpp
@@ -26,8 +26,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<binary_asset>(address)
-        .then([](const binary_asset::load_result& script_data){
-            return the<deferrer>().do_in_main_thread([script_data](){
+        .then([
+            address = str(address)
+        ](const binary_asset::load_result& script_data){
+            return the<deferrer>().do_in_main_thread([
+                script_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("script_asset.parsing", {
+                    {"address", address}
+                });
                 std::optional<script> script_opt = the<luasol>().load_script(
                     script_data->content());
                 if ( !script_opt ) {
diff --git a/sources/enduro2d/high/assets/shader_asset.cpp b/sources/enduro2d/high/assets/shader_asset.cpp
index bd2730b8..0f477083 100644
--- a/sources/enduro2d/high/assets/shader_asset.cpp
+++ b/sources/enduro2d/high/assets/shader_asset.cpp
@@ -54,21 +54,32 @@ namespace
         const rapidjson::Value& root)
     {
         E2D_ASSERT(root.HasMember("vertex") && root["vertex"].IsString());
-        auto vertex_p = library.load_asset_async<text_asset>(
-            path::combine(parent_address, root["vertex"].GetString()));
+        auto vertex_a = path::combine(parent_address, root["vertex"].GetString());
+        auto vertex_p = library.load_asset_async<text_asset>(vertex_a);
 
         E2D_ASSERT(root.HasMember("fragment") && root["fragment"].IsString());
-        auto fragment_p = library.load_asset_async<text_asset>(
-            path::combine(parent_address, root["fragment"].GetString()));
+        auto fragment_a = path::combine(parent_address, root["fragment"].GetString());
+        auto fragment_p = library.load_asset_async<text_asset>(fragment_a);
 
         return stdex::make_tuple_promise(std::make_tuple(
             std::move(vertex_p),
             std::move(fragment_p)))
-        .then([](const std::tuple<
+        .then([
+            vertex_a = std::move(vertex_a),
+            fragment_a = std::move(fragment_a)
+        ](const std::tuple<
             text_asset::load_result,
             text_asset::load_result
         >& results){
-            return the<deferrer>().do_in_main_thread([results](){
+            return the<deferrer>().do_in_main_thread([
+                results,
+                vertex_a = std::move(vertex_a),
+                fragment_a = std::move(fragment_a)
+            ](){
+                E2D_PROFILER_SCOPE_EX("shader_asset.create_shader", {
+                    {"vertex_address", vertex_a},
+                    {"fragment_address", fragment_a}
+                });
                 const shader_ptr content = the<render>().create_shader(
                     std::get<0>(results)->content(),
                     std::get<1>(results)->content());
diff --git a/sources/enduro2d/high/assets/shape_asset.cpp b/sources/enduro2d/high/assets/shape_asset.cpp
index df46fa9a..a722aa37 100644
--- a/sources/enduro2d/high/assets/shape_asset.cpp
+++ b/sources/enduro2d/high/assets/shape_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<binary_asset>(address)
-        .then([](const binary_asset::load_result& shape_data){
-            return the<deferrer>().do_in_worker_thread([shape_data](){
+        .then([
+            address = str(address)
+        ](const binary_asset::load_result& shape_data){
+            return the<deferrer>().do_in_worker_thread([
+                shape_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("shape_asset.parsing", {
+                    {"address", address}
+                });
                 shape content;
                 if ( !shapes::try_load_shape(content, shape_data->content()) ) {
                     throw shape_asset_loading_exception();
diff --git a/sources/enduro2d/high/assets/spine_asset.cpp b/sources/enduro2d/high/assets/spine_asset.cpp
index 914279a4..ad9a8867 100644
--- a/sources/enduro2d/high/assets/spine_asset.cpp
+++ b/sources/enduro2d/high/assets/spine_asset.cpp
@@ -116,58 +116,72 @@ namespace
         return library.load_asset_async<binary_asset>(atlas_path)
         .then([
             &library,
+            atlas_path,
             atlas_folder
         ](const binary_asset::load_result& atlas_data){
-            auto atlas_internal = std::make_unique<atlas_internal_state>();
+            return the<deferrer>().do_in_worker_thread([](){})
+            .then([
+                &library,
+                atlas_data,
+                atlas_path,
+                atlas_folder
+            ](){
+                E2D_PROFILER_SCOPE_EX("spine_asset.atlas_parsing", {
+                    {"address", atlas_path}
+                });
 
-            spine::atlas_ptr atlas(
-                spAtlas_create(
-                    reinterpret_cast<const char*>(atlas_data->content().data()),
-                    math::numeric_cast<int>(atlas_data->content().size()),
-                    atlas_folder.c_str(),
-                    atlas_internal.get()),
-                spAtlas_dispose);
+                auto atlas_internal = std::make_unique<atlas_internal_state>();
 
-            if ( !atlas ) {
-                the<debug>().error("SPINE: Failed to create preload atlas");
-                throw spine_asset_loading_exception();
-            }
+                spine::atlas_ptr atlas(
+                    spAtlas_create(
+                        reinterpret_cast<const char*>(atlas_data->content().data()),
+                        math::numeric_cast<int>(atlas_data->content().size()),
+                        atlas_folder.c_str(),
+                        atlas_internal.get()),
+                    spAtlas_dispose);
 
-            return stdex::make_tuple_promise(std::make_tuple(
-                atlas_internal->loading.load_async(library),
-                stdex::make_resolved_promise(atlas_data)));
-        })
-        .then([
-            atlas_folder
-        ](const std::tuple<
-            asset_group,
-            binary_asset::load_result
-        >& results){
-            auto atlas_internal = std::make_unique<atlas_internal_state>();
-            atlas_internal->loaded = std::get<0>(results);
+                if ( !atlas ) {
+                    the<debug>().error("SPINE: Failed to create preload atlas");
+                    throw spine_asset_loading_exception();
+                }
 
-            spine::atlas_ptr atlas(
-                spAtlas_create(
-                    reinterpret_cast<const char*>(std::get<1>(results)->content().data()),
-                    math::numeric_cast<int>(std::get<1>(results)->content().size()),
-                    atlas_folder.c_str(),
-                    atlas_internal.get()),
-                spAtlas_dispose);
+                return atlas_internal->loading.load_async(library);
+            })
+            .then([
+                atlas_data,
+                atlas_path,
+                atlas_folder
+            ](auto&& dependencies){
+                E2D_PROFILER_SCOPE_EX("spine_asset.atlas_parsing", {
+                    {"address", atlas_path}
+                });
 
-            if ( !atlas ) {
-                the<debug>().error("SPINE: Failed to create preloaded atlas");
-                throw spine_asset_loading_exception();
-            }
+                auto atlas_internal = std::make_unique<atlas_internal_state>();
+                atlas_internal->loaded = std::forward<decltype(dependencies)>(dependencies);
 
-            for ( const spAtlasPage* page = atlas->pages; page; page = page->next ) {
-                if ( !page->rendererObject ) {
+                spine::atlas_ptr atlas(
+                    spAtlas_create(
+                        reinterpret_cast<const char*>(atlas_data->content().data()),
+                        math::numeric_cast<int>(atlas_data->content().size()),
+                        atlas_folder.c_str(),
+                        atlas_internal.get()),
+                    spAtlas_dispose);
+
+                if ( !atlas ) {
                     the<debug>().error("SPINE: Failed to create preloaded atlas");
                     throw spine_asset_loading_exception();
                 }
-            }
 
-            atlas->rendererObject = nullptr;
-            return atlas;
+                for ( const spAtlasPage* page = atlas->pages; page; page = page->next ) {
+                    if ( !page->rendererObject ) {
+                        the<debug>().error("SPINE: Failed to create preloaded atlas");
+                        throw spine_asset_loading_exception();
+                    }
+                }
+
+                atlas->rendererObject = nullptr;
+                return atlas;
+            });
         });
     }
 
@@ -178,75 +192,85 @@ namespace
         f32 skeleton_scale,
         const spine::atlas_ptr& atlas)
     {
-        return library.load_asset_async<binary_asset>(
-            path::combine(parent_address, skeleton_address))
+        str address = path::combine(parent_address, skeleton_address);
+        return library.load_asset_async<binary_asset>(address)
         .then([
             atlas,
             skeleton_scale,
-            skeleton_address
+            address = std::move(address)
         ](const binary_asset::load_result& skeleton_data){
-            if ( strings::ends_with(skeleton_address, ".skel") ) {
-                using skeleton_bin_ptr = std::unique_ptr<
-                    spSkeletonBinary,
-                    decltype(&::spSkeletonBinary_dispose)>;
+            return the<deferrer>().do_in_worker_thread([
+                atlas,
+                skeleton_scale,
+                address = std::move(address),
+                skeleton_data
+            ](){
+                E2D_PROFILER_SCOPE_EX("spine_asset.skeleton_parsing", {
+                    {"address", address}
+                });
+                if ( strings::ends_with(address, ".skel") ) {
+                    using skeleton_bin_ptr = std::unique_ptr<
+                        spSkeletonBinary,
+                        decltype(&::spSkeletonBinary_dispose)>;
 
-                skeleton_bin_ptr binary_skeleton(
-                    spSkeletonBinary_create(atlas.get()),
-                    spSkeletonBinary_dispose);
+                    skeleton_bin_ptr binary_skeleton(
+                        spSkeletonBinary_create(atlas.get()),
+                        spSkeletonBinary_dispose);
 
-                if ( !binary_skeleton ) {
-                    the<debug>().error("SPINE: Failed to create binary skeleton");
-                    throw spine_asset_loading_exception();
+                    if ( !binary_skeleton ) {
+                        the<debug>().error("SPINE: Failed to create binary skeleton");
+                        throw spine_asset_loading_exception();
+                    }
+
+                    binary_skeleton->scale = skeleton_scale;
+
+                    spine::skeleton_data_ptr data_skeleton(
+                        spSkeletonBinary_readSkeletonData(
+                            binary_skeleton.get(),
+                            reinterpret_cast<const unsigned char*>(skeleton_data->content().data()),
+                            math::numeric_cast<int>(skeleton_data->content().size())),
+                        spSkeletonData_dispose);
+
+                    if ( !data_skeleton ) {
+                        the<debug>().error("SPINE: Failed to read binary skeleton data:\n"
+                            "--> Error: %0",
+                            binary_skeleton->error);
+                        throw spine_asset_loading_exception();
+                    }
+
+                    return data_skeleton;
+                } else {
+                    using skeleton_json_ptr = std::unique_ptr<
+                        spSkeletonJson,
+                        decltype(&::spSkeletonJson_dispose)>;
+
+                    skeleton_json_ptr json_skeleton(
+                        spSkeletonJson_create(atlas.get()),
+                        spSkeletonJson_dispose);
+
+                    if ( !json_skeleton ) {
+                        the<debug>().error("SPINE: Failed to create json skeleton");
+                        throw spine_asset_loading_exception();
+                    }
+
+                    json_skeleton->scale = skeleton_scale;
+
+                    spine::skeleton_data_ptr data_skeleton(
+                        spSkeletonJson_readSkeletonData(
+                            json_skeleton.get(),
+                            reinterpret_cast<const char*>(skeleton_data->content().data())),
+                        spSkeletonData_dispose);
+
+                    if ( !data_skeleton ) {
+                        the<debug>().error("SPINE: Failed to read json skeleton data:\n"
+                            "--> Error: %0",
+                            json_skeleton->error);
+                        throw spine_asset_loading_exception();
+                    }
+
+                    return data_skeleton;
                 }
-
-                binary_skeleton->scale = skeleton_scale;
-
-                spine::skeleton_data_ptr data_skeleton(
-                    spSkeletonBinary_readSkeletonData(
-                        binary_skeleton.get(),
-                        reinterpret_cast<const unsigned char*>(skeleton_data->content().data()),
-                        math::numeric_cast<int>(skeleton_data->content().size())),
-                    spSkeletonData_dispose);
-
-                if ( !data_skeleton ) {
-                    the<debug>().error("SPINE: Failed to read binary skeleton data:\n"
-                        "--> Error: %0",
-                        binary_skeleton->error);
-                    throw spine_asset_loading_exception();
-                }
-
-                return data_skeleton;
-            } else {
-                using skeleton_json_ptr = std::unique_ptr<
-                    spSkeletonJson,
-                    decltype(&::spSkeletonJson_dispose)>;
-
-                skeleton_json_ptr json_skeleton(
-                    spSkeletonJson_create(atlas.get()),
-                    spSkeletonJson_dispose);
-
-                if ( !json_skeleton ) {
-                    the<debug>().error("SPINE: Failed to create json skeleton");
-                    throw spine_asset_loading_exception();
-                }
-
-                json_skeleton->scale = skeleton_scale;
-
-                spine::skeleton_data_ptr data_skeleton(
-                    spSkeletonJson_readSkeletonData(
-                        json_skeleton.get(),
-                        reinterpret_cast<const char*>(skeleton_data->content().data())),
-                    spSkeletonData_dispose);
-
-                if ( !data_skeleton ) {
-                    the<debug>().error("SPINE: Failed to read json skeleton data:\n"
-                        "--> Error: %0",
-                        json_skeleton->error);
-                    throw spine_asset_loading_exception();
-                }
-
-                return data_skeleton;
-            }
+            });
         });
     }
 
diff --git a/sources/enduro2d/high/assets/texture_asset.cpp b/sources/enduro2d/high/assets/texture_asset.cpp
index 491028bc..51ea7ecc 100644
--- a/sources/enduro2d/high/assets/texture_asset.cpp
+++ b/sources/enduro2d/high/assets/texture_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<image_asset>(address)
-        .then([](const image_asset::load_result& texture_data){
-            return the<deferrer>().do_in_main_thread([texture_data](){
+        .then([
+            address = str(address)
+        ](const image_asset::load_result& texture_data){
+            return the<deferrer>().do_in_main_thread([
+                texture_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("texture_asset.create_texture", {
+                    {"address", address}
+                });
                 const texture_ptr content = the<render>().create_texture(
                     texture_data->content());
                 if ( !content ) {
diff --git a/sources/enduro2d/high/assets/xml_asset.cpp b/sources/enduro2d/high/assets/xml_asset.cpp
index de8aec11..e259490a 100644
--- a/sources/enduro2d/high/assets/xml_asset.cpp
+++ b/sources/enduro2d/high/assets/xml_asset.cpp
@@ -24,8 +24,16 @@ namespace e2d
         const library& library, str_view address)
     {
         return library.load_asset_async<text_asset>(address)
-        .then([](const text_asset::load_result& xml_data){
-            return the<deferrer>().do_in_worker_thread([xml_data](){
+        .then([
+            address = str(address)
+        ](const text_asset::load_result& xml_data){
+            return the<deferrer>().do_in_worker_thread([
+                xml_data,
+                address = std::move(address)
+            ](){
+                E2D_PROFILER_SCOPE_EX("xml_asset.parsing", {
+                    {"address", address}
+                });
                 auto xml = std::make_shared<pugi::xml_document>();
                 if ( !xml->load_string(xml_data->content().c_str()) ) {
                     throw xml_asset_loading_exception();
diff --git a/sources/enduro2d/high/luasol.cpp b/sources/enduro2d/high/luasol.cpp
index fa479db7..6031e13b 100644
--- a/sources/enduro2d/high/luasol.cpp
+++ b/sources/enduro2d/high/luasol.cpp
@@ -41,6 +41,8 @@ namespace e2d
     std::optional<script> luasol::load_script(str_view src) {
         E2D_ASSERT(is_in_main_thread());
 
+        E2D_PROFILER_SCOPE("luasol.load_script");
+
         sol::load_result result = state_.load_buffer(
             src.data(), src.size());
 
@@ -62,16 +64,4 @@ namespace e2d
             reinterpret_cast<const char*>(src.data()),
             src.size()));
     }
-
-    std::optional<script> luasol::load_script(const input_stream_uptr& src) {
-        E2D_ASSERT(is_in_main_thread());
-
-        buffer file_data;
-        if ( !streams::try_read_tail(file_data, src) ) {
-            the<debug>().error("LUASOL: Failed to read script stream");
-            return std::nullopt;
-        }
-
-        return load_script(file_data);
-    }
 }
diff --git a/sources/enduro2d/high/systems/render_system.cpp b/sources/enduro2d/high/systems/render_system.cpp
index 8462475a..9c9fc66f 100644
--- a/sources/enduro2d/high/systems/render_system.cpp
+++ b/sources/enduro2d/high/systems/render_system.cpp
@@ -21,9 +21,12 @@ namespace
     using namespace e2d::render_system_impl;
 
     void for_all_scenes(drawer::context& ctx, const ecs::registry& owner) {
+        E2D_PROFILER_SCOPE("render_system.for_all_scenes");
+
         const auto comp = [](const auto& l, const auto& r) noexcept {
             return std::get<scene>(l).depth() < std::get<scene>(r).depth();
         };
+        
         const auto func = [&ctx](
             const ecs::const_entity&,
             const scene&,
@@ -33,6 +36,7 @@ namespace
                 ctx.draw(node);
             });
         };
+        
         systems::for_extracted_sorted_components<scene, actor>(
             owner,
             comp,
@@ -41,9 +45,12 @@ namespace
     }
 
     void for_all_cameras(drawer& drawer, const ecs::registry& owner) {
+        E2D_PROFILER_SCOPE("render_system.for_all_cameras");
+
         const auto comp = [](const auto& l, const auto& r) noexcept {
             return std::get<camera>(l).depth() < std::get<camera>(r).depth();
         };
+        
         const auto func = [&drawer, &owner](
             const ecs::const_entity&,
             const camera& cam,
@@ -53,6 +60,7 @@ namespace
                 for_all_scenes(ctx, owner);
             });
         };
+        
         systems::for_extracted_sorted_components<camera, actor>(
             owner,
             comp,
diff --git a/sources/enduro2d/high/world.cpp b/sources/enduro2d/high/world.cpp
index 3e130584..4af9bde9 100644
--- a/sources/enduro2d/high/world.cpp
+++ b/sources/enduro2d/high/world.cpp
@@ -195,6 +195,8 @@ namespace e2d
     }
 
     gobject world::instantiate(const prefab& prefab, const node_iptr& parent) {
+        E2D_PROFILER_SCOPE("world.instantiate");
+        
         gobject inst = new_instance(*this, prefab);
 
         if ( parent ) {
@@ -216,6 +218,8 @@ namespace e2d
     }
 
     gobject world::instantiate(const prefab& prefab, const node_iptr& parent, const t2f& transform) {
+        E2D_PROFILER_SCOPE("world.instantiate");
+
         gobject inst = new_instance(*this, prefab);
         inst.component<actor>()->node()->transform(transform);
 
@@ -244,6 +248,7 @@ namespace e2d
     }
 
     void world::finalize_instances() noexcept {
+        E2D_PROFILER_SCOPE("world.finalize_instances");
         while ( !destroying_states_.empty() ) {
             gobject inst{&destroying_states_.front()};
             destroying_states_.pop_front();

From 95fee92b207d148ca6406b36f96d8e7c3ad20750 Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Fri, 10 Jan 2020 12:03:56 +0700
Subject: [PATCH 18/19] code style fixes

---
 headers/enduro2d/core/audio.hpp                    |  2 +-
 headers/enduro2d/core/profiler.hpp                 |  8 +++++---
 headers/enduro2d/core/render.hpp                   |  2 +-
 headers/enduro2d/core/window.hpp                   |  2 +-
 headers/enduro2d/utils/buffer_view.hpp             |  2 +-
 headers/enduro2d/utils/url.hpp                     |  2 +-
 samples/sources/sample_00/sample_00.cpp            |  2 +-
 samples/sources/sample_01/sample_01.cpp            |  2 +-
 samples/sources/sample_02/sample_02.cpp            |  2 +-
 samples/sources/sample_03/sample_03.cpp            | 14 ++++++++++++++
 samples/sources/sample_05/sample_05.cpp            |  4 ++--
 sources/enduro2d/core/audio_impl/audio_bass.cpp    |  2 +-
 .../enduro2d/core/audio_impl/audio_bass_impl.cpp   |  2 +-
 sources/enduro2d/core/dbgui.cpp                    |  2 +-
 sources/enduro2d/core/engine.cpp                   |  2 +-
 sources/enduro2d/core/profiler.cpp                 | 13 ++++++-------
 sources/enduro2d/core/render_impl/render_none.cpp  |  2 +-
 .../enduro2d/core/render_impl/render_opengl.cpp    |  2 +-
 sources/enduro2d/core/vfs.cpp                      |  4 ++--
 sources/enduro2d/high/starter.cpp                  |  2 +-
 sources/enduro2d/high/systems/render_system.cpp    |  8 ++++----
 sources/enduro2d/high/world.cpp                    |  2 +-
 22 files changed, 49 insertions(+), 34 deletions(-)

diff --git a/headers/enduro2d/core/audio.hpp b/headers/enduro2d/core/audio.hpp
index 824dbe16..997e78fd 100644
--- a/headers/enduro2d/core/audio.hpp
+++ b/headers/enduro2d/core/audio.hpp
@@ -96,7 +96,7 @@ namespace e2d
 
         void volume(f32 value) noexcept;
         [[nodiscard]] f32 volume() const noexcept;
-        
+
         void resume() noexcept;
         void pause() noexcept;
     private:
diff --git a/headers/enduro2d/core/profiler.hpp b/headers/enduro2d/core/profiler.hpp
index 282d348d..d161231f 100644
--- a/headers/enduro2d/core/profiler.hpp
+++ b/headers/enduro2d/core/profiler.hpp
@@ -8,6 +8,8 @@
 
 #include "_core.hpp"
 
+#include "deferrer.hpp"
+
 namespace e2d
 {
     class profiler final : public module<profiler> {
@@ -156,7 +158,7 @@ namespace e2d
 
             void on_event(const event_info& event) noexcept final {
                 const bool skip = info_.events.empty() && depth_;
-                
+
                 if ( std::holds_alternative<begin_scope_info>(event) ) {
                     ++depth_;
                 } else if ( std::holds_alternative<end_scope_info>(event) ) {
@@ -168,7 +170,7 @@ namespace e2d
                     if ( !skip ) {
                         info_.events.push_back(event);
                     }
-                    
+
                     if ( !depth_ && time_point_ <= Clock::now() ) {
                         promise_.resolve(std::move(info_));
                     }
@@ -212,7 +214,7 @@ namespace e2d::profilers
     bool try_save_recording_info(
         const profiler::recording_info& src,
         buffer& dst) noexcept;
-    
+
     bool try_save_recording_info(
         const profiler::recording_info& src,
         const output_stream_uptr& dst) noexcept;
diff --git a/headers/enduro2d/core/render.hpp b/headers/enduro2d/core/render.hpp
index c535d7e2..adf88318 100644
--- a/headers/enduro2d/core/render.hpp
+++ b/headers/enduro2d/core/render.hpp
@@ -906,7 +906,7 @@ namespace e2d
         shader_ptr create_shader(
             str_view vertex_source,
             str_view fragment_source);
-        
+
         shader_ptr create_shader(
             buffer_view vertex_source,
             buffer_view fragment_source);
diff --git a/headers/enduro2d/core/window.hpp b/headers/enduro2d/core/window.hpp
index ddbb7501..f75bc306 100644
--- a/headers/enduro2d/core/window.hpp
+++ b/headers/enduro2d/core/window.hpp
@@ -105,7 +105,7 @@ namespace e2d
     private:
         debug& debug_;
     };
-    
+
     class window_input_source final : public window::event_listener {
     public:
         window_input_source(input& input) noexcept;
diff --git a/headers/enduro2d/utils/buffer_view.hpp b/headers/enduro2d/utils/buffer_view.hpp
index 7d2b81d1..be2294ed 100644
--- a/headers/enduro2d/utils/buffer_view.hpp
+++ b/headers/enduro2d/utils/buffer_view.hpp
@@ -61,7 +61,7 @@ namespace e2d
     buffer_view::buffer_view(const std::array<T,N>& buffer) noexcept
     : data_(buffer.data())
     , size_(buffer.size() * sizeof(T)) {}
-    
+
     template < typename T, std::size_t N >
     buffer_view::buffer_view(const T (&buffer)[N]) noexcept
     : data_(&buffer[0])
diff --git a/headers/enduro2d/utils/url.hpp b/headers/enduro2d/utils/url.hpp
index 4e1c5102..115961f1 100644
--- a/headers/enduro2d/utils/url.hpp
+++ b/headers/enduro2d/utils/url.hpp
@@ -38,7 +38,7 @@ namespace e2d
 
         const str& scheme() const noexcept;
         const str& path() const noexcept;
-        
+
         str schemepath() const;
 
         url& operator+=(str_view path);
diff --git a/samples/sources/sample_00/sample_00.cpp b/samples/sources/sample_00/sample_00.cpp
index a3ddca95..475374d9 100644
--- a/samples/sources/sample_00/sample_00.cpp
+++ b/samples/sources/sample_00/sample_00.cpp
@@ -96,7 +96,7 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
-            
+
             image texture1_image;
             if ( !images::try_load_image(texture1_image, the<vfs>().read(url("ships://ship (2).png"))) ) {
                 return false;
diff --git a/samples/sources/sample_01/sample_01.cpp b/samples/sources/sample_01/sample_01.cpp
index 6e9a9930..7259897a 100644
--- a/samples/sources/sample_01/sample_01.cpp
+++ b/samples/sources/sample_01/sample_01.cpp
@@ -156,7 +156,7 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
-            
+
             image texture_image;
             if ( !images::try_load_image(texture_image, the<vfs>().read(url("ships://ship (3).png"))) ) {
                 return false;
diff --git a/samples/sources/sample_02/sample_02.cpp b/samples/sources/sample_02/sample_02.cpp
index 3f953597..7878d72b 100644
--- a/samples/sources/sample_02/sample_02.cpp
+++ b/samples/sources/sample_02/sample_02.cpp
@@ -111,7 +111,7 @@ namespace
             the<vfs>().register_scheme_alias(
                 "ships",
                 url("piratepack://PNG/Retina/Ships"));
-            
+
             image texture_image;
             if ( !images::try_load_image(texture_image, the<vfs>().read(url("ships://ship (3).png"))) ) {
                 return false;
diff --git a/samples/sources/sample_03/sample_03.cpp b/samples/sources/sample_03/sample_03.cpp
index 723995f4..b8b1e396 100644
--- a/samples/sources/sample_03/sample_03.cpp
+++ b/samples/sources/sample_03/sample_03.cpp
@@ -36,6 +36,20 @@ namespace
             if ( k.is_key_pressed(keyboard_key::lsuper) && k.is_key_just_released(keyboard_key::enter) ) {
                 the<window>().toggle_fullscreen(!the<window>().fullscreen());
             }
+
+            if ( k.is_key_just_released(keyboard_key::space) ) {
+                the<profiler>().record_for(std::chrono::seconds(1))
+                .then([](const profiler::recording_info& info){
+                    the<debug>().trace("Profile done: %0", info.events.size());
+                    profilers::try_save_recording_info(info, the<vfs>().write({"desktop", "trace.json"}, false));
+                });
+                the<deferrer>().do_in_main_thread([](){
+                    the<library>().load_asset_async<prefab_asset>("scenes/spine_scene_prefab.json")
+                    .then([](const prefab_asset::load_result& prefab_data){
+                        the<world>().instantiate(prefab_data->content());
+                    });
+                });
+            }
         }
     };
 
diff --git a/samples/sources/sample_05/sample_05.cpp b/samples/sources/sample_05/sample_05.cpp
index 24917718..a963c62d 100644
--- a/samples/sources/sample_05/sample_05.cpp
+++ b/samples/sources/sample_05/sample_05.cpp
@@ -19,7 +19,7 @@ namespace
             the<vfs>().register_scheme_alias(
                 "audio",
                 url("rpgaudio://Audio"));
-            
+
             auto sstream1 = the<audio>().create_stream(the<vfs>().read(url("audio://chop.ogg")));
             auto sstream2 = the<audio>().create_stream(*the<vfs>().load(url("audio://footstep00.ogg")));
 
@@ -29,7 +29,7 @@ namespace
 
             sound_src1_ = the<audio>().create_source(sstream1);
             sound_src2_ = the<audio>().create_source(sstream2);
-            
+
             if ( !sound_src1_ || !sound_src2_ ) {
                 return false;
             }
diff --git a/sources/enduro2d/core/audio_impl/audio_bass.cpp b/sources/enduro2d/core/audio_impl/audio_bass.cpp
index bd83c57b..5af43688 100644
--- a/sources/enduro2d/core/audio_impl/audio_bass.cpp
+++ b/sources/enduro2d/core/audio_impl/audio_bass.cpp
@@ -235,7 +235,7 @@ namespace e2d
         HCHANNEL channel = stream->state().stream()
             ? stream->state().sound()
             : BASS_SampleGetChannel(stream->state().sound(), FALSE);
-            
+
         if ( !channel ) {
             state_->dbg().error("AUDIO: can net retrive sound channel");
             return nullptr;
diff --git a/sources/enduro2d/core/audio_impl/audio_bass_impl.cpp b/sources/enduro2d/core/audio_impl/audio_bass_impl.cpp
index aaa12af2..84916684 100644
--- a/sources/enduro2d/core/audio_impl/audio_bass_impl.cpp
+++ b/sources/enduro2d/core/audio_impl/audio_bass_impl.cpp
@@ -43,7 +43,7 @@ namespace e2d
     const input_stream_uptr& sound_stream::internal_state::stream() const noexcept {
         return stream_;
     }
-    
+
     //
     // sound_source::internal_state
     //
diff --git a/sources/enduro2d/core/dbgui.cpp b/sources/enduro2d/core/dbgui.cpp
index 96737ea4..9d714c78 100644
--- a/sources/enduro2d/core/dbgui.cpp
+++ b/sources/enduro2d/core/dbgui.cpp
@@ -179,7 +179,7 @@ namespace e2d
 
             io.DisplaySize =
                 window_.real_size().cast_to<f32>();
-            
+
             io.DisplayFramebufferScale = io.DisplaySize.x > 0.f && io.DisplaySize.y > 0.f
                 ? window_.framebuffer_size().cast_to<f32>() / v2f(io.DisplaySize)
                 : v2f(1.f, 1.f);
diff --git a/sources/enduro2d/core/engine.cpp b/sources/enduro2d/core/engine.cpp
index 964ea43b..27e207fc 100644
--- a/sources/enduro2d/core/engine.cpp
+++ b/sources/enduro2d/core/engine.cpp
@@ -519,7 +519,7 @@ namespace e2d
                 app->shutdown();
                 throw;
             }
-            
+
             the<input>().frame_tick();
             window::poll_events();
 
diff --git a/sources/enduro2d/core/profiler.cpp b/sources/enduro2d/core/profiler.cpp
index b1e9ce10..b374cfdb 100644
--- a/sources/enduro2d/core/profiler.cpp
+++ b/sources/enduro2d/core/profiler.cpp
@@ -6,7 +6,6 @@
 
 #include <enduro2d/core/profiler.hpp>
 
-#include <enduro2d/core/deferrer.hpp>
 #include <enduro2d/core/engine.hpp>
 #include <enduro2d/core/vfs.hpp>
 
@@ -28,7 +27,7 @@ namespace
 
     str recording_info_to_json(const profiler::recording_info& src) {
         str dst("{\"traceEvents\":[\n");
-        
+
         dst += strings::rformat(
             "  {\"name\":\"thread_name\",\"ph\":\"M\",\"tid\":%0,\"pid\":0,\"args\":{\"name\":\"%1\"}},\n",
             std::hash<std::thread::id>()(the<engine>().main_thread()),
@@ -159,7 +158,7 @@ namespace e2d
             std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
-        
+
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
             if ( sink ) {
@@ -175,7 +174,7 @@ namespace e2d
         end_scope_info event{
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
-        
+
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
             if ( sink ) {
@@ -194,7 +193,7 @@ namespace e2d
             std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
-        
+
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
             if ( sink ) {
@@ -213,7 +212,7 @@ namespace e2d
             std::move(args),
             std::this_thread::get_id(),
             time::to_chrono(time::now_us())};
-        
+
         std::lock_guard guard(rmutex_);
         for ( const auto& sink : sinks_ ) {
             if ( sink ) {
@@ -237,7 +236,7 @@ namespace e2d::profilers
             return false;
         }
     }
-    
+
     bool try_save_recording_info(
         const profiler::recording_info& src,
         const output_stream_uptr& dst) noexcept
diff --git a/sources/enduro2d/core/render_impl/render_none.cpp b/sources/enduro2d/core/render_impl/render_none.cpp
index 666dfd2c..4d10eda5 100644
--- a/sources/enduro2d/core/render_impl/render_none.cpp
+++ b/sources/enduro2d/core/render_impl/render_none.cpp
@@ -245,7 +245,7 @@ namespace e2d
         E2D_UNUSED(command);
         return *this;
     }
-    
+
     render& render::update_buffer(
         const index_buffer_ptr& ibuffer,
         buffer_view indices,
diff --git a/sources/enduro2d/core/render_impl/render_opengl.cpp b/sources/enduro2d/core/render_impl/render_opengl.cpp
index 52d22e83..bbd191e5 100644
--- a/sources/enduro2d/core/render_impl/render_opengl.cpp
+++ b/sources/enduro2d/core/render_impl/render_opengl.cpp
@@ -514,7 +514,7 @@ namespace e2d
         }
 
         gl_shader_id fs(state_->dbg());
-        
+
         {
             E2D_PROFILER_SCOPE("render.compile_fragment_shader");
 
diff --git a/sources/enduro2d/core/vfs.cpp b/sources/enduro2d/core/vfs.cpp
index 15e73bea..ad14b439 100644
--- a/sources/enduro2d/core/vfs.cpp
+++ b/sources/enduro2d/core/vfs.cpp
@@ -179,7 +179,7 @@ namespace e2d
             {"url", url.schemepath()}
         });
         return load_async(url).then([](auto&& src){
-            return std::optional(std::forward<decltype(src)>(src));
+            return std::optional<buffer>(std::forward<decltype(src)>(src));
         }).get_or_default(std::nullopt);
     }
 
@@ -202,7 +202,7 @@ namespace e2d
             {"url", url.schemepath()}
         });
         return load_as_string_async(url).then([](auto&& src){
-            return std::optional(std::forward<decltype(src)>(src));
+            return std::optional<str>(std::forward<decltype(src)>(src));
         }).get_or_default(std::nullopt);
     }
 
diff --git a/sources/enduro2d/high/starter.cpp b/sources/enduro2d/high/starter.cpp
index e2c4f587..54cb288e 100644
--- a/sources/enduro2d/high/starter.cpp
+++ b/sources/enduro2d/high/starter.cpp
@@ -99,7 +99,7 @@ namespace
 
         void frame_render() final {
             E2D_PROFILER_SCOPE("application.frame_render");
-           
+
             world& w = the<world>();
 
             {
diff --git a/sources/enduro2d/high/systems/render_system.cpp b/sources/enduro2d/high/systems/render_system.cpp
index 9c9fc66f..264ee187 100644
--- a/sources/enduro2d/high/systems/render_system.cpp
+++ b/sources/enduro2d/high/systems/render_system.cpp
@@ -26,7 +26,7 @@ namespace
         const auto comp = [](const auto& l, const auto& r) noexcept {
             return std::get<scene>(l).depth() < std::get<scene>(r).depth();
         };
-        
+
         const auto func = [&ctx](
             const ecs::const_entity&,
             const scene&,
@@ -36,7 +36,7 @@ namespace
                 ctx.draw(node);
             });
         };
-        
+
         systems::for_extracted_sorted_components<scene, actor>(
             owner,
             comp,
@@ -50,7 +50,7 @@ namespace
         const auto comp = [](const auto& l, const auto& r) noexcept {
             return std::get<camera>(l).depth() < std::get<camera>(r).depth();
         };
-        
+
         const auto func = [&drawer, &owner](
             const ecs::const_entity&,
             const camera& cam,
@@ -60,7 +60,7 @@ namespace
                 for_all_scenes(ctx, owner);
             });
         };
-        
+
         systems::for_extracted_sorted_components<camera, actor>(
             owner,
             comp,
diff --git a/sources/enduro2d/high/world.cpp b/sources/enduro2d/high/world.cpp
index 4af9bde9..3d8313ce 100644
--- a/sources/enduro2d/high/world.cpp
+++ b/sources/enduro2d/high/world.cpp
@@ -196,7 +196,7 @@ namespace e2d
 
     gobject world::instantiate(const prefab& prefab, const node_iptr& parent) {
         E2D_PROFILER_SCOPE("world.instantiate");
-        
+
         gobject inst = new_instance(*this, prefab);
 
         if ( parent ) {

From dbd6481579069140c9df09ae58cd5fcf4b99038c Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Fri, 10 Jan 2020 15:14:02 +0700
Subject: [PATCH 19/19] update promise module

---
 modules/promise.hpp                     |  2 +-
 samples/sources/sample_03/sample_03.cpp | 14 --------------
 2 files changed, 1 insertion(+), 15 deletions(-)

diff --git a/modules/promise.hpp b/modules/promise.hpp
index 388fcb3e..22380ff9 160000
--- a/modules/promise.hpp
+++ b/modules/promise.hpp
@@ -1 +1 @@
-Subproject commit 388fcb3ead7bf057f89ace08807b705ab3944af0
+Subproject commit 22380ff930c58a9ba391bceb8bd8f0a2a985f63b
diff --git a/samples/sources/sample_03/sample_03.cpp b/samples/sources/sample_03/sample_03.cpp
index b8b1e396..723995f4 100644
--- a/samples/sources/sample_03/sample_03.cpp
+++ b/samples/sources/sample_03/sample_03.cpp
@@ -36,20 +36,6 @@ namespace
             if ( k.is_key_pressed(keyboard_key::lsuper) && k.is_key_just_released(keyboard_key::enter) ) {
                 the<window>().toggle_fullscreen(!the<window>().fullscreen());
             }
-
-            if ( k.is_key_just_released(keyboard_key::space) ) {
-                the<profiler>().record_for(std::chrono::seconds(1))
-                .then([](const profiler::recording_info& info){
-                    the<debug>().trace("Profile done: %0", info.events.size());
-                    profilers::try_save_recording_info(info, the<vfs>().write({"desktop", "trace.json"}, false));
-                });
-                the<deferrer>().do_in_main_thread([](){
-                    the<library>().load_asset_async<prefab_asset>("scenes/spine_scene_prefab.json")
-                    .then([](const prefab_asset::load_result& prefab_data){
-                        the<world>().instantiate(prefab_data->content());
-                    });
-                });
-            }
         }
     };