high level sample

samples/bin/library/gnome.e2d_mesh

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ab164b79bb190d2ffb325801de93a71b5d7059ad78da21b324532c680029951
+size 20856

samples/bin/library/gnome.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13585b9048ffa1bd498f8db27b6dd3e292a08af5f08fa37db5cae46b32deb8b5
+size 112750

samples/bin/library/gnome_material.json

@@ -0,0 +1,16 @@
+{
+    "passes" : [{
+        "shader" : "model_shader.json",
+        "state_block" : {
+            "capabilities_state" : {
+                "depth_test" : true
+            }
+        }
+    }],
+    "property_block" : {
+        "samplers" : [{
+            "name" : "u_texture",
+            "texture" : "gnome.png"
+        }]
+    }
+}

samples/bin/library/gnome_model.json

@@ -0,0 +1,6 @@
+{
+    "mesh" : "gnome.e2d_mesh",
+    "materials" : [
+        "gnome_material.json"
+    ]
+}

samples/bin/library/model_shader.frag

@@ -0,0 +1,10 @@
+#version 120
+
+uniform sampler2D u_texture;
+
+varying vec2 v_st0;
+
+void main() {
+    vec2 st = vec2(v_st0.s, 1.0 - v_st0.t);
+    gl_FragColor = texture2D(u_texture, st);
+}

samples/bin/library/model_shader.json

@@ -0,0 +1,4 @@
+{
+    "vertex" : "model_shader.vert",
+    "fragment" : "model_shader.frag"
+}

samples/bin/library/model_shader.vert

@@ -0,0 +1,14 @@
+#version 120
+
+uniform mat4 u_matrix_m;
+uniform mat4 u_matrix_vp;
+
+attribute vec3 a_vertex;
+attribute vec2 a_st0;
+
+varying vec2 v_st0;
+
+void main() {
+    v_st0 = a_st0;
+    gl_Position = vec4(a_vertex, 1.0) * u_matrix_m * u_matrix_vp;
+}

samples/bin/library/ship.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65cbe87077ff41bd595d1e17d68240e3e18972ea0c018707d35c695d86389b0d
+size 3513

samples/bin/library/ship_sprite.json

@@ -0,0 +1,7 @@
+{
+    "size" : { "x" : 66, "y" : 113 },
+    "pivot" : { "x" : 0.5, "y" : 0.5 },
+    "texrect" : { "w" : 1, "h" : 1 },
+    "texture" : "ship.png",
+    "material" : "sprite_material.json"
+}

samples/bin/library/sprite_material.json

@@ -0,0 +1,14 @@
+{
+    "passes" : [{
+        "shader" : "sprite_shader.json",
+        "state_block" : {
+            "blending_state" : {
+                "src_factor" : "src_alpha",
+                "dst_factor" : "one_minus_src_alpha"
+            },
+            "capabilities_state" : {
+                "blending" : true
+            }
+        }
+    }]
+}

samples/bin/library/sprite_shader.frag

@@ -0,0 +1,11 @@
+#version 120
+
+uniform sampler2D u_texture;
+
+varying vec4 v_tint;
+varying vec2 v_st;
+
+void main() {
+    vec2 st = vec2(v_st.s, 1.0 - v_st.t);
+    gl_FragColor = texture2D(u_texture, st) * v_tint;
+}

samples/bin/library/sprite_shader.json

@@ -0,0 +1,4 @@
+{
+    "vertex" : "sprite_shader.vert",
+    "fragment" : "sprite_shader.frag"
+}

samples/bin/library/sprite_shader.vert

@@ -0,0 +1,16 @@
+#version 120
+
+uniform mat4 u_matrix_vp;
+
+attribute vec3 a_vertex;
+attribute vec4 a_tint;
+attribute vec2 a_st;
+
+varying vec4 v_tint;
+varying vec2 v_st;
+
+void main() {
+    v_st = a_st;
+    v_tint = a_tint;
+    gl_Position = vec4(a_vertex, 1.0) * u_matrix_vp;
+}

samples/sources/sample_03/sample_03.cpp

@@ -9,7 +9,12 @@ using namespace e2d;
 
 namespace
 {
+    struct rotator {
+        v3f axis;
+    };
+
     class game_system final : public ecs::system {
+    public:
         void process(ecs::registry& owner) override {
             E2D_UNUSED(owner);
             const keyboard& k = the<input>().keyboard();
@@ -22,10 +27,80 @@ namespace
         }
     };
 
+    class rotator_system final : public ecs::system {
+    public:
+        void process(ecs::registry& owner) override {
+            const f32 time = the<engine>().time();
+            owner.for_joined_components<rotator, actor>(
+                [&time](const ecs::const_entity&, const rotator& rot, actor& act){
+                    const node_iptr node = act.node();
+                    if ( node ) {
+                        const q4f q = math::make_quat_from_axis_angle(make_rad(time), rot.axis);
+                        node->rotation(q);
+                    }
+                });
+        }
+    };
+
     class game final : public high_application {
     public:
         bool initialize() final {
+            if ( !create_scene() || !create_camera() ) {
+                return false;
+            }
             the<world>().registry().add_system<game_system>();
+            the<world>().registry().add_system<rotator_system>();
+            return true;
+        }
+    private:
+        bool create_scene() {
+            auto model_res = the<library>().load_asset<model_asset>("gnome_model.json");
+            auto sprite_res = the<library>().load_asset<sprite_asset>("ship_sprite.json");
+            if ( !model_res || !sprite_res ) {
+                return false;
+            }
+
+            ecs::entity scene_e = the<world>().registry().create_entity();
+            scene_e.assign_component<scene>(node::create(the<world>()));
+            node_iptr scene_r = scene_e.get_component<scene>().root();
+
+            {
+                ecs::entity model_e = the<world>().registry().create_entity();
+                model_e.assign_component<rotator>(rotator{v3f::unit_y()});
+                model_e.assign_component<actor>(node::create(model_e));
+                model_e.assign_component<renderer>();
+                model_e.assign_component<model_renderer>(model_res);
+
+                node_iptr model_n = model_e.get_component<actor>().node();
+                model_n->scale(v3f{20.f});
+                model_n->translation(v3f{0.f,50.f,0.f});
+                scene_r->add_child(model_n);
+            }
+
+            {
+                ecs::entity sprite_e = the<world>().registry().create_entity();
+                sprite_e.assign_component<rotator>(rotator{v3f::unit_z()});
+                sprite_e.assign_component<actor>(node::create(sprite_e));
+                sprite_e.assign_component<renderer>();
+                sprite_e.assign_component<sprite_renderer>(sprite_res);
+
+                node_iptr sprite_n = sprite_e.get_component<actor>().node();
+                sprite_n->translation(v3f{0,-50.f,0});
+                scene_r->add_child(sprite_n);
+            }
+
+            return true;
+        }
+
+        bool create_camera() {
+            const auto camera_c = camera()
+                .background({1.f, 0.4f, 0.f, 1.f})
+                .viewport(the<window>().real_size())
+                .projection(math::make_orthogonal_lh_matrix4(
+                    the<window>().real_size().cast_to<f32>(), 0.f, 1000.f));
+            ecs::entity camera_e = the<world>().registry().create_entity();
+            camera_e.assign_component<camera>(camera_c);
+            camera_e.assign_component<actor>(node::create(camera_e));
             return true;
         }
     };
@@ -36,7 +111,7 @@ int e2d_main(int argc, char *argv[]) {
         engine::parameters("sample_03", "enduro2d")
             .timer_params(engine::timer_parameters()
                 .maximal_framerate(100)));
-    modules::initialize<starter>(
+    modules::initialize<starter>(argc, argv, starter_params).start<game>();
-        argc, argv, starter_params).start<game>();
+    modules::shutdown<starter>();
     return 0;
 }