142 lines
3.5 KiB
C++
142 lines
3.5 KiB
C++
/**
|
|
* @file RenderItem.cpp
|
|
* @brief 渲染项创建与销毁测试逻辑。
|
|
*/
|
|
#include "CommonHeader.h"
|
|
#include <filesystem>
|
|
#include "Content/ContentToEngine.h"
|
|
#include "ShaderComponents.h"
|
|
#include "Components/Entity.h"
|
|
#include "Graphics_Beta/Renderer.h"
|
|
#include "../ContentTools/Geometry.h"
|
|
#include "Test.h"
|
|
#if TEST_RENDERER
|
|
using namespace XEngine;
|
|
bool read_file(std::filesystem::path, std::unique_ptr<u8[]>&, u64&);
|
|
|
|
namespace {
|
|
id::id_type model_id{ id::invalid_id };
|
|
id::id_type vs_id{ id::invalid_id };
|
|
id::id_type ps_id{ id::invalid_id };
|
|
id::id_type mtl_id{ id::invalid_id };
|
|
|
|
std::unordered_map<id::id_type, id::id_type> render_item_entity_map;
|
|
|
|
void
|
|
load_model()
|
|
{
|
|
std::unique_ptr<u8[]> model;
|
|
u64 size{ 0 };
|
|
read_file("..\\..\\enginetest\\model.model", model, size);
|
|
model_id = content::create_resource(model.get(), content::asset_type::mesh);
|
|
assert(id::is_valid(model_id));
|
|
}
|
|
|
|
void
|
|
load_shaders()
|
|
{
|
|
shader_file_info info{};
|
|
info.file_name = "TestShader.hlsl";
|
|
info.function = "TestShaderVS";
|
|
info.type = shader_type::vertex;
|
|
|
|
const char* shader_path{ "..\\..\\enginetest\\" };
|
|
|
|
std::wstring defines[]{ L"ELEMENTS_TYPE=1", L"ELEMENTS_TYPE=3" };
|
|
utl::vector<u32> keys;
|
|
keys.emplace_back(tools::elements::element_type::static_normal);
|
|
keys.emplace_back(tools::elements::element_type::static_normal_texture);
|
|
|
|
utl::vector<std::wstring> extra_args{};
|
|
utl::vector<std::unique_ptr<u8[]>> vertex_shaders;
|
|
utl::vector<u8*> vertex_shaders_pointers;
|
|
for (u32 i{ 0 }; i < _countof(defines); ++i)
|
|
{
|
|
extra_args.clear();
|
|
extra_args.emplace_back(L"-D");
|
|
extra_args.emplace_back(defines[i]);
|
|
vertex_shaders.emplace_back(std::move(compile_shader(info, shader_path, extra_args)));
|
|
assert(vertex_shaders.back().get());
|
|
vertex_shaders_pointers.emplace_back(vertex_shaders.back().get());
|
|
}
|
|
|
|
|
|
extra_args.clear();
|
|
info.function = "TestShaderPS";
|
|
info.type = shader_type::pixel;
|
|
|
|
auto pixel_shader = compile_shader(info, shader_path, extra_args);
|
|
assert(pixel_shader.get());
|
|
|
|
|
|
vs_id = content::add_shader_group(vertex_shaders_pointers.data(), (u32)vertex_shaders_pointers.size(), keys.data());
|
|
|
|
const u8* pixel_shaders[]{ pixel_shader.get() };
|
|
ps_id = content::add_shader_group(&pixel_shaders[0], 1, &u32_invalid_id);
|
|
|
|
}
|
|
|
|
void
|
|
create_material()
|
|
{
|
|
graphics::material_init_info info{};
|
|
info.shader_ids[graphics::shader_type::vertex] = vs_id;
|
|
info.shader_ids[graphics::shader_type::pixel] = ps_id;
|
|
info.type = graphics::material_type::opaque;
|
|
mtl_id = content::create_resource(&info, content::asset_type::material);
|
|
|
|
}
|
|
}//namespace
|
|
|
|
id::id_type
|
|
create_render_item(id::id_type entity_id)
|
|
{
|
|
auto _1 = std::thread{ [] {load_model(); } };
|
|
auto _2 = std::thread{ [] {load_shaders(); } };
|
|
|
|
_1.join();
|
|
_2.join();
|
|
|
|
create_material();
|
|
id::id_type materials[]{ mtl_id };
|
|
|
|
id::id_type item_id{ graphics::add_render_item(entity_id, model_id, _countof(materials), &materials[0]) };
|
|
|
|
render_item_entity_map[item_id] = entity_id;
|
|
|
|
return item_id;
|
|
}
|
|
|
|
void
|
|
destroy_render_item(id::id_type item_id)
|
|
{
|
|
if (id::is_valid(item_id))
|
|
{
|
|
graphics::remove_render_item(item_id);
|
|
auto pair = render_item_entity_map.find(item_id);
|
|
if (pair != render_item_entity_map.end())
|
|
{
|
|
game_entity::remove(game_entity::entity_id{ pair->second });
|
|
}
|
|
}
|
|
|
|
if (id::is_valid(mtl_id))
|
|
{
|
|
content::destroy_resource(mtl_id, content::asset_type::material);
|
|
}
|
|
|
|
if (id::is_valid(vs_id))
|
|
{
|
|
content::remove_shader_group(vs_id);
|
|
}
|
|
if (id::is_valid(ps_id))
|
|
{
|
|
content::remove_shader_group(ps_id);
|
|
}
|
|
if (id::is_valid(model_id))
|
|
{
|
|
content::destroy_resource(model_id, content::asset_type::mesh);
|
|
}
|
|
}
|
|
#endif
|