529 lines
14 KiB
C++
529 lines
14 KiB
C++
/**
|
||
* @file ContentToEngine.cpp
|
||
* @brief 内容二进制数据到渲染/资源句柄的转换实现。
|
||
* @details
|
||
* 本文件完成导入数据的运行时落地，包含：
|
||
* - 网格层级(LOD)结构重排与子网格 GPU 资源创建；
|
||
* - 着色器分组缓存与 key 索引查询；
|
||
* - 材质/纹理/几何资源的统一创建与释放入口。
|
||
*/
|
||
#include "ContentToEngine.h"
|
||
#include "Graphics\Renderer.h"
|
||
#include "Utilities\IOStream.h"
|
||
|
||
namespace XEngine::content {
|
||
namespace {
|
||
|
||
/**
|
||
* @brief 几何层级缓冲区的视图封装。
|
||
* @details
|
||
* 对连续内存中的几何层级布局进行字段映射，提供阈值、LOD 偏移与 GPU ID 访问。
|
||
*/
|
||
class geometry_hierarchy_stream
|
||
{
|
||
public:
|
||
DISABLE_COPY_AND_MOVE(geometry_hierarchy_stream);
|
||
|
||
geometry_hierarchy_stream(u8 *const buffer, u32 lods = u32_invalid_id)
|
||
:_buffer{ buffer }
|
||
{
|
||
assert(buffer && lods);
|
||
if (lods != u32_invalid_id)
|
||
{
|
||
*((u32*)buffer) = lods;
|
||
}
|
||
|
||
_lod_count = *((u32*)buffer);
|
||
_thresholds = (f32*)(&buffer[sizeof(u32)]);
|
||
_lod_offsets = (lod_offset*)(&_thresholds[_lod_count]);
|
||
_gpu_ids = (id::id_type*)(&_lod_offsets[_lod_count]);
|
||
}
|
||
|
||
void gpu_ids(u32 lod, id::id_type*& ids, u32& id_count)
|
||
{
|
||
assert(lod < _lod_count);
|
||
ids = &_gpu_ids[_lod_offsets[lod].offset];
|
||
id_count = _lod_offsets[lod].count;
|
||
}
|
||
|
||
u32 lod_from_threshold(f32 threshold)
|
||
{
|
||
assert(threshold > 0);
|
||
if (_lod_count == 1) return 0;
|
||
|
||
for (u32 i{ _lod_count - 1 }; i > 0; --i)
|
||
{
|
||
if (_thresholds[i] <= threshold) return i;
|
||
}
|
||
|
||
assert(false);
|
||
return 0;
|
||
}
|
||
|
||
[[nodiscard]] constexpr u32 lod_count() const { return _lod_count; }
|
||
[[nodiscard]] constexpr f32* thresholds() const { return _thresholds; }
|
||
[[nodiscard]] constexpr lod_offset* lod_offsets() const { return _lod_offsets; }
|
||
[[nodiscard]] constexpr id::id_type* gpu_ids() const { return _gpu_ids; }
|
||
private:
|
||
u8 *const _buffer;
|
||
f32* _thresholds;
|
||
lod_offset* _lod_offsets;
|
||
id::id_type* _gpu_ids;
|
||
u32 _lod_count;
|
||
};
|
||
|
||
|
||
/**
|
||
* @brief 支持 noexcept 移动的着色器组缓存容器。
|
||
*/
|
||
struct noexcept_map {
|
||
std::unordered_map<u32, std::unique_ptr<u8[]>> map;
|
||
noexcept_map() = default;
|
||
noexcept_map(const noexcept_map&) = default;
|
||
noexcept_map(noexcept_map&&) noexcept = default;
|
||
noexcept_map& operator=(const noexcept_map&) = default;
|
||
noexcept_map& operator=(noexcept_map&&) noexcept = default;
|
||
|
||
};
|
||
|
||
/**
|
||
* @brief 单子网格资源的指针标记位。
|
||
*/
|
||
constexpr uintptr_t single_mesh_marker{ (uintptr_t)0x01 };
|
||
/**
|
||
* @brief 几何层级资源池。
|
||
*/
|
||
utl::free_list<u8*> geometry_hierarchies;
|
||
/**
|
||
* @brief 几何资源互斥锁。
|
||
*/
|
||
std::mutex geometry_mutex;
|
||
|
||
/**
|
||
* @brief 着色器组资源池。
|
||
*/
|
||
utl::free_list<noexcept_map> shader_groups;
|
||
/**
|
||
* @brief 着色器资源互斥锁。
|
||
*/
|
||
std::mutex shader_mutex;
|
||
|
||
|
||
/**
|
||
* @brief 预估并计算几何层级缓冲区所需字节数。
|
||
* @param data 几何二进制输入数据。
|
||
* @return 所需缓冲区大小（字节）。
|
||
*/
|
||
u32
|
||
get_geometry_hierarchy_buffer_size(const void *const data)
|
||
{
|
||
assert(data);
|
||
utl::blob_stream_reader blob{ (const u8*)data };
|
||
const u32 lod_count{ blob.reader<u32>() };
|
||
assert(lod_count);
|
||
constexpr u32 su32{ sizeof(u32) };
|
||
|
||
u32 size{ su32 + (sizeof(f32) + sizeof(lod_offset)) * lod_count };
|
||
|
||
for (u32 lod_idx{ 0 }; lod_idx < lod_count; ++lod_idx)
|
||
{
|
||
// skip threshold
|
||
blob.skip(sizeof(f32));
|
||
// add size of gpu_ids
|
||
size += sizeof(id::id_type) * blob.reader<u32>();
|
||
// skip submesh data and goto next LOD
|
||
blob.skip(blob.reader<u32>());
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
/**
|
||
* @brief 创建多 LOD 网格层级资源。
|
||
* @param data 几何二进制输入数据。
|
||
* @return 几何内容资源 ID。
|
||
*/
|
||
//id::id_type
|
||
//create_mesh_hierarchy(const void *const data)
|
||
//{
|
||
// assert(data);
|
||
//
|
||
// const u32 size{ get_geometry_hierarchy_buffer_size(data) };
|
||
// u8 *const hierarchy_buffer{ (u8 *const)malloc(size) };
|
||
//
|
||
// utl::blob_stream_reader blob{ (const u8*)data };
|
||
// const u32 lod_count{ blob.reader<u32>() };
|
||
// assert(lod_count);
|
||
// geometry_hierarchy_stream stream{ hierarchy_buffer, lod_count };
|
||
// u32 submesh_index{ 0 };
|
||
// id::id_type *const gpu_ids{ stream.gpu_ids() };
|
||
//
|
||
// for (u32 lod_idx{ 0 }; lod_idx < lod_count; ++lod_idx)
|
||
// {
|
||
// stream.thresholds()[lod_idx] = blob.reader<f32>();
|
||
// const u32 id_count{ blob.reader<u32>() };
|
||
// assert(id_count < (1 << 16));
|
||
// stream.lod_offsets()[lod_idx] = { (u16)submesh_index, (u16)id_count };
|
||
// blob.skip(sizeof(u32)); // skip sizeof submeshes
|
||
// for (u32 id_idx{ 0 }; id_idx < id_count; ++id_idx)
|
||
// {
|
||
// const u8* at{ blob.position() };
|
||
// gpu_ids[submesh_index++] = graphics::add_submesh(at);
|
||
// blob.skip((u32)(at - blob.position()));
|
||
// assert(submesh_index < (1 << 16));
|
||
// }
|
||
// }
|
||
//
|
||
// assert([&]()
|
||
// {
|
||
// f32 previous_theshold{ stream.thresholds()[0] };
|
||
// for (u32 i{ 1 }; i < lod_count; ++i)
|
||
// {
|
||
// if (stream.thresholds()[i] <= previous_theshold) return false;
|
||
// previous_theshold = stream.thresholds()[i];
|
||
// }
|
||
// return true;
|
||
// }());
|
||
//
|
||
// static_assert(alignof(void*) > 2, "We need the least significant bit for th single mesh marker.");
|
||
// std::lock_guard lock{ geometry_mutex };
|
||
// return geometry_hierarchies.add(hierarchy_buffer);
|
||
//}
|
||
|
||
/**
|
||
* @brief 判断几何数据是否为单 LOD 单子网格。
|
||
* @param data 几何二进制输入数据。
|
||
* @return 单子网格返回 true。
|
||
*/
|
||
bool
|
||
is_single_mesh(const void *const data)
|
||
{
|
||
assert(data);
|
||
utl::blob_stream_reader blob{ (const u8*)data };
|
||
const u32 lod_count{ blob.reader<u32>() };
|
||
assert(lod_count);
|
||
if (lod_count > 1) return false;
|
||
|
||
|
||
blob.skip(sizeof(f32)); // skip threhold
|
||
const u32 submesh_count{ blob.reader<u32>() };
|
||
assert(submesh_count);
|
||
return submesh_count == 1;
|
||
}
|
||
|
||
/**
|
||
* @brief 创建单子网格资源并编码为伪指针句柄。
|
||
* @param data 几何二进制输入数据。
|
||
* @return 几何内容资源 ID。
|
||
*/
|
||
//id::id_type
|
||
//create_single_submesh(const void *const data)
|
||
//{
|
||
// assert(data);
|
||
// utl::blob_stream_reader blob{ (const u8*)data };
|
||
// // skip lod_count, lod_threshold, submesh_count, and sizeof_submeshes
|
||
// blob.skip(sizeof(u32) + sizeof(f32) + sizeof(u32) + sizeof(u32));
|
||
// const u8* at{ blob.position() };
|
||
// const id::id_type gpu_id{ graphics::add_submesh(at) };
|
||
//
|
||
// // create a fake pointer and put it in the geometry_hierarchies.
|
||
// static_assert(sizeof(uintptr_t) > sizeof(id::id_type));
|
||
// constexpr u8 shift_bits{ (sizeof(uintptr_t) - sizeof(id::id_type)) << 3 };
|
||
// u8 *const fake_pointer{ (u8 *const)((((uintptr_t)gpu_id) << shift_bits) | single_mesh_marker) };
|
||
// std::lock_guard lock{ geometry_mutex };
|
||
// return geometry_hierarchies.add(fake_pointer);
|
||
//}
|
||
|
||
/**
|
||
* @brief 从单子网格伪指针解码 GPU 资源 ID。
|
||
* @param pointer 编码后的伪指针。
|
||
* @return GPU 子网格 ID。
|
||
*/
|
||
constexpr id::id_type
|
||
gpu_id_from_fake_pointer(u8 *const pointer)
|
||
{
|
||
assert((uintptr_t)pointer & single_mesh_marker);
|
||
static_assert(sizeof(uintptr_t) > sizeof(id::id_type));
|
||
constexpr u8 shift_bits{ (sizeof(uintptr_t) - sizeof(id::id_type)) << 3 };
|
||
return (((uintptr_t)pointer) >> shift_bits) & (uintptr_t)id::invalid_id;
|
||
}
|
||
//
|
||
// data contain:
|
||
//struct{
|
||
// u32 lod_count,
|
||
// struct{
|
||
// f32 lod_threshold,
|
||
// u32 submesh_count,
|
||
// u32 sizeof_submeshes,
|
||
// struct{
|
||
// u32 element_size, u32 vertex_count,
|
||
// u32 index_count, u32 elements_type, u32 primitive_topology
|
||
// u8 positions[sizeof(f32) * 3 * vertex_count],
|
||
// u8 elements[sizeof(element_size) * vertex_count],
|
||
// u8 indices[index_size * index_count],
|
||
// } submeshes[submesh_count]
|
||
// }mesh_lods[lod_count]
|
||
// } geometry;
|
||
//
|
||
// Output format
|
||
//
|
||
// struct{
|
||
// u32 lod_count,
|
||
// f32 thresholds[lod_count]
|
||
// struct{
|
||
// u16 offset,
|
||
// u16 count
|
||
// }lod_offsets[lod_count],
|
||
// id::idtype gpu_ids[total_number_of_submeshes]
|
||
//}geometry_hierarchy
|
||
//
|
||
//
|
||
//
|
||
//
|
||
|
||
/**
|
||
* @brief 按输入几何形态创建对应资源。
|
||
* @param data 几何二进制输入数据。
|
||
* @return 几何内容资源 ID。
|
||
*/
|
||
//id::id_type
|
||
//create_geometry_resource(const void *const data)
|
||
//{
|
||
// assert(data);
|
||
// return is_single_mesh(data) ? create_single_submesh(data) : create_mesh_hierarchy(data);
|
||
//}
|
||
|
||
/**
|
||
* @brief 销毁几何资源并释放关联子网格。
|
||
* @param id 几何内容资源 ID。
|
||
*/
|
||
//void
|
||
//destory_geometry_resource(id::id_type id)
|
||
//{
|
||
// std::lock_guard lock{ geometry_mutex };
|
||
// u8 *const pointer{ geometry_hierarchies[id] };
|
||
// if ((uintptr_t)pointer & single_mesh_marker)
|
||
// {
|
||
// graphics::remove_submesh(gpu_id_from_fake_pointer(pointer));
|
||
// }
|
||
// else
|
||
// {
|
||
// geometry_hierarchy_stream stream{ pointer };
|
||
// const u32 lod_count{ stream.lod_count() };
|
||
// u32 id_index{ 0 };
|
||
// for (u32 lod{ 0 }; lod < lod_count; ++lod)
|
||
// {
|
||
// for (u32 i{ 0 }; i < stream.lod_offsets()[lod].count; ++i)
|
||
// {
|
||
// graphics::remove_submesh(stream.gpu_ids()[id_index++]);
|
||
// }
|
||
// }
|
||
//
|
||
// free(pointer);
|
||
// }
|
||
//
|
||
// geometry_hierarchies.remove(id);
|
||
//}
|
||
|
||
/**
|
||
* @brief 创建材质资源。
|
||
* @param data 材质初始化数据。
|
||
* @return 材质资源 ID。
|
||
*/
|
||
//id::id_type
|
||
//create_material_resource(const void *const data)
|
||
//{
|
||
// assert(data);
|
||
// return graphics::add_material(*(const graphics::material_init_info *const)data);
|
||
//}
|
||
} // namespace
|
||
|
||
/**
|
||
* @brief 销毁材质资源。
|
||
* @param id 材质资源 ID。
|
||
*/
|
||
//void
|
||
//destory_material_resource(id::id_type id)
|
||
//{
|
||
// graphics::remove_material(id);
|
||
//}
|
||
|
||
/**
|
||
* @brief 统一资源创建入口。
|
||
* @param data 资源二进制数据。
|
||
* @param type 资源类型。
|
||
* @return 资源 ID。
|
||
*/
|
||
//id::id_type
|
||
//create_resource(const void *const data, asset_type::type type)
|
||
//{
|
||
// assert(data);
|
||
// id::id_type id{ id::invalid_id };
|
||
//
|
||
// switch (type)
|
||
// {
|
||
// case XEngine::content::asset_type::unknown: break;
|
||
// case XEngine::content::asset_type::animation: break;
|
||
// case XEngine::content::asset_type::audio: break;
|
||
// case XEngine::content::asset_type::material: id = create_material_resource(data); break;
|
||
// case XEngine::content::asset_type::mesh: id = create_geometry_resource(data); break;
|
||
// case XEngine::content::asset_type::skeleton: break;
|
||
// case XEngine::content::asset_type::texture: break;
|
||
// }
|
||
//
|
||
// assert(id::is_valid(id));
|
||
// return id;
|
||
//
|
||
//}
|
||
|
||
|
||
/**
|
||
* @brief 统一资源销毁入口。
|
||
* @param id 资源 ID。
|
||
* @param type 资源类型。
|
||
*/
|
||
//void
|
||
//destroy_resource(id::id_type id, asset_type::type type)
|
||
//{
|
||
// assert(id::is_valid(id));
|
||
// switch (type)
|
||
// {
|
||
// case XEngine::content::asset_type::unknown: break;
|
||
// case XEngine::content::asset_type::animation: break;
|
||
// case XEngine::content::asset_type::audio: break;
|
||
// case XEngine::content::asset_type::material: destory_material_resource(id); break;
|
||
// case XEngine::content::asset_type::mesh: destory_geometry_resource(id); break;
|
||
// case XEngine::content::asset_type::skeleton: break;
|
||
// case XEngine::content::asset_type::texture: break;
|
||
// default:
|
||
// assert(false);
|
||
// break;
|
||
// }
|
||
//}
|
||
/**
|
||
* @brief 注册着色器组并复制其二进制数据。
|
||
* @param shaders 着色器数组。
|
||
* @param num_shaders 着色器数量。
|
||
* @param keys 查询键数组。
|
||
* @return 着色器组 ID。
|
||
*/
|
||
id::id_type
|
||
add_shader_group(const u8 *const * shaders, u32 num_shaders, const u32 *const keys)
|
||
{
|
||
assert(shaders && num_shaders && keys);
|
||
noexcept_map group;
|
||
for (u32 i{ 0 }; i < num_shaders; ++i)
|
||
{
|
||
assert(shaders[i]);
|
||
const compiled_shader_ptr shader_ptr{ (const compiled_shader_ptr)shaders[i] };
|
||
const u64 size{ shader_ptr->buffer_size()};
|
||
std::unique_ptr<u8[]> shader{ std::make_unique<u8[]>(size) };
|
||
memcpy(shader.get(), shaders[i], size);
|
||
group.map[keys[i]] = std::move(shader);
|
||
}
|
||
std::lock_guard lock{ shader_mutex };
|
||
return shader_groups.add(std::move(group));
|
||
}
|
||
/**
|
||
* @brief 删除着色器组。
|
||
* @param id 着色器组 ID。
|
||
*/
|
||
void
|
||
remove_shader_group(id::id_type id)
|
||
{
|
||
std::lock_guard lock{ shader_mutex };
|
||
assert(id::is_valid(id));
|
||
|
||
shader_groups[id].map.clear();
|
||
shader_groups.remove(id);
|
||
}
|
||
/**
|
||
* @brief 在着色器组内按键查找着色器。
|
||
* @param id 着色器组 ID。
|
||
* @param shader_key 查询键。
|
||
* @return 命中时返回着色器指针。
|
||
*/
|
||
compiled_shader_ptr
|
||
get_shader(id::id_type id, u32 shader_key)
|
||
{
|
||
std::lock_guard lock{ shader_mutex };
|
||
assert(id::is_valid(id));
|
||
for (const auto& [key, value] : shader_groups[id].map)
|
||
{
|
||
if (key == shader_key)
|
||
{
|
||
return (const compiled_shader_ptr)value.get();
|
||
}
|
||
}
|
||
assert(false);
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
|
||
/**
|
||
* @brief 获取几何资源包含的全部子网格 GPU ID。
|
||
* @param geometry_content_id 几何内容资源 ID。
|
||
* @param id_count 输出数组长度。
|
||
* @param gpu_ids 输出数组。
|
||
*/
|
||
void
|
||
get_submesh_gpu_id(id::id_type geometry_content_id, u32 id_count, id::id_type *const gpu_ids)
|
||
{
|
||
std::lock_guard lock{ geometry_mutex };
|
||
u8 *const pointer{ geometry_hierarchies[geometry_content_id] };
|
||
if ((uintptr_t)pointer & single_mesh_marker)
|
||
{
|
||
assert(id_count == 1);
|
||
*gpu_ids = gpu_id_from_fake_pointer(pointer);
|
||
}
|
||
else
|
||
{
|
||
geometry_hierarchy_stream stream{ pointer };
|
||
|
||
assert([&]() {
|
||
const u32 lod_count{ stream.lod_count() };
|
||
const lod_offset lod_offset{ stream.lod_offsets()[lod_count - 1] };
|
||
const u32 gpu_id_count{ (u32)lod_offset.offset + (u32)lod_offset.count };
|
||
return gpu_id_count == id_count;
|
||
}());
|
||
|
||
|
||
memcpy(gpu_ids, stream.gpu_ids(), sizeof(id::id_type) * id_count);
|
||
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 按阈值查询各几何实例使用的 LOD 偏移。
|
||
* @param geometry_ids 几何资源 ID 数组。
|
||
* @param thresholds 每个实例的阈值数组。
|
||
* @param id_count 查询数量。
|
||
* @param offsets 输出 LOD 偏移数组。
|
||
*/
|
||
void
|
||
get_lod_offset(const id::id_type *const geometry_ids, const f32 *const thresholds, u32 id_count, utl::vector<lod_offset>& offsets)
|
||
{
|
||
assert(geometry_ids && thresholds && id_count);
|
||
assert(offsets.empty());
|
||
|
||
std::lock_guard lock{ geometry_mutex };
|
||
|
||
for (u32 i{ 0 }; i < id_count; ++i)
|
||
{
|
||
u8 *const pointer{ geometry_hierarchies[geometry_ids[i]] };
|
||
if ((uintptr_t)pointer & single_mesh_marker)
|
||
{
|
||
assert(id_count == 1);
|
||
offsets.emplace_back(lod_offset{ 0,1 });
|
||
}
|
||
else
|
||
{
|
||
geometry_hierarchy_stream stream{ pointer };
|
||
const u32 lod{ stream.lod_from_threshold(thresholds[i]) };
|
||
offsets.emplace_back(stream.lod_offsets()[lod]);
|
||
}
|
||
}
|
||
}
|
||
}
|