MadeOfJelly/MushMachine
2
2
Fork 0
mirror of https://github.com/MadeOfJelly/MushMachine.git synced 2025-06-18 18:56:36 +02:00
Code Issues Projects Releases Wiki Activity

remove old transform and velocity components and replace with new decomposed components

Browse Source 
focus on 2D for now
This commit is contained in:
Green Sky
2022-01-04 22:33:59 +01:00
parent c36fa30cbc
commit 12b0a90ad0
71 changed files with 1114 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
framework/opengl_renderer/src/mm/opengl/render_tasks/batched_spritesheet.cpp
View File

@ -1,7 +1,5 @@
#include "./batched_spritesheet.hpp"
#include <memory>
#include <mm/opengl/shader.hpp>
#include <mm/opengl/buffer.hpp>
#include <mm/opengl/vertex_array_object.hpp>
@ -13,11 +11,9 @@
#include <mm/services/scene_service_interface.hpp>
#include <entt/entity/registry.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include "./spritesheet_renderable.hpp"
#include <mm/services/opengl_renderer.hpp>
#include <tracy/Tracy.hpp>
#ifndef MM_OPENGL_3_GLES
@ -67,18 +63,17 @@ BatchedSpriteSheet::~BatchedSpriteSheet(void) {
void BatchedSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
ZoneScopedN("MM::OpenGL::RenderTasks::BatchedSpriteSheet::render");
auto* scene_ss = engine.tryService<MM::Services::SceneServiceInterface>();
// no scene
if (scene_ss == nullptr) {
return;
auto* ssi = engine.tryService<MM::Services::SceneServiceInterface>();
if (ssi == nullptr) {
return; // nothing to draw
}
auto& scene = scene_ss->getScene();
auto& scene = ssi->getScene();
struct sp_data {
SpriteSheet sp;
struct instance_data {
MM::Components::Transform2D* trans = nullptr;
const MM::Components::Transform4x4* trans = nullptr;
glm::vec4* color = nullptr;
uint32_t tile_index = 0;
};
@ -87,13 +82,11 @@ void BatchedSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
// HACK: assume same sp for same texture
std::unordered_map<MM::OpenGL::Texture::handle_t, sp_data> batch_map;
auto view = scene.view<Components::Transform2D, SpriteSheetRenderable>();
view.each([&](auto e, Components::Transform2D& t, SpriteSheetRenderable& spr) {
// if off screen, early out
if (false) { // TODO:
return;
}
scene.view<const Components::Transform4x4, SpriteSheetRenderable>().each([this, &scene, &batch_map](entt::entity e, const auto& t, auto& spr) {
//// if off screen, early out
//if (false) { // TODO:
//return;
//}
assert(spr.sp.tex); // debug
@ -139,7 +132,8 @@ void BatchedSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
auto* inst_memory = gl_inst_buffer->map(sp_ent.second.instances.size(), GL_DYNAMIC_DRAW);
for (auto& inst : sp_ent.second.instances) {
inst_memory->pos_trans = inst.trans->getTransform4(inst.trans->position.y/10.f + 500.f);
//inst_memory->pos_trans = inst.trans->getTransform4(inst.trans->position.y/10.f + 500.f);
inst_memory->pos_trans = inst.trans->trans; // TODO: this is ugly
inst_memory->color = *inst.color;
inst_memory->tile_index = inst.tile_index;
@ -149,6 +143,8 @@ void BatchedSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
static_assert(std::is_standard_layout<gl_instance_data>::value); // check if offsetof() is usable
// TODO: optimize, dont call attrib pointer each draw
// mat4, oof
// attptr 1-4
for (size_t i = 0; i < 4; i++) {

24
framework/opengl_renderer/src/mm/opengl/render_tasks/simple_rect.cpp
View File

@ -11,7 +11,7 @@
#include <mm/services/scene_service_interface.hpp>
#include <entt/entity/registry.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include <tracy/Tracy.hpp>
@ -56,6 +56,13 @@ SimpleRect::~SimpleRect(void) {
void SimpleRect::render(Services::OpenGLRenderer& rs, Engine& engine) {
ZoneScopedN("MM::OpenGL::RenderTasks::SimpleRect::render");
auto* ssi = engine.tryService<MM::Services::SceneServiceInterface>();
if (ssi == nullptr) {
return; // nothing to draw
}
auto& scene = ssi->getScene();
rs.targets[target_fbo]->bind(FrameBufferObject::RW);
glEnable(GL_DEPTH_TEST);
@ -64,8 +71,6 @@ void SimpleRect::render(Services::OpenGLRenderer& rs, Engine& engine) {
_shader->bind();
_vao->bind();
auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
Camera3D* cam = scene.try_ctx<Camera3D>();
if (!cam) {
cam = &default_cam;
@ -73,12 +78,8 @@ void SimpleRect::render(Services::OpenGLRenderer& rs, Engine& engine) {
auto vp = cam->getViewProjection();
auto view = scene.view<MM::Components::Transform2D>();
for (auto& e : view) {
auto& t = view.get<Components::Transform2D>(e);
_shader->setUniformMat4f("_WVP", vp * t.getTransform4(t.position.y/10.f + 500.f));
scene.view<const Components::Transform4x4>().each([this, &scene, &vp](entt::entity e, const auto& t) {
_shader->setUniformMat4f("_WVP", vp * t.trans);
if (scene.all_of<Components::Color>(e)) {
_shader->setUniform4f("_color", scene.get<Components::Color>(e).color);
@ -86,9 +87,8 @@ void SimpleRect::render(Services::OpenGLRenderer& rs, Engine& engine) {
_shader->setUniform4f("_color", default_color);
}
glDrawArrays(GL_TRIANGLES, 0, 6);
}
});
_vao->unbind();
_shader->unbind();
@ -106,7 +106,7 @@ in vec2 _vertexPosition;
uniform mat4 _WVP;
void main() {
gl_Position = _WVP * vec4(_vertexPosition, 0, 1);
gl_Position = _WVP * vec4(_vertexPosition, 0.0, 1.0);
})")
FS_CONST_MOUNT_FILE(fragmentPath,

17
framework/opengl_renderer/src/mm/opengl/render_tasks/simple_sprite.cpp
View File

@ -11,7 +11,7 @@
#include <mm/services/scene_service_interface.hpp>
#include <entt/entity/registry.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/opengl/components/texture.hpp>
#include <mm/components/color.hpp>
@ -62,6 +62,13 @@ SimpleSprite::~SimpleSprite(void) {
void SimpleSprite::render(Services::OpenGLRenderer& rs, Engine& engine) {
ZoneScopedN("MM::OpenGL::RenderTasks::SimpleSprite::render");
auto* ssi = engine.tryService<MM::Services::SceneServiceInterface>();
if (ssi == nullptr) {
return; // nothing to draw
}
auto& scene = ssi->getScene();
rs.targets[target_fbo]->bind(FrameBufferObject::W);
glEnable(GL_DEPTH_TEST);
@ -72,8 +79,6 @@ void SimpleSprite::render(Services::OpenGLRenderer& rs, Engine& engine) {
_vao->bind();
auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
auto* cam = scene.try_ctx<Camera3D>();
if (!cam) {
cam = &default_cam;
@ -81,14 +86,12 @@ void SimpleSprite::render(Services::OpenGLRenderer& rs, Engine& engine) {
auto vp = cam->getViewProjection();
auto view = scene.view<Components::Transform2D, Components::OpenGL::Texture>();
view.each([&](auto e, Components::Transform2D& t, Components::OpenGL::Texture& tex) {
scene.view<const Components::Transform4x4, Components::OpenGL::Texture>().each([this, &scene, &vp](entt::entity e, const auto& t, auto& tex) {
assert(tex.tex); // debug
tex.tex->bind(0);
_shader->setUniformMat4f("_WVP", vp * t.getTransform4(t.position.y/10.f + 500.f));
_shader->setUniformMat4f("_WVP", vp * t.trans);
if (scene.all_of<Components::Color>(e)) {
_shader->setUniform4f("_color", scene.get<Components::Color>(e).color);

18
framework/opengl_renderer/src/mm/opengl/render_tasks/simple_spritesheet.cpp
View File

@ -11,7 +11,7 @@
#include <mm/services/scene_service_interface.hpp>
#include <entt/entity/registry.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include "./spritesheet_renderable.hpp"
@ -69,6 +69,13 @@ SimpleSpriteSheet::~SimpleSpriteSheet(void) {
void SimpleSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
ZoneScopedN("MM::OpenGL::RenderTasks::SimpleSpriteSheet::render");
auto* ssi = engine.tryService<MM::Services::SceneServiceInterface>();
if (ssi == nullptr) {
return; // nothing to draw
}
auto& scene = ssi->getScene();
rs.targets[target_fbo]->bind(FrameBufferObject::W);
glEnable(GL_DEPTH_TEST);
@ -78,9 +85,6 @@ void SimpleSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
_vertexBuffer->bind(GL_ARRAY_BUFFER);
_vao->bind();
auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();
auto* cam = scene.try_ctx<Camera3D>();
if (!cam) {
cam = &default_cam;
@ -88,16 +92,14 @@ void SimpleSpriteSheet::render(Services::OpenGLRenderer& rs, Engine& engine) {
auto vp = cam->getViewProjection();
auto view = scene.view<Components::Transform2D, SpriteSheetRenderable>();
view.each([&](auto e, Components::Transform2D& t, SpriteSheetRenderable& spr) {
scene.view<const Components::Transform4x4, SpriteSheetRenderable>().each([this, &scene, &vp](entt::entity e, const auto& t, auto& spr) {
assert(spr.sp.tex); // debug
TracyGpuZone("MM::OpenGL::Renderers::SimpleSpriteSheetRenderer::render.each");
spr.sp.tex->bind(0);
_shader->setUniformMat4f("_WVP", vp * t.getTransform4(t.position.y/10.f + 500.f));
_shader->setUniformMat4f("_WVP", vp * t.trans);
_shader->setUniform2ui("_tileCount", spr.sp.tile_count.x, spr.sp.tile_count.y);
_shader->setUniform1ui("_atlasIndex", spr.tile_index);

2
framework/opengl_renderer/src/mm/opengl/render_tasks/spritesheet_renderable.hpp
View File

@ -1,3 +1,5 @@
#pragma once
#include <mm/opengl/spritesheet.hpp>
namespace MM::OpenGL {

9
framework/opengl_renderer/src/mm/opengl/render_tasks/tilemap.cpp
View File

@ -11,7 +11,7 @@
#include <mm/services/scene_service_interface.hpp>
#include <entt/entity/registry.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/opengl/components/texture.hpp>
#include <mm/components/color.hpp>
@ -87,9 +87,10 @@ void Tilemap::render(MM::Services::OpenGLRenderer& rs, MM::Engine& engine) {
_shader->setUniform3f("_ambient_color", ambient_color);
auto view = scene.view<MM::Components::Transform2D, OpenGL::TilemapRenderable>();
view.each([&](auto, MM::Components::Transform2D& t, OpenGL::TilemapRenderable& tilemap) {
_shader->setUniformMat4f("_WVP", vp * t.getTransform4(tilemap.z + 500.f));
scene.view<MM::Components::Transform4x4, OpenGL::TilemapRenderable>()
.each([&](auto, MM::Components::Transform4x4& t, OpenGL::TilemapRenderable& tilemap) {
//_shader->setUniformMat4f("_WVP", vp * t.getTransform4(tilemap.z + 500.f));
_shader->setUniformMat4f("_WVP", vp * t.trans);
// for each sprite layer
for (auto& sp_layer : tilemap.sprite_layer) {

2
framework/opengl_renderer/src/mm/opengl/render_tasks/tilemap_renderable.hpp
View File

@ -42,7 +42,7 @@ struct TilemapRenderable {
};
std::vector<SpriteLayer> sprite_layer;
float z = 0.f;
//float z = 0.f; // TODO: use Components::Position2D_ZOffset instead
};
} // MM::OpenGL

9
framework/opengl_renderer/test/CMakeLists.txt
View File

@ -30,6 +30,7 @@ target_link_libraries(simple_rect_render_task_test
simple_rect_render_task
simple_velocity_system
transform_system
random
@ -48,6 +49,9 @@ target_link_libraries(simple_sprite_render_task_test
simple_sprite_render_task
simple_velocity_system
transform_system
random
gtest_main
)
@ -64,6 +68,7 @@ target_link_libraries(simple_spritesheet_render_task_test
simple_spritesheet_render_task
#simple_velocity_system
transform_system
gtest_main
)
@ -80,6 +85,7 @@ target_link_libraries(batched_spritesheet_render_task_test
batched_spritesheet_render_task
#simple_velocity_system
transform_system
gtest_main
)
@ -101,6 +107,7 @@ target_link_libraries(blur_render_task_test
imgui_render_task
simple_velocity_system
transform_system
random
@ -119,6 +126,8 @@ target_link_libraries(tilemap_render_task_test
imgui_service
tilemap_render_task
transform_system
gtest_main
)

47
framework/opengl_renderer/test/batched_spritesheet_render_task_test.cpp
View File

@ -14,11 +14,17 @@
#include <mm/opengl/render_tasks/batched_spritesheet.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/scale2d.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include <mm/components/time_delta.hpp>
#include <mm/opengl/render_tasks/spritesheet_renderable.hpp>
#include <mm/systems/transform.hpp>
#include <physfs.h>
#include "res/textures.zip.h"
@ -69,10 +75,27 @@ TEST(batched_spritesheet_render_task, it) {
rs.addRenderTask<MM::OpenGL::RenderTasks::BatchedSpriteSheet>(engine);
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Scale2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
// setup systems
scene.set<float>(0.f); // accu
auto& org = scene.set<entt::organizer>();
org.emplace<&update_spritesheet_animation>("update_spritesheet_animation");
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform3d_rotate2d>("transform3d_rotate2d");
org.emplace<MM::Systems::transform3d_scale2d>("transform3d_scale2d");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
@ -83,10 +106,13 @@ TEST(batched_spritesheet_render_task, it) {
{
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = -1.f;
t.scale.x = 1.5f;
t.scale.y = 2.f;
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = -1.f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {1.5f,2.f};
auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
spr.sp.tex = rm_t.get("anim_run"_hs);
@ -97,10 +123,13 @@ TEST(batched_spritesheet_render_task, it) {
{
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = 1.f;
t.scale.x = 1.5f;
t.scale.y = 2.f;
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = 1.f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {1.5f,2.f};
auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
spr.sp.tex = rm_t.get("anim_idle"_hs);

44
framework/opengl_renderer/test/blur_render_task_test.cpp
View File

@ -17,10 +17,17 @@
#include <mm/opengl/render_tasks/blur.hpp>
#include <mm/opengl/render_tasks/imgui.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/scale2d.hpp>
#include <mm/components/rotation2d.hpp>
#include <mm/components/velocity2d_rotation.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include <mm/systems/simple_velocity_system2d.hpp>
#include <mm/systems/transform.hpp>
#include <mm/opengl/fbo_builder.hpp>
#include <mm/opengl/texture_loader.hpp>
@ -110,10 +117,27 @@ TEST(blur_render_task, it) {
.finish();
}
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Scale2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Rotation2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>(); // in this example only rotation is touched
// setup v system
auto& org = scene.set<entt::organizer>();
org.emplace<&MM::Systems::simple_velocity>("simple_velocity");
org.emplace<MM::Systems::simple_rotational_velocity_patching>("simple_rotational_velocity_patching");
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform3d_rotate2d>("transform3d_rotate2d");
org.emplace<MM::Systems::transform3d_scale2d>("transform3d_scale2d");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
@ -122,12 +146,18 @@ TEST(blur_render_task, it) {
for (int i = 0; i < 10; i++) {
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = float(i) * 9.f - 40.f;
t.scale = {5,5};
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = i * 9.f - 40;
auto& v = scene.emplace<MM::Components::Velocity2D>(e);
v.rotation = float(i) * 0.3f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {5,5};
scene.emplace<MM::Components::Rotation2D>(e);
auto& v = scene.emplace<MM::Components::Velocity2DRotation>(e);
v.rot_vel = i * 0.3f;
if (rng.roll(0.5f)) {
auto& col = scene.emplace<MM::Components::Color>(e);

45
framework/opengl_renderer/test/simple_rect_render_task_test.cpp
View File

@ -12,10 +12,17 @@
#include <mm/opengl/render_tasks/simple_rect.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/scale2d.hpp>
#include <mm/components/rotation2d.hpp>
#include <mm/components/velocity2d_rotation.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include <mm/systems/simple_velocity_system2d.hpp>
#include <mm/systems/transform.hpp>
#include <mm/random/srng.hpp>
@ -44,9 +51,25 @@ TEST(simple_rect_render_task, it) {
rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleRect>(engine);
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Scale2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Rotation2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>(); // in this example only rotation is touched
// setup v system
auto& org = scene.set<entt::organizer>();
org.emplace<&MM::Systems::simple_velocity>("simple_velocity");
org.emplace<MM::Systems::simple_rotational_velocity_patching>("simple_rotational_velocity_patching");
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform3d_rotate2d>("transform3d_rotate2d");
org.emplace<MM::Systems::transform3d_scale2d>("transform3d_scale2d");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
@ -56,13 +79,19 @@ TEST(simple_rect_render_task, it) {
for (int y = 0; y < 10; y++) {
for (int i = 0; i < 10; i++) {
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = i * 9.f - 40;
t.position.y = -y * 6.f + 25;
t.scale = {5,5};
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = i * 9.f - 40;
p.pos.y = -y * 6.f + 25;
auto& v = scene.emplace<MM::Components::Velocity2D>(e);
v.rotation = i * 0.3f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {5,5};
scene.emplace<MM::Components::Rotation2D>(e);
auto& v = scene.emplace<MM::Components::Velocity2DRotation>(e);
v.rot_vel = i * 0.3f;
if (rng.roll(0.5f)) {
auto& col = scene.emplace<MM::Components::Color>(e);

58
framework/opengl_renderer/test/simple_sprite_render_task_test.cpp
View File

@ -12,13 +12,20 @@
#include <mm/opengl/render_tasks/simple_sprite.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/scale2d.hpp>
#include <mm/components/rotation2d.hpp>
#include <mm/components/velocity2d_rotation.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/opengl/components/texture.hpp>
#include <mm/components/color.hpp>
#include <mm/systems/simple_velocity_system2d.hpp>
#include <mm/systems/transform.hpp>
#include <random>
#include <mm/random/srng.hpp>
using namespace entt::literals;
@ -47,37 +54,58 @@ TEST(simple_sprite_render_task, it) {
rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleSprite>(engine);
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Scale2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Rotation2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>(); // in this example only rotation is touched
// setup v system
auto& org = scene.set<entt::organizer>();
org.emplace<&MM::Systems::simple_velocity>("simple_velocity");
org.emplace<MM::Systems::simple_rotational_velocity_patching>("simple_rotational_velocity_patching");
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform3d_rotate2d>("transform3d_rotate2d");
org.emplace<MM::Systems::transform3d_scale2d>("transform3d_scale2d");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
std::mt19937 mt(42);
MM::Random::SRNG rng{42};
for (int y = 0; y < 10; y++) {
for (int i = 0; i < 10; i++) {
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = i * 9.f - 40;
t.position.y = -y * 6.f + 25;
t.scale = {5,5};
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = i * 9.f - 40;
p.pos.y = -y * 6.f + 25;
auto& v = scene.emplace<MM::Components::Velocity2D>(e);
v.rotation = i * 0.3f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {5,5};
scene.emplace<MM::Components::Rotation2D>(e);
auto& v = scene.emplace<MM::Components::Velocity2DRotation>(e);
v.rot_vel = i * 0.3f;
auto& tex = scene.emplace<MM::Components::OpenGL::Texture>(e);
tex.tex = rm_t.get("errig"_hs);
if (mt() % 2) {
if (rng.roll(0.5f)) {
auto& col = scene.emplace<MM::Components::Color>(e);
auto rc = [&mt]() -> float {
return (mt() % 1001) / 1000.f ;
};
col.color = {rc(),rc(),rc(),1};
col.color = {rng.zeroToOne(), rng.zeroToOne(), rng.zeroToOne(), 1.f};
}
}
}

46
framework/opengl_renderer/test/simple_spritesheet_render_task_test.cpp
View File

@ -14,11 +14,17 @@
#include <mm/opengl/render_tasks/simple_spritesheet.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/scale2d.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/components/color.hpp>
#include <mm/components/time_delta.hpp>
#include <mm/opengl/render_tasks/spritesheet_renderable.hpp>
#include <mm/systems/transform.hpp>
#include <physfs.h>
#include "res/textures.zip.h"
@ -65,10 +71,26 @@ TEST(simple_spritesheet_render_task, it) {
rs.addRenderTask<MM::OpenGL::RenderTasks::SimpleSpriteSheet>(engine);
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Scale2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
// setup systems
scene.set<float>(0.f); // accu
auto& org = scene.set<entt::organizer>();
org.emplace<&update_spritesheet_animation>("update_spritesheet_animation");
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform3d_rotate2d>("transform3d_rotate2d");
org.emplace<MM::Systems::transform3d_scale2d>("transform3d_scale2d");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
@ -79,10 +101,13 @@ TEST(simple_spritesheet_render_task, it) {
{
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = -1.f;
t.scale.x = 1.5f;
t.scale.y = 2.f;
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = -1.f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {1.5f,2.f};
auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
spr.sp.tex = rm_t.get("anim_run"_hs);
@ -93,10 +118,13 @@ TEST(simple_spritesheet_render_task, it) {
{
auto e = scene.create();
auto& t = scene.emplace<MM::Components::Transform2D>(e);
t.position.x = 1.f;
t.scale.x = 1.5f;
t.scale.y = 2.f;
auto& p = scene.emplace<MM::Components::Position2D>(e);
p.pos.x = 1.f;
// zoffset is created by event
auto& s = scene.emplace<MM::Components::Scale2D>(e);
s.scale = {1.5f,2.f};
auto& spr = scene.emplace<MM::OpenGL::SpriteSheetRenderable>(e);
spr.sp.tex = rm_t.get("anim_idle"_hs);

28
framework/opengl_renderer/test/tilemap_render_task_test.cpp
View File

@ -8,13 +8,18 @@
#include <mm/services/opengl_renderer.hpp>
#include <entt/entity/registry.hpp>
#include <entt/entity/organizer.hpp>
#include <mm/opengl/camera_3d.hpp>
#include <mm/opengl/render_tasks/tilemap.hpp>
#include <mm/opengl/render_tasks/tilemap_renderable.hpp>
#include <mm/components/transform2d.hpp>
#include <mm/components/position2d.hpp>
#include <mm/components/position2d_zoffset.hpp>
#include <mm/components/position3d.hpp>
#include <mm/components/transform4x4.hpp>
#include <mm/systems/transform.hpp>
#include <mm/opengl/texture_loader.hpp>
using namespace entt::literals;
@ -48,11 +53,30 @@ TEST(tilemap_render_task_test, it) {
rs.addRenderTask<MM::OpenGL::RenderTasks::Tilemap>(engine);
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position2D_ZOffset>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Position3D>>();
scene.on_construct<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::Transform4x4>>();
scene.on_construct<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>(); // fun
// "useless" in this example
scene.on_update<MM::Components::Position2D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position2D_ZOffset>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
scene.on_update<MM::Components::Position3D>().connect<&entt::registry::emplace_or_replace<MM::Components::DirtyTransformTag>>();
auto& org = scene.set<entt::organizer>();
org.emplace<MM::Systems::position3d_from_2d>("position3d_from_2d");
org.emplace<MM::Systems::transform3d_translate>("transform3d_translate");
org.emplace<MM::Systems::transform_clear_dirty>("transform_clear_dirty");
// HACK: instead you would switch to this scene
engine.getService<MM::Services::OrganizerSceneService>().updateOrganizerVertices(scene);
auto& rm_t = MM::ResourceManager<MM::OpenGL::Texture>::ref();
{
auto e = scene.create();
scene.emplace<MM::Components::Transform2D>(e);
scene.emplace<MM::Components::Position2D>(e);
auto& tm = scene.emplace<MM::OpenGL::TilemapRenderable>(e);