Skip to content

Revisiting import asset process #449

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 1 commit into
base: develop
Choose a base branch
from
Draft

Revisiting import asset process #449

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions Tetragrama/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,7 @@ target_include_directories (${TARGET_NAME}
./Helpers
./Importers
./Serializers
./Managers
${ENLISTMENT_ROOT}/ZEngine
)

Expand Down
66 changes: 34 additions & 32 deletions Tetragrama/Components/DockspaceUIComponent.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,31 +29,26 @@ namespace Tetragrama::Components
{
UIComponent::Initialize(parent, name, visibility, closed);

parent->LayerArena.CreateSubArena(ZMega(10), &LocalArena);

m_asset_importer = ZPushStructCtor(&(parent->LayerArena), Importers::AssimpImporter);
m_editor_serializer = ZPushStructCtor(&(parent->LayerArena), Serializers::EditorSceneSerializer);

m_editor_serializer->Initialize(&(parent->LayerArena));
m_asset_importer->Initialize(&(parent->LayerArena));

m_editor_serializer->AssetImporter = m_asset_importer;

m_dockspace_node_flag = ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_PassthruCentralNode;
m_window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
m_editor_serializer->AssetImporter = m_asset_importer;

auto context = reinterpret_cast<EditorContext*>(ParentLayer->ParentContext);
m_editor_serializer->Context = context;
m_asset_importer->Context = context;
m_dockspace_node_flag = ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_PassthruCentralNode;
m_window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;

const auto& editor_config = *context->ConfigurationPtr;
auto context = reinterpret_cast<EditorContext*>(ParentLayer->ParentContext);
m_editor_serializer->Context = context;
m_asset_importer->Context = context;

m_default_import_configuration = {};
m_default_import_configuration.OutputWorkingSpacePath.init(&(parent->LayerArena), editor_config.WorkingSpacePath.c_str());
m_default_import_configuration.OutputModelFilePath.init(&(parent->LayerArena), editor_config.SceneDataPath.c_str());
m_default_import_configuration.OutputMeshFilePath.init(&(parent->LayerArena), editor_config.SceneDataPath.c_str());
m_default_import_configuration.OutputMaterialsPath.init(&(parent->LayerArena), editor_config.SceneDataPath.c_str());
m_default_import_configuration.OutputTextureFilesPath.init(&(parent->LayerArena), editor_config.DefaultImportTexturePath.c_str());
const auto& editor_config = *context->ConfigurationPtr;

auto editor_serializer_default_output = fmt::format("{0}{1}{2}", editor_config.WorkingSpacePath.c_str(), PLATFORM_OS_BACKSLASH, editor_config.ScenePath.c_str());
auto editor_serializer_default_output = fmt::format("{0}{1}{2}", editor_config.WorkingSpacePath.c_str(), PLATFORM_OS_BACKSLASH, editor_config.ScenePath.c_str());

m_editor_serializer->SetDefaultOutput(editor_serializer_default_output);
m_editor_serializer->SetOnProgressCallback(OnEditorSceneSerializerProgress);
Expand Down Expand Up @@ -195,7 +190,7 @@ namespace Tetragrama::Components

if (ImGui::Button("Launch", ImVec2(80, 0)) && is_import_button_enabled)
{
Helpers::UIDispatcher::RunAsync([this] { OnImportAssetAsync(s_asset_importer_input_buffer); });
OnImportAssetAsync(s_asset_importer_input_buffer);
}

if (!is_import_button_enabled || std::string_view(s_asset_importer_input_buffer).empty())
Expand Down Expand Up @@ -400,16 +395,10 @@ namespace Tetragrama::Components
ZEngine::Helpers::secure_memset(s_save_as_input_buffer, 0, IM_ARRAYSIZE(s_save_as_input_buffer), IM_ARRAYSIZE(s_save_as_input_buffer));
}

void DockspaceUIComponent::OnAssetImporterComplete(void* const context, Importers::ImporterData&& data)
void DockspaceUIComponent::OnAssetImporterComplete(void* const context, const char* result)
{
s_asset_importer_report_msg_color = {0.0f, 1.0f, 0.0f, 1.0f};
s_asset_importer_report_msg = "Completed";

auto context_ptr = reinterpret_cast<EditorContext*>(context);
/*
* Removing the WorkingSpace Path
*/
context_ptr->CurrentScenePtr->Push(&(context_ptr->Arena), data.SerializedMeshesPath.c_str(), data.SerializedModelPath.c_str(), data.SerializedMaterialsPath.c_str());
}

void DockspaceUIComponent::OnAssetImporterProgress(void* const context, float value)
Expand Down Expand Up @@ -534,18 +523,31 @@ namespace Tetragrama::Components
co_return;
}

std::future<void> DockspaceUIComponent::OnImportAssetAsync(std::string_view filename)
std::future<void> DockspaceUIComponent::OnImportAssetAsync(const char* filename)
{
if (!filename.empty())
if (ZEngine::Helpers::secure_strlen(filename) == 0)
{
auto parent_path = std::filesystem::path(filename).parent_path().string();
auto asset_name = fs::path(filename).filename().replace_extension().string();
auto import_config = m_default_import_configuration;
import_config.AssetFilename.init(&(ParentLayer->LayerArena), asset_name.c_str());
import_config.InputBaseAssetFilePath.init(&(ParentLayer->LayerArena), parent_path.c_str());
co_await m_asset_importer->ImportAsync(filename, import_config);
co_return;
}
co_return;

LocalArena.Clear();

auto context = reinterpret_cast<EditorContext*>(ParentLayer->ParentContext);
auto arena = &LocalArena;
const auto& editor_config = *context->ConfigurationPtr;
auto parent_path = std::filesystem::path(filename).parent_path().string();
auto asset_name = fs::path(filename).filename().replace_extension().string();
auto output_asset_file = fmt::format("{}.zeasset", asset_name.c_str());

Importers::ImportConfiguration config = {};
config.OutputWorkingSpacePath.init(arena, editor_config.WorkingSpacePath.c_str());
config.OutputTextureFilesPath.init(arena, editor_config.DefaultImportTexturePath.c_str());
config.OutputAssetsPath.init(arena, editor_config.SceneDataPath.c_str());
config.AssetName.init(arena, asset_name.c_str());
config.OutputAssetFile.init(arena, output_asset_file.c_str());
config.InputBaseAssetFilePath.init(arena, parent_path.c_str());

co_await m_asset_importer->ImportAsync(filename, config);
}

std::future<void> DockspaceUIComponent::OnExitAsync()
Expand Down
46 changes: 24 additions & 22 deletions Tetragrama/Components/DockspaceUIComponent.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,39 +13,41 @@ namespace Tetragrama::Components
DockspaceUIComponent();
virtual ~DockspaceUIComponent();

void Initialize(Layers::ImguiLayer* parent = nullptr, const char* name = "Dockspace", bool visibility = true, bool closed = false) override;
ZEngine::Core::Memory::ArenaAllocator LocalArena = {};

void Update(ZEngine::Core::TimeStep dt) override;
virtual void Render(ZEngine::Rendering::Renderers::GraphicRenderer* const renderer, ZEngine::Hardwares::CommandBuffer* const command_buffer) override;
void Initialize(Layers::ImguiLayer* parent = nullptr, const char* name = "Dockspace", bool visibility = true, bool closed = false) override;

void RenderMenuBar();
void RenderSaveScene();
void RenderSaveSceneAs();
void ResetSaveAsBuffers();
void RenderExitPopup();
void Update(ZEngine::Core::TimeStep dt) override;
virtual void Render(ZEngine::Rendering::Renderers::GraphicRenderer* const renderer, ZEngine::Hardwares::CommandBuffer* const command_buffer) override;

void RenderMenuBar();
void RenderSaveScene();
void RenderSaveSceneAs();
void ResetSaveAsBuffers();
void RenderExitPopup();

/*
* Model Importer Funcs
*/
void RenderImporter();
void ResetImporterBuffers();
static void OnAssetImporterComplete(void* const, Importers::ImporterData&&);
static void OnAssetImporterProgress(void* const, float value);
static void OnAssetImporterError(void* const, std::string_view);
static void OnAssetImporterLog(void* const, std::string_view);
void RenderImporter();
void ResetImporterBuffers();
static void OnAssetImporterComplete(void* const context, const char* result);
static void OnAssetImporterProgress(void* const, float value);
static void OnAssetImporterError(void* const, std::string_view);
static void OnAssetImporterLog(void* const, std::string_view);

/*
* Editor Scene Funcs
*/
static void OnEditorSceneSerializerProgress(void* const, float value);
static void OnEditorSceneSerializerComplete(void* const);
static void OnEditorSceneSerializerDeserializeComplete(void* const, EditorScene&&);
static void OnEditorSceneSerializerError(void* const, std::string_view);
static void OnEditorSceneSerializerProgress(void* const, float value);
static void OnEditorSceneSerializerComplete(void* const);
static void OnEditorSceneSerializerDeserializeComplete(void* const, EditorScene&&);
static void OnEditorSceneSerializerError(void* const, std::string_view);

std::future<void> OnNewSceneAsync();
std::future<void> OnOpenSceneAsync();
std::future<void> OnImportAssetAsync(std::string_view filename);
std::future<void> OnExitAsync();
std::future<void> OnNewSceneAsync();
std::future<void> OnOpenSceneAsync();
std::future<void> OnImportAssetAsync(const char* filename);
std::future<void> OnExitAsync();

private:
static ImVec4 s_asset_importer_report_msg_color;
Expand Down
18 changes: 9 additions & 9 deletions Tetragrama/Helpers/SerializerCommonHelper.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,8 +2,6 @@
#include <SerializerCommonHelper.h>
#include <ZEngine/Helpers/MemoryOperations.h>

#define DEFAULT_STR_BUFFER 256

using namespace ZEngine::Core::Containers;

namespace Tetragrama::Helpers
Expand Down Expand Up @@ -37,11 +35,13 @@ namespace Tetragrama::Helpers
}
}

void SerializeMapData(std::ostream& os, const std::unordered_map<uint32_t, uint32_t>& data)
void SerializeMapData(std::ostream& os, ZEngine::Core::Containers::HashMap<uint32_t, uint32_t>& data)
{
std::vector<uint32_t> flat_data = {};
flat_data.reserve(data.size() * 2);
for (auto d : data)

auto view = data.view();
for (auto d : view)
{
flat_data.push_back(d.first);
flat_data.push_back(d.second);
Expand Down Expand Up @@ -71,18 +71,18 @@ namespace Tetragrama::Helpers
}
}

void DeserializeMapData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, std::unordered_map<uint32_t, uint32_t>& data)
void DeserializeMapData(ZEngine::Core::Memory::ArenaAllocator* Arena, std::istream& in, ZEngine::Core::Containers::HashMap<uint32_t, uint32_t>& data)
{
size_t data_count;
in.read(reinterpret_cast<char*>(&data_count), sizeof(size_t));
data.init(Arena, data_count);

std::vector<uint32_t> flat_data = {};
flat_data.resize(data_count);
in.read(reinterpret_cast<char*>(flat_data.data()), sizeof(uint32_t) * data_count);
uint32_t buf[DEFAULT_STR_BUFFER] = {0};
in.read(reinterpret_cast<char*>(buf), sizeof(uint32_t) * data_count);

for (int i = 0; i < data_count; i += 2)
{
data[flat_data[i]] = flat_data[i + 1];
data[buf[i]] = buf[i + 1];
}
}
} // namespace Tetragrama::Helpers
148 changes: 145 additions & 3 deletions Tetragrama/Helpers/SerializerCommonHelper.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,17 +1,159 @@
#pragma once
#include <ZEngine/Core/Containers/Array.h>
#include <ZEngine/Core/Containers/HashMap.h>
#include <ZEngine/Core/Containers/Strings.h>
#include <ZEngine/Core/Memory/Allocator.h>
#include <ZEngineDef.h>
#include <iostream>
#include <unordered_map>
#include <type_traits>

namespace Tetragrama::Helpers
{
void SerializeStringData(std::ostream&, ZEngine::Core::Containers::StringView);
void SerializeStringArrayData(std::ostream&, ZEngine::Core::Containers::ArrayView<ZEngine::Core::Containers::String>);
void SerializeMapData(std::ostream&, const std::unordered_map<uint32_t, uint32_t>&);
void SerializeMapData(std::ostream&, ZEngine::Core::Containers::HashMap<uint32_t, uint32_t>&);

void DeserializeStringData(ZEngine::Core::Memory::ArenaAllocator*, std::istream& in, ZEngine::Core::Containers::String& data);
void DeserializeStringArrayData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, ZEngine::Core::Containers::Array<ZEngine::Core::Containers::String>&);
void DeserializeMapData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, std::unordered_map<uint32_t, uint32_t>&);
void DeserializeMapData(ZEngine::Core::Memory::ArenaAllocator*, std::istream&, ZEngine::Core::Containers::HashMap<uint32_t, uint32_t>&);

template <typename T>
void WriteBinary(std::ostream& writer, const T& data)
{
writer.write(reinterpret_cast<const char*>(&data), sizeof(T));
}

template <typename T, typename = std::enable_if_t<std::is_same_v<T, const char*> || std::is_same_v<T, ZEngine::Core::Containers::String>>>
void WriteBinaryString(std::ostream& writer, const T& str)
{
if constexpr (std::is_same_v<T, ZEngine::Core::Containers::String>)

{
size_t count = str.size();
writer.write(reinterpret_cast<const char*>(&count), sizeof(size_t));
writer.write(str.c_str(), count + 1);
}
else if constexpr (std::is_same_v<T, const char*>)

{
size_t count = ZEngine::Helpers::secure_strlen(str);

writer.write(reinterpret_cast<const char*>(&count), sizeof(size_t));
writer.write(str, count + 1);
}
}

template <typename T>
void WriteBinaryArray(std::ostream& writer, ZEngine::Core::Containers::ArrayView<T> arr)
{
size_t count = arr.size();
writer.write(reinterpret_cast<const char*>(&count), sizeof(size_t));

if constexpr (std::is_same_v<T, ZEngine::Core::Containers::String>)

{
for (unsigned i = 0; i < count; ++i)
{
WriteBinaryString(writer, arr[i]);
}
}

else
{
writer.write(reinterpret_cast<const char*>(arr.data()), sizeof(T) * count);
}
}

template <class T, class U>
void WriteBinaryHashMap(std::ostream& writer, ZEngine::Core::Containers::HashMap<T, U>& map)
{
uint32_t size = static_cast<uint32_t>(map.size());
WriteBinary(writer, size);

auto view = map.view();
for (const auto& [key, val] : view)
{
WriteBinary(writer, key);
WriteBinary(writer, val);
}
}

template <typename T>
void ReadBinary(std::istream& in, T& value)
{
in.read(reinterpret_cast<char*>(&value), sizeof(T));
}

template <typename T, typename = std::enable_if_t<std::is_same_v<T, ZEngine::Core::Containers::String>>>
void ReadBinaryString(ZEngine::Core::Memory::ArenaAllocator* arena, std::istream& in, T& str)
{
uint32_t size;
ReadBinary(in, size);
if constexpr (std::is_same_v<T, ZEngine::Core::Containers::String>)

{
char buf[DEFAULT_STR_BUFFER] = {0};
in.read(reinterpret_cast<char*>(&size), sizeof(size_t));
in.read(buf, size + 1);

str.init(arena, buf);
}
}

template <typename T>
void ReadBinaryArray(ZEngine::Core::Memory::ArenaAllocator* arena, std::istream& in, ZEngine::Core::Containers::Array<T>& arr)
{
uint32_t size;
ReadBinary(in, size);
arr.init(arena, size, size);

if constexpr (std::is_same_v<T, ZEngine::Core::Containers::String>)

{
for (unsigned i = 0; i < size; ++i)
{
auto& str = arr[i];
ReadBinaryString(arena, in, str);
}
}
else
{
if (size > 0)
{
in.read(reinterpret_cast<char*>(arr.data()), sizeof(T) * size);
}
}
}

template <class T, class U>
void ReadHashMap(ZEngine::Core::Memory::ArenaAllocator* arena, std::istream& in, ZEngine::Core::Containers::HashMap<T, U>& map)
{
uint32_t size;
ReadBinary(in, size);

for (uint32_t i = 0; i < size; ++i)
{
T key;
U val;

if constexpr (std::is_same_v<T, ZEngine::Core::Containers::String>)
{
ReadBinaryString(arena, in, key);
}
else
{
ReadBinary(in, key);
}

if constexpr (std::is_same_v<U, ZEngine::Core::Containers::String>)
{
ReadBinaryString(arena, in, val);
}
else
{
ReadBinary(in, val);
}
map.insert(key, val);
}
}
} // namespace Tetragrama::Helpers
Loading