BlackMATov/enduro2d
1
0
Fork 0
mirror of https://github.com/enduro2d/enduro2d.git synced 2025-12-16 22:16:53 +07:00
Code Issues Packages Projects Releases Wiki Activity

initialization all modules in engine

Browse Source
This commit is contained in:
Matvey Cherevko
2018-11-08 00:13:34 +07:00
parent fcb6698658
commit 59bb164f4c
6 changed files with 711 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
samples/sources/sample_00/sample_00.cpp
View File

@@ -89,106 +89,116 @@ namespace
vertex2{color32::blue()},
vertex2{color32::yellow()}};
}
class game final : public application {
public:
bool initialize() final {
the<vfs>().register_scheme<archive_file_source>(
"piratepack",
the<vfs>().open(url("resources://bin/kenney_piratepack.zip")));
the<vfs>().register_scheme_alias(
"ships",
url("piratepack://PNG/Retina/Ships"));
shader_ = the<render>().create_shader(
vs_source_cstr, fs_source_cstr);
texture1_ = the<render>().create_texture(
the<vfs>().open(url("ships://ship (2).png")));
texture2_ = the<render>().create_texture(
the<vfs>().open(url("ships://ship (19).png")));
if ( !shader_ || !texture1_ || !texture2_ ) {
return false;
}
const auto indices = generate_quad_indices();
index_buffer_ = the<render>().create_index_buffer(
buffer(indices.data(), indices.size() * sizeof(indices[0])),
index_declaration::index_type::unsigned_byte,
index_buffer::usage::static_draw);
const auto vertices1 = generate_quad_vertices(texture1_->size());
vertex_buffer1_ = the<render>().create_vertex_buffer(
buffer(vertices1.data(), vertices1.size() * sizeof(vertices1[0])),
vertex1::decl(),
vertex_buffer::usage::static_draw);
const auto vertices2 = generate_quad_colors();
vertex_buffer2_ = the<render>().create_vertex_buffer(
buffer(vertices2.data(), vertices2.size() * sizeof(vertices2[0])),
vertex2::decl(),
vertex_buffer::usage::static_draw);
if ( !index_buffer_ || !vertex_buffer1_ || !vertex_buffer2_ ) {
return false;
}
material_ = render::material()
.add_pass(render::pass_state()
.states(render::state_block()
.capabilities(render::capabilities_state()
.blending(true))
.blending(render::blending_state()
.src_factor(render::blending_factor::src_alpha)
.dst_factor(render::blending_factor::one_minus_src_alpha)))
.shader(shader_)
.properties(render::property_block()
.sampler("u_texture1", render::sampler_state()
.texture(texture1_)
.min_filter(render::sampler_min_filter::linear)
.mag_filter(render::sampler_mag_filter::linear))
.sampler("u_texture2", render::sampler_state()
.texture(texture2_)
.min_filter(render::sampler_min_filter::linear)
.mag_filter(render::sampler_mag_filter::linear))));
geometry_ = render::geometry()
.indices(index_buffer_)
.add_vertices(vertex_buffer1_)
.add_vertices(vertex_buffer2_);
begin_game_time_ = time::now_ms();
return true;
}
bool frame_tick() final {
const keyboard& k = the<input>().keyboard();
if ( the<window>().should_close() || k.is_key_just_released(keyboard_key::escape) ) {
return false;
}
const auto game_time = (time::now_ms() - begin_game_time_).cast_to<f32>().value;
const auto framebuffer_size = the<window>().real_size().cast_to<f32>();
const auto projection = math::make_orthogonal_lh_matrix4(framebuffer_size, 0.f, 1.f);
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::swap_command(true)));
return true;
}
private:
shader_ptr shader_;
texture_ptr texture1_;
texture_ptr texture2_;
index_buffer_ptr index_buffer_;
vertex_buffer_ptr vertex_buffer1_;
vertex_buffer_ptr vertex_buffer2_;
render::material material_;
render::geometry geometry_;
milliseconds<i64> begin_game_time_;
};
}
int e2d_main() {
{
modules::initialize<vfs>()
.register_scheme<filesystem_file_source>("file");
modules::initialize<debug>()
.register_sink<debug_console_sink>();
modules::initialize<input>();
modules::initialize<window>(v2u{640, 480}, "Enduro2D", false)
.register_event_listener<window_input_source>(the<input>());
modules::initialize<render>(the<debug>(), the<window>());
}
{
str resources;
filesystem::extract_predef_path(resources, filesystem::predef_path::resources);
the<vfs>().register_scheme_alias(
"resources",
url{"file", resources});
the<vfs>().register_scheme<archive_file_source>(
"piratepack",
the<vfs>().open(url("resources://bin/kenney_piratepack.zip")));
the<vfs>().register_scheme_alias("ships", url("piratepack://PNG/Retina/Ships"));
}
auto texture1 = the<render>().create_texture(
the<vfs>().open(url("ships://ship (2).png")));
auto texture2 = the<render>().create_texture(
the<vfs>().open(url("ships://ship (19).png")));
const auto shader = the<render>().create_shader(
vs_source_cstr, fs_source_cstr);
const auto indices = generate_quad_indices();
const auto index_buffer = the<render>().create_index_buffer(
buffer(indices.data(), indices.size() * sizeof(indices[0])),
index_declaration::index_type::unsigned_byte,
index_buffer::usage::static_draw);
const auto vertices1 = generate_quad_vertices(texture1->size());
const auto vertex_buffer1 = the<render>().create_vertex_buffer(
buffer(vertices1.data(), vertices1.size() * sizeof(vertices1[0])),
vertex1::decl(),
vertex_buffer::usage::static_draw);
const auto vertices2 = generate_quad_colors();
const auto vertex_buffer2 = the<render>().create_vertex_buffer(
buffer(vertices2.data(), vertices2.size() * sizeof(vertices2[0])),
vertex2::decl(),
vertex_buffer::usage::static_draw);
if ( !texture1 || !texture2 || !shader || !index_buffer || !vertex_buffer1 || !vertex_buffer2 ) {
return 1;
}
auto material = render::material()
.add_pass(render::pass_state()
.states(render::state_block()
.capabilities(render::capabilities_state()
.blending(true))
.blending(render::blending_state()
.src_factor(render::blending_factor::src_alpha)
.dst_factor(render::blending_factor::one_minus_src_alpha)))
.shader(shader)
.properties(render::property_block()
.sampler("u_texture1", render::sampler_state()
.texture(texture1)
.min_filter(render::sampler_min_filter::linear)
.mag_filter(render::sampler_mag_filter::linear))
.sampler("u_texture2", render::sampler_state()
.texture(texture2)
.min_filter(render::sampler_min_filter::linear)
.mag_filter(render::sampler_mag_filter::linear))));
auto geometry = render::geometry()
.indices(index_buffer)
.add_vertices(vertex_buffer1)
.add_vertices(vertex_buffer2);
const auto begin_game_time = time::now_ms();
const auto framebuffer_size = the<window>().real_size().cast_to<f32>();
const auto projection = math::make_orthogonal_lh_matrix4(framebuffer_size, 0.f, 1.f);
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;
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::swap_command(true)));
the<input>().frame_tick();
window::poll_events();
}
auto params = engine::parameters("sample_00", "enduro2d");
modules::initialize<engine>(params).start<game>();
return 0;
}