feat: initial DX12 foundation framework

EngineTest/RenderItem.cpp

@@ -0,0 +1,141 @@
+/**
+ * @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