raw pointers for draw command

headers/enduro2d/core/render.hpp

@@ -665,14 +665,8 @@ namespace e2d
             u8 _pad[4] = {0};
         };
 
-        class material;
-        using material_ptr = std::shared_ptr<material>;
-
         class material final {
         public:
-            static material_ptr create();
-            static material_ptr create(const material& mat);
-
             material& add_pass(const pass_state& pass) noexcept;
             std::size_t pass_count() const noexcept;
 
@@ -690,14 +684,8 @@ namespace e2d
             property_block properties_;
         };
 
-        class geometry;
-        using geometry_ptr = std::shared_ptr<geometry>;
-
         class geometry final {
         public:
-            static geometry_ptr create();
-            static geometry_ptr create(const geometry& geo);
-
             geometry& add_vertices(const vertex_buffer_ptr& vb) noexcept;
             std::size_t vertices_count() const noexcept;
 
@@ -734,24 +722,21 @@ namespace e2d
 
         class draw_command final {
         public:
-            draw_command() = default;
+            draw_command() = delete;
-            draw_command(const material_ptr& mat, const geometry_ptr& geo) noexcept;
+            draw_command(const material& mat, const geometry& geo) noexcept;
+            draw_command(const material& mat, const geometry& geo, const property_block& props) noexcept;
 
-            draw_command& material(const material_ptr& value) noexcept;
+            draw_command& material_ref(const material& value) noexcept;
-            draw_command& geometry(const geometry_ptr& value) noexcept;
+            draw_command& geometry_ref(const geometry& value) noexcept;
-            draw_command& properties(const property_block& value);
+            draw_command& properties_ref(const property_block& value);
 
-            material_ptr& material() noexcept;
+            const material& material_ref() const noexcept;
-            geometry_ptr& geometry() noexcept;
+            const geometry& geometry_ref() const noexcept;
-            property_block& properties() noexcept;
+            const property_block& properties_ref() const noexcept;
-
-            const material_ptr& material() const noexcept;
-            const geometry_ptr& geometry() const noexcept;
-            const property_block& properties() const noexcept;
         private:
-            material_ptr material_;
+            const material* material_ = nullptr;
-            geometry_ptr geometry_;
+            const geometry* geometry_ = nullptr;
-            property_block properties_;
+            const property_block* properties_ = nullptr;
         };
 
         class clear_command final {

samples/sources/sample_00/sample_00.cpp

@@ -144,7 +144,7 @@ int e2d_main() {
         return 1;
     }
 
-    auto material = render::material::create(render::material()
+    auto material = render::material()
         .add_pass(render::pass_state()
             .states(render::state_block()
                 .capabilities(render::capabilities_state()
@@ -161,12 +161,12 @@ int e2d_main() {
                 .sampler("u_texture2", render::sampler_state()
                     .texture(texture2)
                     .min_filter(render::sampler_min_filter::linear)
-                    .mag_filter(render::sampler_mag_filter::linear)))));
+                    .mag_filter(render::sampler_mag_filter::linear))));
 
-    auto geometry = render::geometry::create(render::geometry()
+    auto geometry = render::geometry()
         .indices(index_buffer)
         .add_vertices(vertex_buffer1)
-        .add_vertices(vertex_buffer2));
+        .add_vertices(vertex_buffer2);
 
     const auto begin_game_time = time::now_ms();
     const auto framebuffer_size = the<window>().real_size().cast_to<f32>();
@@ -176,16 +176,16 @@ int e2d_main() {
     while ( !the<window>().should_close() && !k.is_key_just_released(keyboard_key::escape) ) {
         const auto game_time = (time::now_ms() - begin_game_time).cast_to<f32>().value;
 
-        material->properties()
+        material.properties()
             .property("u_time", game_time)
             .property("u_MVP", projection);
 
         the<render>().execute(render::command_block<64>()
             .add_command(render::clear_command()
                 .color_value({1.f, 0.4f, 0.f, 1.f}))
-            .add_command(render::draw_command(material, geometry)));
+            .add_command(render::draw_command(material, geometry))
+            .add_command(render::swap_command(true)));
 
-        the<window>().swap_buffers(true);
         the<input>().frame_tick();
         window::poll_events();
     }

samples/sources/sample_01/sample_01.cpp

@@ -202,7 +202,7 @@ int e2d_main() {
         return 1;
     }
 
-    auto material = render::material::create(render::material()
+    auto material = render::material()
         .add_pass(render::pass_state()
             .states(render::state_block()
                 .capabilities(render::capabilities_state()
@@ -216,12 +216,12 @@ int e2d_main() {
                 .sampler("u_texture", render::sampler_state()
                     .texture(texture)
                     .min_filter(render::sampler_min_filter::linear)
-                    .mag_filter(render::sampler_mag_filter::linear)))));
+                    .mag_filter(render::sampler_mag_filter::linear))));
 
-    auto geometry = render::geometry::create(render::geometry()
+    auto geometry = render::geometry()
         .indices(index_buffer)
         .add_vertices(vertex_buffer1)
-        .add_vertices(vertex_buffer2));
+        .add_vertices(vertex_buffer2);
 
     const auto begin_game_time = time::now_ms();
     const auto framebuffer_size = the<window>().real_size().cast_to<f32>();
@@ -243,16 +243,16 @@ int e2d_main() {
             math::make_loot_at_lh_matrix4({0.f,0.f,-3.f}, v3f::zero(), v3f::unit_y()) *
             projection;
 
-        material->properties()
+        material.properties()
             .property("u_time", game_time)
             .property("u_MVP", MVP);
 
         the<render>().execute(render::command_block<64>()
             .add_command(render::clear_command()
                 .color_value({1.f, 0.4f, 0.f, 1.f}))
-            .add_command(render::draw_command(material, geometry)));
+            .add_command(render::draw_command(material, geometry))
+            .add_command(render::swap_command(true)));
 
-        the<window>().swap_buffers(true);
         the<input>().frame_tick();
         window::poll_events();
     }

samples/sources/sample_02/sample_02.cpp

@@ -151,7 +151,7 @@ int e2d_main() {
         return 1;
     }
 
-    auto material = render::material::create(render::material()
+    auto material = render::material()
         .add_pass(render::pass_state()
             .states(render::state_block()
                 .capabilities(render::capabilities_state()
@@ -169,11 +169,11 @@ int e2d_main() {
             .sampler("u_texture", render::sampler_state()
                 .texture(texture)
                 .min_filter(render::sampler_min_filter::linear)
-                .mag_filter(render::sampler_mag_filter::linear))));
+                .mag_filter(render::sampler_mag_filter::linear)));
 
-    auto geometry = render::geometry::create(render::geometry()
+    auto geometry = render::geometry()
         .indices(index_buffer)
-        .add_vertices(vertex_buffer));
+        .add_vertices(vertex_buffer);
 
     const auto begin_game_time = time::now_ms();
     const auto framebuffer_size = the<window>().real_size().cast_to<f32>();
@@ -189,6 +189,18 @@ int e2d_main() {
         pixel_declaration::pixel_type::depth16,
         render_target::external_texture::color_and_depth);
 
+    auto rt_props = render::property_block()
+        .sampler("u_texture", render::sampler_state()
+            .texture(rt->color())
+            .min_filter(render::sampler_min_filter::linear)
+            .mag_filter(render::sampler_mag_filter::linear));
+
+    auto texture_props = render::property_block()
+        .sampler("u_texture", render::sampler_state()
+            .texture(texture)
+            .min_filter(render::sampler_min_filter::linear)
+            .mag_filter(render::sampler_mag_filter::linear));
+
     const keyboard& k = the<input>().keyboard();
     while ( !the<window>().should_close() && !k.is_key_just_released(keyboard_key::escape) ) {
         const auto game_time = (time::now_ms() - begin_game_time).cast_to<f32>().value;
@@ -201,7 +213,7 @@ int e2d_main() {
             math::make_loot_at_lh_matrix4({0.f,0.f,-2.f}, v3f::zero(), v3f::unit_y()) *
             projection;
 
-        material->properties()
+        material.properties()
             .property("u_time", game_time)
             .property("u_MVP", MVP);
 
@@ -210,26 +222,19 @@ int e2d_main() {
             .add_command(render::viewport_command(rt->size()))
             .add_command(render::clear_command()
                 .color_value({0.f, 0.4f, 0.f, 1.f}))
-            .add_command(render::draw_command(material, geometry)
+            .add_command(render::draw_command(material, geometry, texture_props)));
-                .properties(render::property_block()
+
-                    .sampler("u_texture", render::sampler_state()
+        the<render>().execute(render::command_block<64>()
-                        .texture(texture)
-                        .min_filter(render::sampler_min_filter::linear)
-                        .mag_filter(render::sampler_mag_filter::linear))))
             .add_command(render::render_target_command(nullptr))
             .add_command(render::viewport_command(the<window>().real_size()))
             .add_command(render::clear_command()
-                .color_value({1.f, 0.4f, 0.f, 1.f}))
+                .color_value({1.f, 0.4f, 0.f, 1.f})));
-            .add_command(render::draw_command(material, geometry)
-                .properties(render::property_block()
-                    .sampler("u_texture", render::sampler_state()
-                        .texture(rt->color())
-                        .min_filter(render::sampler_min_filter::linear)
-                        .mag_filter(render::sampler_mag_filter::linear))))
-            .add_command(render::swap_command(true)));
 
-        std::this_thread::sleep_for(
+        for ( std::size_t i = 0; i < 5000; ++i ) {
-            time::to_chrono(make_milliseconds(10)));
+            the<render>().execute(render::draw_command(material, geometry, rt_props));
+        }
+
+        the<render>().execute(render::swap_command(true));
 
         the<input>().frame_tick();
         window::poll_events();

sources/enduro2d/core/render.cpp

@@ -768,14 +768,6 @@ namespace e2d
     // material
     //
 
-    render::material_ptr render::material::create() {
-        return std::make_shared<material>();
-    }
-
-    render::material_ptr render::material::create(const material& mat) {
-        return std::make_shared<material>(mat);
-    }
-
     render::material& render::material::add_pass(const pass_state& pass) noexcept {
         E2D_ASSERT(pass_count_ < max_pass_count);
         passes_[pass_count_] = pass;
@@ -812,14 +804,6 @@ namespace e2d
     // geometry
     //
 
-    render::geometry_ptr render::geometry::create() {
-        return std::make_shared<geometry>();
-    }
-
-    render::geometry_ptr render::geometry::create(const geometry& geo) {
-        return std::make_shared<geometry>(geo);
-    }
-
     render::geometry& render::geometry::add_vertices(const vertex_buffer_ptr& vb) noexcept {
         E2D_ASSERT(vertices_count_ < max_vertices_count);
         vertices_[vertices_count_] = vb;
@@ -897,47 +881,43 @@ namespace e2d
     // draw_command
     //
 
-    render::draw_command::draw_command(const material_ptr& mat, const geometry_ptr& geo) noexcept
+    render::draw_command::draw_command(const material& mat, const geometry& geo) noexcept
-    : material_(mat)
+    : material_(&mat)
-    , geometry_(geo) {}
+    , geometry_(&geo) {}
 
-    render::draw_command& render::draw_command::material(const material_ptr& value) noexcept {
+    render::draw_command::draw_command(const material& mat, const geometry& geo, const property_block& props) noexcept
-        material_ = value;
+    : material_(&mat)
+    , geometry_(&geo)
+    , properties_(&props) {}
+
+    render::draw_command& render::draw_command::material_ref(const material& value) noexcept {
+        material_ = &value;
         return *this;
     }
 
-    render::draw_command& render::draw_command::geometry(const geometry_ptr& value) noexcept {
+    render::draw_command& render::draw_command::geometry_ref(const geometry& value) noexcept {
-        geometry_ = value;
+        geometry_ = &value;
         return *this;
     }
 
-    render::draw_command& render::draw_command::properties(const property_block& value) {
+    render::draw_command& render::draw_command::properties_ref(const property_block& value) {
-        properties_ = value;
+        properties_ = &value;
         return *this;
     }
 
-    render::material_ptr& render::draw_command::material() noexcept {
+    const render::material& render::draw_command::material_ref() const noexcept {
-        return material_;
+        E2D_ASSERT_MSG(material_, "draw command with empty material");
+        return *material_;
     }
 
-    render::geometry_ptr& render::draw_command::geometry() noexcept {
+    const render::geometry& render::draw_command::geometry_ref() const noexcept {
-        return geometry_;
+        E2D_ASSERT_MSG(material_, "draw command with empty geometry");
+        return *geometry_;
     }
 
-    render::property_block& render::draw_command::properties() noexcept {
+    const render::property_block& render::draw_command::properties_ref() const noexcept {
-        return properties_;
+        static property_block empty_property_block;
-    }
+        return properties_ ? *properties_ : empty_property_block;
-
-    const render::material_ptr& render::draw_command::material() const noexcept {
-        return material_;
-    }
-
-    const render::geometry_ptr& render::draw_command::geometry() const noexcept {
-        return geometry_;
-    }
-
-    const render::property_block& render::draw_command::properties() const noexcept {
-        return properties_;
     }
 
     //

sources/enduro2d/core/render_impl/render_opengl.cpp

@@ -744,17 +744,14 @@ namespace e2d
 
     render& render::execute(const draw_command& command) {
         E2D_ASSERT(main_thread() == std::this_thread::get_id());
-        E2D_ASSERT_MSG(command.material(), "draw command with empty material");
-        E2D_ASSERT_MSG(command.geometry(), "draw command with empty geometry");
 
-        const material& mat = *command.material();
+        const material& mat = command.material_ref();
-        const geometry& geo = *command.geometry();
+        const geometry& geo = command.geometry_ref();
-        const property_block& props = command.properties();
+        const property_block& props = command.properties_ref();
 
         for ( std::size_t i = 0, e = mat.pass_count(); i < e; ++i ) {
             const pass_state& pass = mat.pass(i);
             const property_block& main_props = main_property_cache()
-                .clear()
                 .merge(mat.properties())
                 .merge(pass.properties())
                 .merge(props);
@@ -765,6 +762,7 @@ namespace e2d
                     draw_indexed_primitive(state_->dbg(), geo.topo(), geo.indices());
                 });
             });
+            main_property_cache().clear();
         }
         return *this;
     }