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

cube sample

Browse Source
This commit is contained in:
Matvey Cherevko
2018-10-16 03:04:32 +07:00
parent 20551c736f
commit 2fb8453473
2 changed files with 241 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -173,9 +173,10 @@ int e2d_main() {
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", (time::now_ms() - begin_game_time).cast_to<f32>().value)
.property("u_time", game_time)
.property("u_MVP", projection);
the<render>()

247
samples/sources/sample_01/sample_01.cpp
View File

@@ -7,25 +7,254 @@
#include "../common.hpp"
using namespace e2d;
namespace
{
const char* vs_source_cstr =
"#version 120 \n"
" \n"
"attribute vec3 a_position; \n"
"attribute vec2 a_uv; \n"
"attribute vec4 a_color; \n"
" \n"
"uniform mat4 u_MVP; \n"
" \n"
"varying vec4 v_color; \n"
"varying vec2 v_uv; \n"
" \n"
"void main(){ \n"
" v_color = a_color; \n"
" v_uv = a_uv; \n"
" \n"
" gl_Position = vec4(a_position, 1.0) * u_MVP; \n"
"} \n";
const char* fs_source_cstr =
"#version 120 \n"
" \n"
"uniform sampler2D u_texture; \n"
"varying vec4 v_color; \n"
"varying vec2 v_uv; \n"
" \n"
"void main(){ \n"
" vec2 uv = vec2(v_uv.s, 1.0 - v_uv.t); \n"
" gl_FragColor = v_color * texture2D(u_texture, uv); \n"
"} \n";
struct vertex1 {
v3f position;
v2hu uv;
static vertex_declaration decl() noexcept {
return vertex_declaration()
.add_attribute<v3f>("a_position")
.add_attribute<v2hu>("a_uv");
}
};
struct vertex2 {
color32 color;
static vertex_declaration decl() noexcept {
return vertex_declaration()
.add_attribute<color32>("a_color").normalized();
}
};
array<u8,36> generate_cube_indices() noexcept {
return {
0, 1, 2,
2, 3, 0,
4, 5, 6,
6, 7, 4,
8, 9, 10,
10, 11, 8,
12, 13, 14,
14, 15, 12,
16, 17, 18,
18, 19, 16,
20, 21, 22,
22, 23, 20};
}
array<vertex1,24> generate_cube_vertices(const v3f& size) noexcept {
f32 x = size.x * 0.5f;
f32 y = size.y * 0.5f;
f32 z = size.z * 0.5f;
return {
vertex1{{-x, -y, -z}, {0, 1}},
vertex1{{ x, -y, -z}, {1, 1}},
vertex1{{ x, y, -z}, {1, 0}},
vertex1{{-x, y, -z}, {0, 0}},
vertex1{{-x, -y, z}, {0, 1}},
vertex1{{ x, -y, z}, {1, 1}},
vertex1{{ x, -y, -z}, {1, 0}},
vertex1{{-x, -y, -z}, {0, 0}},
vertex1{{ x, -y, z}, {0, 1}},
vertex1{{-x, -y, z}, {1, 1}},
vertex1{{-x, y, z}, {1, 0}},
vertex1{{ x, y, z}, {0, 0}},
vertex1{{-x, y, -z}, {0, 1}},
vertex1{{ x, y, -z}, {1, 1}},
vertex1{{ x, y, z}, {1, 0}},
vertex1{{-x, y, z}, {0, 0}},
vertex1{{ x, -y, -z}, {0, 1}},
vertex1{{ x, -y, z}, {1, 1}},
vertex1{{ x, y, z}, {1, 0}},
vertex1{{ x, y, -z}, {0, 0}},
vertex1{{-x, -y, z}, {0, 1}},
vertex1{{-x, -y, -z}, {1, 1}},
vertex1{{-x, y, -z}, {1, 0}},
vertex1{{-x, y, z}, {0, 0}}};
}
array<vertex2,24> generate_cube_colors() noexcept {
return {
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()},
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()},
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()},
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()},
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()},
vertex2{color32::red()},
vertex2{color32::green()},
vertex2{color32::blue()},
vertex2{color32::yellow()}};
}
}
int e2d_main() {
modules::initialize<debug>();
{
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);
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"));
}
the<debug>().register_sink<debug_console_sink>();
the<window>().register_event_listener<window_input_source>(the<input>());
the<window>().register_event_listener<window_trace_event_listener>(the<debug>());
auto texture = the<render>().create_texture(
the<vfs>().open(url("ships://ship (3).png")));
the<debug>()
.trace("SAMPLE: window real size: %0", the<window>().real_size())
.trace("SAMPLE: window virtual size: %0", the<window>().virtual_size())
.trace("SAMPLE: window framebuffer size: %0", the<window>().framebuffer_size());
const auto shader = the<render>().create_shader(
make_memory_stream(buffer(vs_source_cstr, std::strlen(vs_source_cstr))),
make_memory_stream(buffer(fs_source_cstr, std::strlen(fs_source_cstr))));
const auto indices = generate_cube_indices();
const auto index_buffer = the<render>().create_index_buffer(
buffer(indices.data(), indices.size() * sizeof(indices[0])),
index_declaration(index_declaration::index_type::unsigned_byte),
index_buffer::usage::static_draw);
const auto vertices1 = generate_cube_vertices(make_vec3(1.f));
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_cube_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 ( !texture || !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()
.culling(true)
.depth_test(true))
.culling(render::culling_state()
.mode(render::culling_mode::ccw)
.face(render::culling_face::back)))
.shader(shader)
.properties(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))));
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_perspective_lh_matrix4(
make_deg(45.f),
framebuffer_size.x / framebuffer_size.y,
0.1f,
100.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;
const auto MVP =
math::make_rotation_matrix4(make_rad(game_time) * 0.001f, 1.f, 0.f, 0.f) *
math::make_rotation_matrix4(make_rad(game_time) * 0.001f, 0.f, 1.f, 0.f) *
math::make_rotation_matrix4(make_rad(game_time) * 0.001f, 0.f, 0.f, 1.f) *
math::make_translation_matrix4(0.f,0.f,3.f) *
projection;
material.properties()
.property("u_time", game_time)
.property("u_MVP", MVP);
the<render>()
.clear_depth_buffer(1.f)
.clear_stencil_buffer(0)
.clear_color_buffer({1.f, 0.4f, 0.f, 1.f})
.draw(material, geometry);
the<window>().swap_buffers(true);
the<input>().frame_tick();
window::poll_events();
}
return 0;
}