UI系统更新
This commit is contained in:
parent
6c39655c8f
commit
dcd4af87a2
@ -7,6 +7,7 @@
|
||||
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataDispatcher.h"
|
||||
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataProject.h"
|
||||
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataSource.h"
|
||||
#include "MetaCoreRuntimeUi/MetaCoreRuntimeUiSystem.h"
|
||||
#include "MetaCoreScene/MetaCoreScenePackage.h"
|
||||
#include "MetaCoreScene/MetaCoreScene.h"
|
||||
|
||||
@ -33,6 +34,7 @@ MetaCore::MetaCoreSceneView MetaCoreBuildPlayerSceneView() {
|
||||
document.DataSourcesPath = std::filesystem::path("Runtime") / "DataSources.mcruntime";
|
||||
document.BindingsPath = std::filesystem::path("Runtime") / "Bindings.mcruntime";
|
||||
document.DiagnosticsPath = std::filesystem::path("Runtime") / "Diagnostics.mcruntimestate";
|
||||
document.UiManifestPath = std::filesystem::path("Runtime") / "Ui.mcruntime";
|
||||
return document;
|
||||
}
|
||||
|
||||
@ -280,6 +282,22 @@ int main(int argc, char* argv[]) {
|
||||
auto bindingsDocument = loadedBindingsDocument.value_or(MetaCoreBuildDefaultRuntimeBindingsDocument());
|
||||
MetaCoreResolveRuntimeSourcePathsForProject(sourcesDocument, projectRoot);
|
||||
|
||||
const std::filesystem::path uiManifestPath = (projectRoot / runtimeProjectDocument.UiManifestPath).lexically_normal();
|
||||
const auto loadedUiManifest = runtimeProjectDocument.UiManifestPath.empty()
|
||||
? std::optional<MetaCore::MetaCoreRuntimeUiManifest>{}
|
||||
: MetaCore::MetaCoreReadRuntimeUiManifest(uiManifestPath, typeRegistry);
|
||||
MetaCore::MetaCoreRuntimeUiSystem runtimeUi;
|
||||
if (loadedUiManifest.has_value()) {
|
||||
if (!runtimeUi.Initialize(window, projectRoot, projectRoot / "Ui", *loadedUiManifest)) {
|
||||
std::cerr << "MetaCorePlayer: failed to initialize runtime UI\n";
|
||||
} else {
|
||||
runtimeUi.AttachToViewportRenderer(viewportRenderer);
|
||||
}
|
||||
for (const std::string& error : runtimeUi.GetErrors()) {
|
||||
std::cerr << "MetaCorePlayer UI: " << error << '\n';
|
||||
}
|
||||
}
|
||||
|
||||
if (loadedSourcesDocument.has_value() && loadedBindingsDocument.has_value()) {
|
||||
std::cout << "MetaCorePlayer: loaded runtime config from binary .mcruntime documents\n";
|
||||
} else {
|
||||
@ -334,7 +352,9 @@ int main(int argc, char* argv[]) {
|
||||
});
|
||||
if (runtimeAdapter != nullptr) {
|
||||
runtimeAdapter->Tick(1.0 / 60.0);
|
||||
runtimeDataDispatcher.ApplyUpdates(runtimeAdapter->PollUpdates());
|
||||
const std::vector<MetaCore::MetaCoreRuntimeDataUpdate> updates = runtimeAdapter->PollUpdates();
|
||||
runtimeDataDispatcher.ApplyUpdates(updates);
|
||||
runtimeUi.ApplyDataUpdates(updates);
|
||||
runtimeDataDispatcher.TickStaleness(runtimeAdapter->GetStatus().LastUpdateAt);
|
||||
}
|
||||
const auto diagnostics = runtimeDataDispatcher.BuildDiagnosticsSnapshot(
|
||||
@ -378,6 +398,7 @@ int main(int argc, char* argv[]) {
|
||||
}
|
||||
}
|
||||
}
|
||||
runtimeUi.Update(window.GetDeltaSeconds());
|
||||
viewportRenderer.RenderSceneToViewport(scene, MetaCoreBuildPlayerSceneView(), true);
|
||||
viewportRenderer.RenderAll();
|
||||
renderDevice.RenderFrame();
|
||||
@ -385,6 +406,7 @@ int main(int argc, char* argv[]) {
|
||||
window.EndFrame();
|
||||
}
|
||||
|
||||
runtimeUi.Shutdown();
|
||||
viewportRenderer.Shutdown();
|
||||
renderDevice.Shutdown();
|
||||
window.Shutdown();
|
||||
|
||||
@ -33,13 +33,14 @@ endif()
|
||||
|
||||
list(PREPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
|
||||
|
||||
set(METACORE_VCPKG_TRIPLET "")
|
||||
set(METACORE_VCPKG_DEFAULT_TRIPLET "")
|
||||
set(METACORE_VCPKG_PREFIX "")
|
||||
if(WIN32)
|
||||
set(METACORE_VCPKG_TRIPLET "x64-windows")
|
||||
set(METACORE_VCPKG_DEFAULT_TRIPLET "x64-windows")
|
||||
elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64)$")
|
||||
set(METACORE_VCPKG_TRIPLET "x64-linux")
|
||||
set(METACORE_VCPKG_DEFAULT_TRIPLET "x64-linux-clang-libcxx")
|
||||
endif()
|
||||
set(METACORE_VCPKG_TRIPLET "${METACORE_VCPKG_DEFAULT_TRIPLET}" CACHE STRING "vcpkg target triplet for MetaCore dependencies")
|
||||
|
||||
if(METACORE_VCPKG_TRIPLET)
|
||||
foreach(METACORE_VCPKG_PREFIX_CANDIDATE IN ITEMS
|
||||
@ -70,6 +71,23 @@ find_package(glm CONFIG REQUIRED)
|
||||
set(METACORE_IMGUI_USES_PKG_CONFIG FALSE)
|
||||
if(NOT METACORE_BUILD_CORE_ONLY)
|
||||
include(MetaCoreFilament)
|
||||
find_package(RmlUi CONFIG REQUIRED)
|
||||
find_package(PNG CONFIG REQUIRED)
|
||||
find_package(unofficial-brotli CONFIG REQUIRED)
|
||||
|
||||
# RmlUi's exported static target references Freetype, but the vcpkg Freetype
|
||||
# config does not propagate its compression libraries. Keep that dependency
|
||||
# detail local to the runtime UI target rather than leaking it to every app.
|
||||
set(METACORE_VCPKG_TRIPLET_ROOT "${CMAKE_SOURCE_DIR}/vcpkg_installed/${METACORE_VCPKG_TRIPLET}")
|
||||
find_library(METACORE_BZIP2_RELEASE NAMES bz2 PATHS "${METACORE_VCPKG_TRIPLET_ROOT}/lib" NO_DEFAULT_PATH REQUIRED)
|
||||
find_library(METACORE_BZIP2_DEBUG NAMES bz2d bz2 PATHS "${METACORE_VCPKG_TRIPLET_ROOT}/debug/lib" NO_DEFAULT_PATH REQUIRED)
|
||||
add_library(MetaCoreVcpkgBzip2 STATIC IMPORTED GLOBAL)
|
||||
set_target_properties(MetaCoreVcpkgBzip2 PROPERTIES
|
||||
IMPORTED_LOCATION_RELEASE "${METACORE_BZIP2_RELEASE}"
|
||||
IMPORTED_LOCATION_RELWITHDEBINFO "${METACORE_BZIP2_RELEASE}"
|
||||
IMPORTED_LOCATION_MINSIZEREL "${METACORE_BZIP2_RELEASE}"
|
||||
IMPORTED_LOCATION_DEBUG "${METACORE_BZIP2_DEBUG}"
|
||||
)
|
||||
find_package(imgui CONFIG QUIET)
|
||||
if(NOT imgui_FOUND)
|
||||
set(METACORE_IMGUI_USES_PKG_CONFIG TRUE)
|
||||
@ -218,6 +236,48 @@ if(NOT METACORE_BUILD_CORE_ONLY)
|
||||
)
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
set(METACORE_RML_UI_MATERIAL_SOURCE "${CMAKE_SOURCE_DIR}/Source/MetaCoreRuntimeUi/Private/Materials/rml_ui.mat")
|
||||
set(METACORE_RML_UI_MATERIAL_OUTPUT "${CMAKE_BINARY_DIR}/rml_ui.filamat")
|
||||
if(METACORE_FILAMENT_MATC_RUNNABLE AND EXISTS "${METACORE_RML_UI_MATERIAL_SOURCE}")
|
||||
add_custom_command(
|
||||
OUTPUT "${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
COMMAND "${METACORE_FILAMENT_MATC}"
|
||||
--platform desktop
|
||||
--api opengl
|
||||
--output "${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
"${METACORE_RML_UI_MATERIAL_SOURCE}"
|
||||
DEPENDS
|
||||
"${METACORE_RML_UI_MATERIAL_SOURCE}"
|
||||
"${METACORE_FILAMENT_MATC}"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_target(MetaCoreRmlUiMaterial
|
||||
DEPENDS "${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
)
|
||||
else()
|
||||
add_custom_command(
|
||||
OUTPUT "${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
"${METACORE_UI_BLIT_MATERIAL_OUTPUT}"
|
||||
"${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
DEPENDS "${METACORE_UI_BLIT_MATERIAL_OUTPUT}"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_target(MetaCoreRmlUiMaterial
|
||||
DEPENDS "${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
)
|
||||
endif()
|
||||
|
||||
function(metacore_stage_rml_ui_material target_name)
|
||||
add_dependencies(${target_name} MetaCoreRmlUiMaterial)
|
||||
add_custom_command(TARGET ${target_name} POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
"${METACORE_RML_UI_MATERIAL_OUTPUT}"
|
||||
"$<TARGET_FILE_DIR:${target_name}>/rml_ui.filamat"
|
||||
VERBATIM
|
||||
)
|
||||
endfunction()
|
||||
endif()
|
||||
|
||||
add_executable(MetaCoreHeaderTool
|
||||
@ -645,6 +705,28 @@ metacore_stage_ui_blit_material(MetaCoreLauncher)
|
||||
|
||||
|
||||
|
||||
add_library(MetaCoreRuntimeUi STATIC
|
||||
Source/MetaCoreRuntimeUi/Public/MetaCoreRuntimeUi/MetaCoreRuntimeUiSystem.h
|
||||
Source/MetaCoreRuntimeUi/Private/MetaCoreRuntimeUiSystem.cpp
|
||||
)
|
||||
target_include_directories(MetaCoreRuntimeUi
|
||||
PUBLIC Source/MetaCoreRuntimeUi/Public
|
||||
PRIVATE third_party
|
||||
)
|
||||
target_link_libraries(MetaCoreRuntimeUi
|
||||
PUBLIC
|
||||
MetaCoreFoundation
|
||||
MetaCorePlatform
|
||||
MetaCoreRender
|
||||
MetaCoreRuntimeData
|
||||
RmlUi::RmlUi
|
||||
PNG::PNG
|
||||
unofficial::brotli::brotlidec
|
||||
MetaCoreVcpkgBzip2
|
||||
)
|
||||
metacore_use_filament(MetaCoreRuntimeUi)
|
||||
target_compile_options(MetaCoreRuntimeUi PRIVATE ${METACORE_COMMON_WARNINGS})
|
||||
|
||||
add_executable(MetaCorePlayer
|
||||
Apps/MetaCorePlayer/main.cpp
|
||||
Source/MetaCoreRender/Private/MetaCoreGlibcCompat.cpp
|
||||
@ -657,8 +739,10 @@ target_link_libraries(MetaCorePlayer
|
||||
MetaCoreRender
|
||||
MetaCoreRuntimeData
|
||||
MetaCoreScene
|
||||
MetaCoreRuntimeUi
|
||||
)
|
||||
metacore_stage_ui_blit_material(MetaCorePlayer)
|
||||
metacore_stage_rml_ui_material(MetaCorePlayer)
|
||||
|
||||
|
||||
|
||||
@ -674,8 +758,11 @@ if(METACORE_BUILD_TESTS)
|
||||
PRIVATE
|
||||
MetaCoreEditor
|
||||
MetaCoreRuntimeData
|
||||
MetaCoreRuntimeUi
|
||||
)
|
||||
target_compile_options(MetaCoreSmokeTests PRIVATE ${METACORE_COMMON_WARNINGS})
|
||||
metacore_stage_ui_blit_material(MetaCoreSmokeTests)
|
||||
metacore_stage_rml_ui_material(MetaCoreSmokeTests)
|
||||
|
||||
|
||||
add_test(NAME MetaCoreSmokeTests COMMAND MetaCoreSmokeTests)
|
||||
|
||||
Binary file not shown.
Binary file not shown.
BIN
SandboxProject/Runtime/Ui.mcruntime
Normal file
BIN
SandboxProject/Runtime/Ui.mcruntime
Normal file
Binary file not shown.
15
SandboxProject/Ui/Generated/main_menu.rcss
Normal file
15
SandboxProject/Ui/Generated/main_menu.rcss
Normal file
@ -0,0 +1,15 @@
|
||||
body {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
background-color: transparent;
|
||||
font-family: sans-serif;
|
||||
}
|
||||
|
||||
.mcui {
|
||||
box-sizing: border-box;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.mcui-Button {
|
||||
text-align: center;
|
||||
}
|
||||
10
SandboxProject/Ui/Generated/main_menu.rml
Normal file
10
SandboxProject/Ui/Generated/main_menu.rml
Normal file
@ -0,0 +1,10 @@
|
||||
<rml>
|
||||
<head>
|
||||
<link type="text/rcss" href="main_menu.rcss" />
|
||||
</head>
|
||||
<body style="position:relative; width:1920px; height:1080px;">
|
||||
<button id="Button" class="mcui mcui-Button" data-metacore-action="Button" style="position:absolute; left:1460px; top:205px; width:295px; height:199px; color:rgba(255, 255, 255, 1.000); background-color:rgba(46, 87, 148, 0.850); font-size:16px; padding:8px 8px;">按钮
|
||||
<div id="Text" class="mcui mcui-Text" style="position:absolute; left:522px; top:62px; width:330px; height:249px; color:rgba(255, 255, 255, 1.000); background-color:rgba(31, 36, 46, 0.000); font-size:16px; padding:8px 8px;">文本</div>
|
||||
</button>
|
||||
</body>
|
||||
</rml>
|
||||
17
SandboxProject/Ui/NewHud.rcss
Normal file
17
SandboxProject/Ui/NewHud.rcss
Normal file
@ -0,0 +1,17 @@
|
||||
body {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
background-color: transparent;
|
||||
font-family: sans-serif;
|
||||
color: #f0f2f5;
|
||||
}
|
||||
|
||||
.mcui-element {
|
||||
box-sizing: border-box;
|
||||
padding: 8px 10px;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
button.mcui-element {
|
||||
text-align: center;
|
||||
}
|
||||
9
SandboxProject/Ui/NewHud.rml
Normal file
9
SandboxProject/Ui/NewHud.rml
Normal file
@ -0,0 +1,9 @@
|
||||
<rml>
|
||||
<head>
|
||||
<link type="text/rcss" href="NewHud.rcss" />
|
||||
</head>
|
||||
<body>
|
||||
<div id="ui_1" class="mcui-element" data-metacore-kind="panel" style="position:absolute; left:48px; top:48px; width:320px; height:160px; color:rgba(240, 242, 245, 1.000); background-color:rgba(26, 31, 41, 0.720);"></div>
|
||||
<div id="ui_2" class="mcui-element" style="position:absolute; left:72px; top:72px; width:180px; height:44px; color:rgba(240, 242, 245, 1.000); background-color:rgba(41, 46, 54, 0.820);">HUD</div>
|
||||
</body>
|
||||
</rml>
|
||||
@ -2695,6 +2695,236 @@ void MetaCoreDrawScriptComponentInspector(MetaCoreEditorContext& editorContext,
|
||||
}
|
||||
}
|
||||
|
||||
void MetaCoreDrawUiRendererComponentInspector(MetaCoreEditorContext& editorContext, MetaCoreGameObject& gameObject) {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
return;
|
||||
}
|
||||
|
||||
const bool multiEdit = editorContext.GetSelectedObjectIds().size() > 1;
|
||||
if (multiEdit) {
|
||||
ImGui::TextDisabled("多选编辑 %zu 个对象", editorContext.GetSelectedObjectIds().size());
|
||||
}
|
||||
|
||||
auto assetDatabaseService = editorContext.GetModuleRegistry().ResolveService<MetaCoreIAssetDatabaseService>();
|
||||
auto& uiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
|
||||
MetaCoreAssetGuid uiAssetGuid = MetaCoreGetSharedSelectedValue<MetaCoreAssetGuid>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<MetaCoreAssetGuid> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<MetaCoreAssetGuid>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().UiDocumentAssetGuid)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](const MetaCoreAssetGuid& lhs, const MetaCoreAssetGuid& rhs) { return lhs == rhs; }
|
||||
).value_or(uiRenderer.UiDocumentAssetGuid);
|
||||
|
||||
std::string uiAssetPreview = "未指定";
|
||||
if (uiAssetGuid.IsValid() && assetDatabaseService != nullptr) {
|
||||
if (const auto record = assetDatabaseService->FindAssetByGuid(uiAssetGuid); record.has_value()) {
|
||||
uiAssetPreview = record->RelativePath.generic_string();
|
||||
} else {
|
||||
uiAssetPreview = uiAssetGuid.ToString();
|
||||
}
|
||||
}
|
||||
if (multiEdit) {
|
||||
const auto sharedUiAsset = MetaCoreGetSharedSelectedValue<MetaCoreAssetGuid>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<MetaCoreAssetGuid> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<MetaCoreAssetGuid>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().UiDocumentAssetGuid)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](const MetaCoreAssetGuid& lhs, const MetaCoreAssetGuid& rhs) { return lhs == rhs; }
|
||||
);
|
||||
if (!sharedUiAsset.has_value()) {
|
||||
uiAssetPreview = "混合值";
|
||||
}
|
||||
}
|
||||
|
||||
ImGui::SetNextItemWidth(-1);
|
||||
if (ImGui::BeginCombo("UI 资产", uiAssetPreview.c_str())) {
|
||||
if (ImGui::Selectable("未指定", !uiAssetGuid.IsValid())) {
|
||||
(void)editorContext.ExecuteSnapshotCommand("修改 UI Renderer", [&]() {
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> MetaCoreAssetGuid* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().UiDocumentAssetGuid
|
||||
: nullptr;
|
||||
},
|
||||
MetaCoreAssetGuid{}
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
if (assetDatabaseService != nullptr) {
|
||||
for (const MetaCoreAssetRecord& record : assetDatabaseService->GetAssetRegistry()) {
|
||||
if (record.Type != "ui_document") {
|
||||
continue;
|
||||
}
|
||||
const bool selected = record.Guid == uiAssetGuid;
|
||||
if (ImGui::Selectable(record.RelativePath.generic_string().c_str(), selected)) {
|
||||
(void)editorContext.ExecuteSnapshotCommand("修改 UI Renderer", [&]() {
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> MetaCoreAssetGuid* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().UiDocumentAssetGuid
|
||||
: nullptr;
|
||||
},
|
||||
record.Guid
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
if (selected) {
|
||||
ImGui::SetItemDefaultFocus();
|
||||
}
|
||||
}
|
||||
}
|
||||
ImGui::EndCombo();
|
||||
}
|
||||
|
||||
const auto sharedRenderMode = MetaCoreGetSharedSelectedValue<MetaCoreUiRenderMode>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<MetaCoreUiRenderMode> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<MetaCoreUiRenderMode>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().RenderMode)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](MetaCoreUiRenderMode lhs, MetaCoreUiRenderMode rhs) { return lhs == rhs; }
|
||||
);
|
||||
int renderModeIndex = static_cast<int>(sharedRenderMode.value_or(uiRenderer.RenderMode));
|
||||
if (multiEdit && !sharedRenderMode.has_value()) {
|
||||
ImGui::TextDisabled("渲染模式: 混合值");
|
||||
}
|
||||
const char* renderModeItems[] = {"2D 屏幕空间", "3D 世界空间"};
|
||||
if (ImGui::Combo("渲染模式", &renderModeIndex, renderModeItems, IM_ARRAYSIZE(renderModeItems))) {
|
||||
const MetaCoreUiRenderMode newMode = renderModeIndex == 1 ? MetaCoreUiRenderMode::WorldSpace : MetaCoreUiRenderMode::ScreenSpace;
|
||||
(void)editorContext.ExecuteSnapshotCommand("修改 UI Renderer", [&]() {
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> MetaCoreUiRenderMode* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().RenderMode
|
||||
: nullptr;
|
||||
},
|
||||
newMode
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
auto drawBoolField = [&](const char* label, bool MetaCoreUiRendererComponent::* member) {
|
||||
const auto sharedValue = MetaCoreGetSharedSelectedValue<bool>(
|
||||
editorContext,
|
||||
[member](MetaCoreGameObject& selectedObject) -> std::optional<bool> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<bool>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().*member)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](bool lhs, bool rhs) { return lhs == rhs; }
|
||||
);
|
||||
bool value = sharedValue.value_or(uiRenderer.*member);
|
||||
if (multiEdit && !sharedValue.has_value()) {
|
||||
ImGui::TextDisabled("%s: 混合值", label);
|
||||
}
|
||||
if (ImGui::Checkbox(label, &value)) {
|
||||
(void)editorContext.ExecuteSnapshotCommand("修改 UI Renderer", [&]() {
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[member](MetaCoreGameObject& selectedObject) -> bool* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &(selectedObject.GetComponent<MetaCoreUiRendererComponent>().*member)
|
||||
: nullptr;
|
||||
},
|
||||
value
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
};
|
||||
drawBoolField("可见", &MetaCoreUiRendererComponent::Visible);
|
||||
drawBoolField("接收输入", &MetaCoreUiRendererComponent::InputEnabled);
|
||||
|
||||
int layer = MetaCoreGetSharedSelectedValue<std::int32_t>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<std::int32_t> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<std::int32_t>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().Layer)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](std::int32_t lhs, std::int32_t rhs) { return lhs == rhs; }
|
||||
).value_or(uiRenderer.Layer);
|
||||
if (ImGui::DragInt("层级", &layer, 1.0F, -10000, 10000)) {
|
||||
MetaCoreTrackComponentInspectorEdit(editorContext, "修改 UI Renderer", true);
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::int32_t* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().Layer
|
||||
: nullptr;
|
||||
},
|
||||
static_cast<std::int32_t>(layer)
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
}
|
||||
|
||||
float pixelsPerUnit = MetaCoreGetSharedSelectedValue<float>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<float> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<float>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().PixelsPerUnit)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](float lhs, float rhs) { return MetaCoreNearlyEqual(lhs, rhs); }
|
||||
).value_or(uiRenderer.PixelsPerUnit);
|
||||
if (ImGui::DragFloat("每单位像素", &pixelsPerUnit, 1.0F, 1.0F, 10000.0F)) {
|
||||
MetaCoreTrackComponentInspectorEdit(editorContext, "修改 UI Renderer", true);
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> float* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().PixelsPerUnit
|
||||
: nullptr;
|
||||
},
|
||||
std::max(1.0F, pixelsPerUnit)
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
}
|
||||
|
||||
glm::vec3 worldSize = MetaCoreGetSharedSelectedValue<glm::vec3>(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> std::optional<glm::vec3> {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? std::optional<glm::vec3>(selectedObject.GetComponent<MetaCoreUiRendererComponent>().WorldSize)
|
||||
: std::nullopt;
|
||||
},
|
||||
[](const glm::vec3& lhs, const glm::vec3& rhs) { return MetaCoreNearlyEqualVec3(lhs, rhs); }
|
||||
).value_or(uiRenderer.WorldSize);
|
||||
float worldSizeValues[2]{worldSize.x, worldSize.y};
|
||||
if (ImGui::DragFloat2("世界尺寸", worldSizeValues, 0.01F, 0.01F, 1000.0F)) {
|
||||
MetaCoreTrackComponentInspectorEdit(editorContext, "修改 UI Renderer", true);
|
||||
const glm::vec3 newWorldSize{std::max(0.01F, worldSizeValues[0]), std::max(0.01F, worldSizeValues[1]), 0.0F};
|
||||
MetaCoreApplyValueToSelectedObjects(
|
||||
editorContext,
|
||||
[](MetaCoreGameObject& selectedObject) -> glm::vec3* {
|
||||
return selectedObject.HasComponent<MetaCoreUiRendererComponent>()
|
||||
? &selectedObject.GetComponent<MetaCoreUiRendererComponent>().WorldSize
|
||||
: nullptr;
|
||||
},
|
||||
newWorldSize
|
||||
);
|
||||
editorContext.GetScene().IncrementRevision();
|
||||
}
|
||||
|
||||
ImGui::TextDisabled("2D 使用屏幕空间层级；3D 使用对象 Transform、世界尺寸和每单位像素。");
|
||||
}
|
||||
|
||||
void MetaCoreDrawMeshRendererComponentInspector(MetaCoreEditorContext& editorContext, MetaCoreGameObject& gameObject) {
|
||||
if (!gameObject.HasComponent<MetaCoreMeshRendererComponent>()) {
|
||||
return;
|
||||
@ -5868,6 +6098,47 @@ bool MetaCoreBuiltinAssetDatabaseService::SetStartupScenePath(const std::filesys
|
||||
return project.LibraryPath / "Cooked" / "Windows" / "CookManifest.bin";
|
||||
}
|
||||
|
||||
[[nodiscard]] bool MetaCoreCopyDirectoryTree(
|
||||
const std::filesystem::path& sourceRoot,
|
||||
const std::filesystem::path& targetRoot
|
||||
) {
|
||||
std::error_code errorCode;
|
||||
if (!std::filesystem::is_directory(sourceRoot, errorCode)) {
|
||||
return false;
|
||||
}
|
||||
std::filesystem::create_directories(targetRoot, errorCode);
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (const auto& entry : std::filesystem::recursive_directory_iterator(sourceRoot, errorCode)) {
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
const std::filesystem::path relativePath = entry.path().lexically_relative(sourceRoot);
|
||||
if (relativePath.empty() || relativePath.is_absolute() || *relativePath.begin() == "..") {
|
||||
return false;
|
||||
}
|
||||
const std::filesystem::path targetPath = targetRoot / relativePath;
|
||||
if (entry.is_directory(errorCode)) {
|
||||
std::filesystem::create_directories(targetPath, errorCode);
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
} else if (entry.is_regular_file(errorCode)) {
|
||||
std::filesystem::create_directories(targetPath.parent_path(), errorCode);
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
std::filesystem::copy_file(entry.path(), targetPath, std::filesystem::copy_options::overwrite_existing, errorCode);
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
class MetaCoreBuiltinCookService final : public MetaCoreICookService {
|
||||
public:
|
||||
[[nodiscard]] std::string GetServiceId() const override { return "MetaCore.CookService"; }
|
||||
@ -5889,6 +6160,7 @@ public:
|
||||
|
||||
[[nodiscard]] bool CookAsset(const MetaCoreAssetGuid& assetGuid) override;
|
||||
[[nodiscard]] bool CookScene(const std::filesystem::path& relativeScenePath) override;
|
||||
[[nodiscard]] bool CookRuntimeUiAssets() override;
|
||||
[[nodiscard]] std::filesystem::path GetCookedPathForAsset(const MetaCoreAssetGuid& assetGuid) const override;
|
||||
|
||||
private:
|
||||
@ -6407,6 +6679,52 @@ bool MetaCoreBuiltinCookService::CookScene(const std::filesystem::path& relative
|
||||
return sceneRecord.has_value() ? CookAsset(sceneRecord->Guid) : false;
|
||||
}
|
||||
|
||||
bool MetaCoreBuiltinCookService::CookRuntimeUiAssets() {
|
||||
if (AssetDatabaseService_ == nullptr || ReflectionRegistry_ == nullptr || !AssetDatabaseService_->HasProject()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const MetaCoreProjectDescriptor& project = AssetDatabaseService_->GetProjectDescriptor();
|
||||
const std::filesystem::path sourceUiRoot = project.UiPath;
|
||||
const std::filesystem::path sourceManifestPath = project.RuntimePath / "Ui.mcruntime";
|
||||
const std::filesystem::path targetRuntimeRoot = project.BuildPath / "Runtime";
|
||||
const std::filesystem::path targetUiRoot = project.BuildPath / "Ui";
|
||||
const std::filesystem::path targetManifestPath = targetRuntimeRoot / "Ui.mcruntime";
|
||||
|
||||
if (!std::filesystem::is_directory(sourceUiRoot) || !std::filesystem::exists(sourceManifestPath)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto manifest = MetaCoreReadRuntimeUiManifest(sourceManifestPath, ReflectionRegistry_->GetTypeRegistry());
|
||||
if (!manifest.has_value()) {
|
||||
return false;
|
||||
}
|
||||
for (const MetaCoreRuntimeUiDocumentEntry& entry : manifest->Documents) {
|
||||
const std::filesystem::path absoluteRmlPath = sourceUiRoot / entry.RmlPath;
|
||||
const std::filesystem::path normalizedRelative = entry.RmlPath.lexically_normal();
|
||||
if (entry.DocumentId.empty() ||
|
||||
normalizedRelative.empty() ||
|
||||
normalizedRelative.is_absolute() ||
|
||||
*normalizedRelative.begin() == ".." ||
|
||||
absoluteRmlPath.extension() != ".rml" ||
|
||||
!std::filesystem::exists(absoluteRmlPath)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!MetaCoreCopyDirectoryTree(sourceUiRoot, targetUiRoot)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
std::error_code errorCode;
|
||||
std::filesystem::create_directories(targetRuntimeRoot, errorCode);
|
||||
if (errorCode) {
|
||||
return false;
|
||||
}
|
||||
std::filesystem::copy_file(sourceManifestPath, targetManifestPath, std::filesystem::copy_options::overwrite_existing, errorCode);
|
||||
return !errorCode;
|
||||
}
|
||||
|
||||
std::filesystem::path MetaCoreBuiltinCookService::GetCookedPathForAsset(const MetaCoreAssetGuid& assetGuid) const {
|
||||
const_cast<MetaCoreBuiltinCookService*>(this)->LoadManifest();
|
||||
const auto iterator = std::find_if(Manifest_.Entries.begin(), Manifest_.Entries.end(), [&](const MetaCoreCookManifestEntry& entry) {
|
||||
@ -7299,6 +7617,51 @@ public:
|
||||
},
|
||||
MetaCoreDrawScriptComponentInspector
|
||||
});
|
||||
Descriptors_.push_back(MetaCoreComponentDescriptor{
|
||||
"UiRenderer",
|
||||
"UI Renderer",
|
||||
[](const MetaCoreGameObject& gameObject) { return gameObject.HasComponent<MetaCoreUiRendererComponent>(); },
|
||||
[](MetaCoreGameObject& gameObject) {
|
||||
if (gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
return false;
|
||||
}
|
||||
gameObject.AddComponent<MetaCoreUiRendererComponent>(MetaCoreUiRendererComponent{});
|
||||
return true;
|
||||
},
|
||||
[](MetaCoreGameObject& gameObject) {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
return false;
|
||||
}
|
||||
gameObject.RemoveComponent<MetaCoreUiRendererComponent>();
|
||||
return true;
|
||||
},
|
||||
[](MetaCoreGameObject& gameObject) {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
return false;
|
||||
}
|
||||
gameObject.GetComponent<MetaCoreUiRendererComponent>() = MetaCoreUiRendererComponent{};
|
||||
return true;
|
||||
},
|
||||
[](const MetaCoreGameObject& gameObject, const MetaCoreTypeRegistry& registry) -> std::optional<std::vector<std::byte>> {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
return MetaCoreSerializeComponentValue(gameObject.GetComponent<MetaCoreUiRendererComponent>(), registry);
|
||||
},
|
||||
[](MetaCoreGameObject& gameObject, std::span<const std::byte> payload, const MetaCoreTypeRegistry& registry) {
|
||||
MetaCoreUiRendererComponent component{};
|
||||
if (!MetaCoreDeserializeComponentValue(payload, component, registry)) {
|
||||
return false;
|
||||
}
|
||||
if (gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
gameObject.GetComponent<MetaCoreUiRendererComponent>() = component;
|
||||
} else {
|
||||
gameObject.AddComponent<MetaCoreUiRendererComponent>(component);
|
||||
}
|
||||
return true;
|
||||
},
|
||||
MetaCoreDrawUiRendererComponentInspector
|
||||
});
|
||||
Descriptors_.push_back(MetaCoreComponentDescriptor{
|
||||
"MeshRenderer",
|
||||
"Mesh Renderer",
|
||||
@ -8386,6 +8749,7 @@ std::optional<std::filesystem::path> MetaCoreBuiltinPrefabService::CreatePrefabF
|
||||
if (gameObject.HasComponent<MetaCoreLightComponent>()) data.Light = gameObject.GetComponent<MetaCoreLightComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreRotatorComponent>()) data.Rotator = gameObject.GetComponent<MetaCoreRotatorComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreScriptComponent>()) data.Script = gameObject.GetComponent<MetaCoreScriptComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreUiRendererComponent>()) data.UiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreMeshRendererComponent>()) data.MeshRenderer = gameObject.GetComponent<MetaCoreMeshRendererComponent>();
|
||||
prefabDataObjects.push_back(std::move(data));
|
||||
}
|
||||
@ -8449,6 +8813,7 @@ std::optional<MetaCoreId> MetaCoreBuiltinPrefabService::InstantiatePrefabDocumen
|
||||
if (sourceObject.Light.has_value()) clonedObject.AddComponent<MetaCoreLightComponent>(*sourceObject.Light);
|
||||
if (sourceObject.Rotator.has_value()) clonedObject.AddComponent<MetaCoreRotatorComponent>(*sourceObject.Rotator);
|
||||
if (sourceObject.Script.has_value()) clonedObject.AddComponent<MetaCoreScriptComponent>(*sourceObject.Script);
|
||||
if (sourceObject.UiRenderer.has_value()) clonedObject.AddComponent<MetaCoreUiRendererComponent>(*sourceObject.UiRenderer);
|
||||
if (sourceObject.MeshRenderer.has_value()) clonedObject.AddComponent<MetaCoreMeshRendererComponent>(*sourceObject.MeshRenderer);
|
||||
|
||||
clonedObject.AddComponent<MetaCorePrefabInstanceMetadata>(MetaCorePrefabInstanceMetadata{
|
||||
@ -8561,6 +8926,7 @@ bool MetaCoreBuiltinPrefabService::ApplySelectedPrefabInstance(MetaCoreEditorCon
|
||||
if (gameObject.HasComponent<MetaCoreLightComponent>()) data.Light = gameObject.GetComponent<MetaCoreLightComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreRotatorComponent>()) data.Rotator = gameObject.GetComponent<MetaCoreRotatorComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreScriptComponent>()) data.Script = gameObject.GetComponent<MetaCoreScriptComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreUiRendererComponent>()) data.UiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (gameObject.HasComponent<MetaCoreMeshRendererComponent>()) data.MeshRenderer = gameObject.GetComponent<MetaCoreMeshRendererComponent>();
|
||||
|
||||
prefabDataObjects.push_back(std::move(data));
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,7 +2,9 @@
|
||||
|
||||
#include "MetaCoreEditor/MetaCoreBuiltinModules.h"
|
||||
#include "MetaCoreEditor/MetaCoreEditorServices.h"
|
||||
#include "MetaCoreFoundation/MetaCorePackage.h"
|
||||
#include "MetaCoreFoundation/MetaCoreProject.h"
|
||||
#include "MetaCoreFoundation/MetaCoreReflection.h"
|
||||
#include "MetaCoreRender/MetaCoreSceneRenderSync.h"
|
||||
#include "MetaCoreEditorCameraController.h"
|
||||
|
||||
@ -27,6 +29,7 @@
|
||||
#define GLM_ENABLE_EXPERIMENTAL
|
||||
#include <algorithm>
|
||||
#include <chrono>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <filesystem>
|
||||
@ -40,6 +43,7 @@
|
||||
#include <glm/vec4.hpp>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <vector>
|
||||
|
||||
@ -945,6 +949,326 @@ void MetaCoreDrawSelectionHierarchyOverlay(
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
[[nodiscard]] std::optional<T> MetaCoreReadEditorTypedPackagePayload(
|
||||
const MetaCorePackageDocument& package,
|
||||
const MetaCoreTypeRegistry& registry,
|
||||
std::string_view expectedTypeName
|
||||
) {
|
||||
if (package.Exports.empty()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const MetaCoreStructDescriptor* descriptor = registry.FindStruct<T>();
|
||||
const MetaCoreExportEntry& exportEntry = package.Exports.front();
|
||||
if (descriptor == nullptr || descriptor->Name != expectedTypeName || exportEntry.PayloadIndex >= package.PayloadSections.size()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
T value{};
|
||||
if (!MetaCoreDeserializeFromBytes(package.PayloadSections[exportEntry.PayloadIndex], value, registry)) {
|
||||
return std::nullopt;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
struct MetaCoreUiPreviewDocumentCacheEntry {
|
||||
std::filesystem::path AbsolutePath{};
|
||||
std::filesystem::file_time_type LastWriteTime{};
|
||||
std::optional<MetaCoreUiDocument> Document{};
|
||||
bool TriedLoad = false;
|
||||
};
|
||||
|
||||
[[nodiscard]] std::optional<MetaCoreUiDocument> MetaCoreLoadUiPreviewDocument(
|
||||
const MetaCoreEditorContext& editorContext,
|
||||
const MetaCoreUiRendererComponent& uiRenderer
|
||||
) {
|
||||
if (!uiRenderer.UiDocumentAssetGuid.IsValid()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const auto assetDatabaseService = editorContext.GetModuleRegistry().ResolveService<MetaCoreIAssetDatabaseService>();
|
||||
const auto packageService = editorContext.GetModuleRegistry().ResolveService<MetaCoreIPackageService>();
|
||||
const auto reflectionRegistry = editorContext.GetModuleRegistry().ResolveService<MetaCoreIReflectionRegistry>();
|
||||
if (assetDatabaseService == nullptr || packageService == nullptr || reflectionRegistry == nullptr || !assetDatabaseService->HasProject()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const auto record = assetDatabaseService->FindAssetByGuid(uiRenderer.UiDocumentAssetGuid);
|
||||
if (!record.has_value()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
const std::filesystem::path relativePackagePath = !record->PackagePath.empty() ? record->PackagePath : record->RelativePath;
|
||||
const std::filesystem::path absolutePath = assetDatabaseService->GetProjectDescriptor().RootPath / relativePackagePath;
|
||||
std::filesystem::file_time_type lastWriteTime{};
|
||||
std::error_code errorCode;
|
||||
if (std::filesystem::exists(absolutePath, errorCode)) {
|
||||
lastWriteTime = std::filesystem::last_write_time(absolutePath, errorCode);
|
||||
}
|
||||
|
||||
static std::unordered_map<std::string, MetaCoreUiPreviewDocumentCacheEntry> cache;
|
||||
const std::string cacheKey = uiRenderer.UiDocumentAssetGuid.ToString();
|
||||
MetaCoreUiPreviewDocumentCacheEntry& cacheEntry = cache[cacheKey];
|
||||
if (cacheEntry.TriedLoad && cacheEntry.AbsolutePath == absolutePath && cacheEntry.LastWriteTime == lastWriteTime) {
|
||||
return cacheEntry.Document;
|
||||
}
|
||||
|
||||
cacheEntry.AbsolutePath = absolutePath;
|
||||
cacheEntry.LastWriteTime = lastWriteTime;
|
||||
cacheEntry.TriedLoad = true;
|
||||
cacheEntry.Document.reset();
|
||||
|
||||
const auto package = packageService->ReadPackage(absolutePath);
|
||||
if (!package.has_value()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
cacheEntry.Document = MetaCoreReadEditorTypedPackagePayload<MetaCoreUiDocument>(
|
||||
*package,
|
||||
reflectionRegistry->GetTypeRegistry(),
|
||||
"MetaCoreUiDocument"
|
||||
);
|
||||
return cacheEntry.Document;
|
||||
}
|
||||
|
||||
[[nodiscard]] ImU32 MetaCoreUiPreviewColor(const glm::vec3& color, float alpha) {
|
||||
return ImGui::ColorConvertFloat4ToU32(ImVec4(
|
||||
std::clamp(color.x, 0.0F, 1.0F),
|
||||
std::clamp(color.y, 0.0F, 1.0F),
|
||||
std::clamp(color.z, 0.0F, 1.0F),
|
||||
std::clamp(alpha, 0.0F, 1.0F)
|
||||
));
|
||||
}
|
||||
|
||||
void MetaCoreDrawUiDocumentPreview(
|
||||
ImDrawList& drawList,
|
||||
const MetaCoreUiDocument& document,
|
||||
const ImVec2& previewMin,
|
||||
const ImVec2& previewSize
|
||||
) {
|
||||
const float referenceWidth = static_cast<float>(std::max(1, document.ReferenceWidth));
|
||||
const float referenceHeight = static_cast<float>(std::max(1, document.ReferenceHeight));
|
||||
const float scaleX = previewSize.x / referenceWidth;
|
||||
const float scaleY = previewSize.y / referenceHeight;
|
||||
const ImVec2 previewMax(previewMin.x + previewSize.x, previewMin.y + previewSize.y);
|
||||
|
||||
drawList.PushClipRect(previewMin, previewMax, true);
|
||||
for (const MetaCoreUiNodeDocument& node : document.Nodes) {
|
||||
if (!node.Visible) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const ImVec2 rectMin(
|
||||
previewMin.x + node.RectTransform.Position.x * scaleX,
|
||||
previewMin.y + node.RectTransform.Position.y * scaleY
|
||||
);
|
||||
const ImVec2 rectSize(
|
||||
std::max(1.0F, node.RectTransform.Size.x * scaleX),
|
||||
std::max(1.0F, node.RectTransform.Size.y * scaleY)
|
||||
);
|
||||
const ImVec2 rectMax(rectMin.x + rectSize.x, rectMin.y + rectSize.y);
|
||||
const bool isText = node.Type == MetaCoreUiNodeType::Text;
|
||||
const bool isButton = node.Type == MetaCoreUiNodeType::Button;
|
||||
const bool isImage = node.Type == MetaCoreUiNodeType::Image;
|
||||
|
||||
const float fillAlpha = isText ? 0.0F : (isButton ? 0.92F : 0.82F);
|
||||
if (!isText) {
|
||||
drawList.AddRectFilled(rectMin, rectMax, MetaCoreUiPreviewColor(node.Style.BackgroundColor, fillAlpha), 4.0F);
|
||||
}
|
||||
drawList.AddRect(
|
||||
rectMin,
|
||||
rectMax,
|
||||
isButton ? IM_COL32(130, 190, 255, 220) : IM_COL32(132, 145, 166, isText ? 80 : 170),
|
||||
4.0F,
|
||||
0,
|
||||
isButton ? 1.4F : 1.0F
|
||||
);
|
||||
|
||||
if (isImage) {
|
||||
drawList.AddLine(rectMin, rectMax, IM_COL32(210, 220, 235, 115), 1.0F);
|
||||
drawList.AddLine(ImVec2(rectMax.x, rectMin.y), ImVec2(rectMin.x, rectMax.y), IM_COL32(210, 220, 235, 115), 1.0F);
|
||||
}
|
||||
|
||||
const std::string label = !node.Text.empty() ? node.Text : (!node.Name.empty() ? node.Name : node.Id);
|
||||
if (!label.empty() && rectSize.x > 12.0F && rectSize.y > 12.0F) {
|
||||
const ImU32 textColor = MetaCoreUiPreviewColor(node.Style.TextColor, 0.96F);
|
||||
const ImVec2 textPos(
|
||||
rectMin.x + std::max(3.0F, node.Style.Padding.x * scaleX),
|
||||
rectMin.y + std::max(3.0F, node.Style.Padding.y * scaleY)
|
||||
);
|
||||
drawList.AddText(textPos, textColor, label.c_str());
|
||||
}
|
||||
}
|
||||
drawList.PopClipRect();
|
||||
}
|
||||
|
||||
void MetaCoreDrawScreenSpaceUiPreviewOverlay(
|
||||
const MetaCoreEditorContext& editorContext,
|
||||
const MetaCoreScene& scene,
|
||||
const MetaCoreSceneViewportState& viewportState
|
||||
) {
|
||||
if (viewportState.Width <= 1.0F || viewportState.Height <= 1.0F) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct UiPreviewItem {
|
||||
MetaCoreId ObjectId = 0;
|
||||
std::string Name{};
|
||||
std::int32_t Layer = 0;
|
||||
float ReferenceWidth = 1920.0F;
|
||||
float ReferenceHeight = 1080.0F;
|
||||
std::optional<MetaCoreUiDocument> Document{};
|
||||
};
|
||||
|
||||
std::vector<UiPreviewItem> items;
|
||||
for (const MetaCoreGameObject& gameObject : scene.GetGameObjects()) {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
continue;
|
||||
}
|
||||
const MetaCoreUiRendererComponent& uiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (!uiRenderer.Visible || uiRenderer.RenderMode != MetaCoreUiRenderMode::ScreenSpace) {
|
||||
continue;
|
||||
}
|
||||
|
||||
std::optional<MetaCoreUiDocument> document = MetaCoreLoadUiPreviewDocument(editorContext, uiRenderer);
|
||||
const float referenceWidth = document.has_value()
|
||||
? static_cast<float>(std::max(1, document->ReferenceWidth))
|
||||
: std::max(1.0F, uiRenderer.WorldSize.x * std::max(1.0F, uiRenderer.PixelsPerUnit));
|
||||
const float referenceHeight = document.has_value()
|
||||
? static_cast<float>(std::max(1, document->ReferenceHeight))
|
||||
: std::max(1.0F, uiRenderer.WorldSize.y * std::max(1.0F, uiRenderer.PixelsPerUnit));
|
||||
items.push_back(UiPreviewItem{
|
||||
gameObject.GetId(),
|
||||
gameObject.GetName(),
|
||||
uiRenderer.Layer,
|
||||
referenceWidth,
|
||||
referenceHeight,
|
||||
std::move(document)
|
||||
});
|
||||
}
|
||||
|
||||
if (items.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
std::sort(items.begin(), items.end(), [](const UiPreviewItem& lhs, const UiPreviewItem& rhs) {
|
||||
if (lhs.Layer != rhs.Layer) {
|
||||
return lhs.Layer < rhs.Layer;
|
||||
}
|
||||
return lhs.ObjectId < rhs.ObjectId;
|
||||
});
|
||||
|
||||
ImDrawList* drawList = ImGui::GetForegroundDrawList();
|
||||
const ImVec2 viewportMin(viewportState.Left, viewportState.Top);
|
||||
const ImVec2 viewportMax(viewportState.Left + viewportState.Width, viewportState.Top + viewportState.Height);
|
||||
drawList->PushClipRect(viewportMin, viewportMax, true);
|
||||
|
||||
for (const UiPreviewItem& item : items) {
|
||||
const float fitScale = std::min(viewportState.Width / item.ReferenceWidth, viewportState.Height / item.ReferenceHeight);
|
||||
const float previewWidth = std::max(24.0F, item.ReferenceWidth * fitScale);
|
||||
const float previewHeight = std::max(24.0F, item.ReferenceHeight * fitScale);
|
||||
const ImVec2 rectMin(
|
||||
viewportState.Left + (viewportState.Width - previewWidth) * 0.5F,
|
||||
viewportState.Top + (viewportState.Height - previewHeight) * 0.5F
|
||||
);
|
||||
const ImVec2 rectMax(rectMin.x + previewWidth, rectMin.y + previewHeight);
|
||||
const bool selected = editorContext.GetSelectedObjectId() == item.ObjectId;
|
||||
const ImU32 fillColor = selected ? IM_COL32(32, 104, 210, 54) : IM_COL32(32, 104, 210, 34);
|
||||
const ImU32 strokeColor = selected ? IM_COL32(98, 178, 255, 230) : IM_COL32(98, 178, 255, 150);
|
||||
drawList->AddRectFilled(rectMin, rectMax, fillColor, 4.0F);
|
||||
drawList->AddRect(rectMin, rectMax, strokeColor, 4.0F, 0, selected ? 2.0F : 1.2F);
|
||||
if (item.Document.has_value()) {
|
||||
MetaCoreDrawUiDocumentPreview(*drawList, *item.Document, rectMin, ImVec2(previewWidth, previewHeight));
|
||||
}
|
||||
|
||||
const std::string label = "2D UI: " + item.Name;
|
||||
const ImVec2 labelPos(rectMin.x + 8.0F, rectMin.y + 7.0F);
|
||||
drawList->AddText(labelPos, strokeColor, label.c_str());
|
||||
if (!item.Document.has_value()) {
|
||||
drawList->AddText(ImVec2(rectMin.x + 8.0F, rectMin.y + 27.0F), IM_COL32(255, 196, 120, 230), "未能读取 UI 文档");
|
||||
}
|
||||
}
|
||||
|
||||
drawList->PopClipRect();
|
||||
}
|
||||
|
||||
void MetaCoreDrawWorldSpaceUiPreviewOverlay(
|
||||
const MetaCoreEditorContext& editorContext,
|
||||
const MetaCoreScene& scene,
|
||||
const MetaCoreSceneView& sceneView,
|
||||
const MetaCoreSceneViewportState& viewportState
|
||||
) {
|
||||
if (viewportState.Width <= 1.0F || viewportState.Height <= 1.0F) {
|
||||
return;
|
||||
}
|
||||
|
||||
ImDrawList* drawList = ImGui::GetForegroundDrawList();
|
||||
const ImVec2 viewportMin(viewportState.Left, viewportState.Top);
|
||||
const ImVec2 viewportMax(viewportState.Left + viewportState.Width, viewportState.Top + viewportState.Height);
|
||||
drawList->PushClipRect(viewportMin, viewportMax, true);
|
||||
|
||||
const glm::vec3 viewDirection = glm::normalize(sceneView.CameraTarget - sceneView.CameraPosition);
|
||||
const float fovRadians = glm::radians(std::max(1.0F, sceneView.VerticalFieldOfViewDegrees));
|
||||
const float orthographicHeight = std::max(0.01F, sceneView.OrthographicSize * 2.0F);
|
||||
|
||||
for (const MetaCoreGameObject& gameObject : scene.GetGameObjects()) {
|
||||
if (!gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
continue;
|
||||
}
|
||||
const MetaCoreUiRendererComponent& uiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (!uiRenderer.Visible || uiRenderer.RenderMode != MetaCoreUiRenderMode::WorldSpace) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const MetaCoreTransformComponent& transform = gameObject.GetComponent<MetaCoreTransformComponent>();
|
||||
ImVec2 centerPoint{};
|
||||
if (!MetaCoreProjectWorldPointToViewport(sceneView, viewportState, transform.Position, centerPoint)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const float worldWidth = std::max(0.05F, std::abs(transform.Scale.x) > 0.001F ? std::abs(transform.Scale.x) : uiRenderer.WorldSize.x);
|
||||
const float worldHeight = std::max(0.05F, std::abs(transform.Scale.y) > 0.001F ? std::abs(transform.Scale.y) : uiRenderer.WorldSize.y);
|
||||
float pixelsPerWorldUnit = viewportState.Height / orthographicHeight;
|
||||
if (sceneView.ProjectionMode == MetaCoreCameraProjectionMode::Perspective) {
|
||||
const float distanceAlongView = glm::dot(transform.Position - sceneView.CameraPosition, viewDirection);
|
||||
if (distanceAlongView <= sceneView.NearClip) {
|
||||
continue;
|
||||
}
|
||||
pixelsPerWorldUnit = viewportState.Height / (2.0F * distanceAlongView * std::tan(fovRadians * 0.5F));
|
||||
}
|
||||
|
||||
const float rawPreviewWidth = worldWidth * pixelsPerWorldUnit;
|
||||
const float rawPreviewHeight = worldHeight * pixelsPerWorldUnit;
|
||||
const float maxPreviewWidth = std::max(64.0F, viewportState.Width * 0.9F);
|
||||
const float maxPreviewHeight = std::max(64.0F, viewportState.Height * 0.9F);
|
||||
const float fitScale = std::min(1.0F, std::min(maxPreviewWidth / std::max(1.0F, rawPreviewWidth), maxPreviewHeight / std::max(1.0F, rawPreviewHeight)));
|
||||
const float previewWidth = std::max(24.0F, rawPreviewWidth * fitScale);
|
||||
const float previewHeight = std::max(24.0F, rawPreviewHeight * fitScale);
|
||||
const ImVec2 rectMin(centerPoint.x - previewWidth * 0.5F, centerPoint.y - previewHeight * 0.5F);
|
||||
const ImVec2 rectMax(rectMin.x + previewWidth, rectMin.y + previewHeight);
|
||||
const bool selected = editorContext.GetSelectedObjectId() == gameObject.GetId();
|
||||
const ImU32 fillColor = selected ? IM_COL32(44, 136, 110, 48) : IM_COL32(44, 136, 110, 30);
|
||||
const ImU32 strokeColor = selected ? IM_COL32(104, 224, 188, 230) : IM_COL32(104, 224, 188, 150);
|
||||
|
||||
drawList->AddRectFilled(rectMin, rectMax, fillColor, 4.0F);
|
||||
drawList->AddRect(rectMin, rectMax, strokeColor, 4.0F, 0, selected ? 2.0F : 1.2F);
|
||||
|
||||
const std::optional<MetaCoreUiDocument> document = MetaCoreLoadUiPreviewDocument(editorContext, uiRenderer);
|
||||
if (document.has_value()) {
|
||||
MetaCoreDrawUiDocumentPreview(*drawList, *document, rectMin, ImVec2(previewWidth, previewHeight));
|
||||
} else {
|
||||
drawList->AddText(ImVec2(rectMin.x + 8.0F, rectMin.y + 27.0F), IM_COL32(255, 196, 120, 230), "未能读取 UI 文档");
|
||||
}
|
||||
|
||||
const std::string label = "3D UI: " + gameObject.GetName();
|
||||
drawList->AddText(ImVec2(rectMin.x + 8.0F, rectMin.y + 7.0F), strokeColor, label.c_str());
|
||||
drawList->AddCircleFilled(centerPoint, 3.0F, strokeColor, 12);
|
||||
}
|
||||
|
||||
drawList->PopClipRect();
|
||||
}
|
||||
|
||||
void MetaCoreDrawSelectionGroupCenterOverlay(
|
||||
const MetaCoreEditorContext& editorContext,
|
||||
const MetaCoreScene& scene,
|
||||
@ -1687,6 +2011,8 @@ void MetaCoreEditorApp::DrawEditorFrame() {
|
||||
MetaCoreDrawWorldOriginOverlay(*EditorContext_, sceneView, viewportState);
|
||||
MetaCoreDrawSelectionBoundsOverlay(*EditorContext_, Scene_, sceneView, viewportState);
|
||||
MetaCoreDrawSelectionHierarchyOverlay(*EditorContext_, Scene_, sceneView, viewportState);
|
||||
MetaCoreDrawScreenSpaceUiPreviewOverlay(*EditorContext_, Scene_, viewportState);
|
||||
MetaCoreDrawWorldSpaceUiPreviewOverlay(*EditorContext_, Scene_, sceneView, viewportState);
|
||||
}
|
||||
|
||||
// 启用资产拖拽到 3D 场景视口的高亮响应遮罩，并显示操作提示
|
||||
|
||||
@ -171,6 +171,21 @@ private:
|
||||
return false;
|
||||
}
|
||||
|
||||
if (lhs.UiRenderer.has_value() != rhs.UiRenderer.has_value()) {
|
||||
return false;
|
||||
}
|
||||
if (lhs.UiRenderer.has_value()) {
|
||||
if (lhs.UiRenderer->UiDocumentAssetGuid != rhs.UiRenderer->UiDocumentAssetGuid ||
|
||||
lhs.UiRenderer->RenderMode != rhs.UiRenderer->RenderMode ||
|
||||
lhs.UiRenderer->Visible != rhs.UiRenderer->Visible ||
|
||||
lhs.UiRenderer->InputEnabled != rhs.UiRenderer->InputEnabled ||
|
||||
lhs.UiRenderer->Layer != rhs.UiRenderer->Layer ||
|
||||
!MetaCoreNearlyEqual(lhs.UiRenderer->PixelsPerUnit, rhs.UiRenderer->PixelsPerUnit) ||
|
||||
!MetaCoreNearlyEqualVec3(lhs.UiRenderer->WorldSize, rhs.UiRenderer->WorldSize)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -226,6 +241,7 @@ private:
|
||||
document.DataSourcesPath = std::filesystem::path("Runtime") / "DataSources.mcruntime";
|
||||
document.BindingsPath = std::filesystem::path("Runtime") / "Bindings.mcruntime";
|
||||
document.DiagnosticsPath = std::filesystem::path("Runtime") / "Diagnostics.mcruntimestate";
|
||||
document.UiManifestPath = std::filesystem::path("Runtime") / "Ui.mcruntime";
|
||||
return document;
|
||||
}
|
||||
|
||||
@ -579,12 +595,27 @@ bool MetaCoreEditorContext::EnsureRuntimeDataConfigLoaded() {
|
||||
runtimeDirectory / "Bindings.mcruntime",
|
||||
runtimeRegistry
|
||||
);
|
||||
const auto loadedUiManifest = MetaCoreReadRuntimeUiManifest(
|
||||
runtimeDirectory / "Ui.mcruntime",
|
||||
runtimeRegistry
|
||||
);
|
||||
|
||||
RuntimeDataSourcesDocument_ = loadedSources.value_or(MetaCoreRuntimeDataSourcesDocument{});
|
||||
RuntimeBindingsDocument_ = loadedBindings.value_or(MetaCoreRuntimeBindingsDocument{});
|
||||
RuntimeUiManifestDocument_ = loadedUiManifest.value_or(MetaCoreRuntimeUiManifest{});
|
||||
if (!loadedUiManifest.has_value() &&
|
||||
std::filesystem::exists(assetDatabaseService->GetProjectDescriptor().UiPath / "Hud.rml")) {
|
||||
RuntimeUiManifestDocument_.Documents.push_back(MetaCoreRuntimeUiDocumentEntry{
|
||||
"hud",
|
||||
std::filesystem::path("Hud.rml"),
|
||||
0,
|
||||
true,
|
||||
true
|
||||
});
|
||||
}
|
||||
RuntimeDataConfigLoaded_ = true;
|
||||
|
||||
if (!loadedSources.has_value() || !loadedBindings.has_value()) {
|
||||
if (!loadedSources.has_value() || !loadedBindings.has_value() || !loadedUiManifest.has_value()) {
|
||||
AddConsoleMessage(MetaCoreLogLevel::Info, "RuntimeData", "Runtime config not found, using empty config");
|
||||
}
|
||||
if (!loadedProjectRuntime.has_value()) {
|
||||
@ -641,8 +672,13 @@ bool MetaCoreEditorContext::SaveRuntimeDataConfig() {
|
||||
RuntimeBindingsDocument_,
|
||||
runtimeRegistry
|
||||
);
|
||||
const bool wroteUiManifest = MetaCoreWriteRuntimeUiManifest(
|
||||
runtimeDirectory / "Ui.mcruntime",
|
||||
RuntimeUiManifestDocument_,
|
||||
runtimeRegistry
|
||||
);
|
||||
|
||||
if (!wroteProjectRuntime || !wroteSources || !wroteBindings) {
|
||||
if (!wroteProjectRuntime || !wroteSources || !wroteBindings || !wroteUiManifest) {
|
||||
AddConsoleMessage(MetaCoreLogLevel::Error, "RuntimeData", "保存 Runtime 配置失败");
|
||||
return false;
|
||||
}
|
||||
@ -659,6 +695,10 @@ MetaCoreRuntimeBindingsDocument& MetaCoreEditorContext::AccessRuntimeBindingsDoc
|
||||
return RuntimeBindingsDocument_;
|
||||
}
|
||||
|
||||
MetaCoreRuntimeUiManifest& MetaCoreEditorContext::AccessRuntimeUiManifestDocument() {
|
||||
return RuntimeUiManifestDocument_;
|
||||
}
|
||||
|
||||
const MetaCoreRuntimeDataSourcesDocument& MetaCoreEditorContext::GetRuntimeDataSourcesDocument() const {
|
||||
return RuntimeDataSourcesDocument_;
|
||||
}
|
||||
|
||||
@ -173,6 +173,7 @@ public:
|
||||
[[nodiscard]] bool SaveRuntimeDataConfig();
|
||||
[[nodiscard]] MetaCoreRuntimeDataSourcesDocument& AccessRuntimeDataSourcesDocument();
|
||||
[[nodiscard]] MetaCoreRuntimeBindingsDocument& AccessRuntimeBindingsDocument();
|
||||
[[nodiscard]] MetaCoreRuntimeUiManifest& AccessRuntimeUiManifestDocument();
|
||||
[[nodiscard]] const MetaCoreRuntimeDataSourcesDocument& GetRuntimeDataSourcesDocument() const;
|
||||
[[nodiscard]] const MetaCoreRuntimeBindingsDocument& GetRuntimeBindingsDocument() const;
|
||||
[[nodiscard]] bool HasSelectedAsset() const;
|
||||
@ -216,6 +217,7 @@ private:
|
||||
bool RuntimeDataConfigLoaded_ = false;
|
||||
MetaCoreRuntimeDataSourcesDocument RuntimeDataSourcesDocument_{};
|
||||
MetaCoreRuntimeBindingsDocument RuntimeBindingsDocument_{};
|
||||
MetaCoreRuntimeUiManifest RuntimeUiManifestDocument_{};
|
||||
MetaCoreSelectedAssetState SelectedAsset_{};
|
||||
std::filesystem::path SelectedProjectDirectory_{"Assets"};
|
||||
std::string SelectedAssetSubId_{};
|
||||
|
||||
@ -212,6 +212,7 @@ class MetaCoreICookService : public MetaCoreIEditorService {
|
||||
public:
|
||||
[[nodiscard]] virtual bool CookAsset(const MetaCoreAssetGuid& assetGuid) = 0;
|
||||
[[nodiscard]] virtual bool CookScene(const std::filesystem::path& relativeScenePath) = 0;
|
||||
[[nodiscard]] virtual bool CookRuntimeUiAssets() = 0;
|
||||
[[nodiscard]] virtual std::filesystem::path GetCookedPathForAsset(const MetaCoreAssetGuid& assetGuid) const = 0;
|
||||
};
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
#include <system_error>
|
||||
#include <regex>
|
||||
#include <sstream>
|
||||
#include <string_view>
|
||||
|
||||
namespace MetaCore {
|
||||
|
||||
@ -103,6 +104,21 @@ namespace {
|
||||
return absoluteRoot.lexically_normal();
|
||||
}
|
||||
|
||||
[[nodiscard]] bool MetaCoreWriteTextFileIfMissing(
|
||||
const std::filesystem::path& path,
|
||||
std::string_view contents
|
||||
) {
|
||||
if (std::filesystem::exists(path)) {
|
||||
return true;
|
||||
}
|
||||
std::ofstream output(path, std::ios::binary);
|
||||
if (!output.is_open()) {
|
||||
return false;
|
||||
}
|
||||
output.write(contents.data(), static_cast<std::streamsize>(contents.size()));
|
||||
return output.good();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
std::filesystem::path MetaCoreGetProjectFilePath(const std::filesystem::path& projectRoot) {
|
||||
@ -166,6 +182,44 @@ bool MetaCoreCreateProjectSkeleton(
|
||||
}
|
||||
}
|
||||
|
||||
constexpr std::string_view defaultHudRml = R"rml(<rml>
|
||||
<head>
|
||||
<link type="text/rcss" href="Hud.rcss" />
|
||||
</head>
|
||||
<body>
|
||||
<div id="hud">
|
||||
<div class="title">MetaCore Runtime</div>
|
||||
<div class="row">Cube: <span data-metacore-bind="cube.position" data-metacore-format="2">0, 0, 0</span></div>
|
||||
<button id="runtime-action" data-metacore-action="hud.primary">Action</button>
|
||||
<input id="runtime-input" type="text" value="" />
|
||||
</div>
|
||||
</body>
|
||||
</rml>
|
||||
)rml";
|
||||
constexpr std::string_view defaultHudRcss = R"rcss(body {
|
||||
margin: 0;
|
||||
font-family: sans-serif;
|
||||
color: #f2f4f8;
|
||||
}
|
||||
#hud {
|
||||
position: absolute;
|
||||
left: 24dp;
|
||||
top: 24dp;
|
||||
width: 300dp;
|
||||
padding: 14dp;
|
||||
background-color: #17202bcc;
|
||||
border: 1dp solid #4f6b88;
|
||||
}
|
||||
.title { font-size: 20dp; margin-bottom: 10dp; }
|
||||
.row { margin-bottom: 12dp; }
|
||||
button { padding: 7dp 12dp; margin-right: 8dp; background-color: #386ea5; color: #ffffff; }
|
||||
input { width: 150dp; padding: 6dp; background-color: #0f1720; color: #ffffff; }
|
||||
)rcss";
|
||||
if (!MetaCoreWriteTextFileIfMissing(normalizedRoot / "Ui" / "Hud.rml", defaultHudRml) ||
|
||||
!MetaCoreWriteTextFileIfMissing(normalizedRoot / "Ui" / "Hud.rcss", defaultHudRcss)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
MetaCoreProjectFileDocument document;
|
||||
if (!projectName.empty()) {
|
||||
document.Name = std::string(projectName);
|
||||
|
||||
@ -8,6 +8,8 @@ void MetaCoreInput::BeginFrame() {
|
||||
PreviousCursorPosition_ = CursorPosition_;
|
||||
CursorDelta_ = glm::vec2(0.0F, 0.0F);
|
||||
MouseWheelDelta_ = 0.0F;
|
||||
KeyEvents_.clear();
|
||||
TextInput_.clear();
|
||||
}
|
||||
|
||||
void MetaCoreInput::SetKeyState(MetaCoreInputKey key, bool isDown) {
|
||||
@ -27,6 +29,14 @@ void MetaCoreInput::AddMouseWheelDelta(float delta) {
|
||||
MouseWheelDelta_ += delta;
|
||||
}
|
||||
|
||||
void MetaCoreInput::AddKeyEvent(MetaCoreKeyEvent event) {
|
||||
KeyEvents_.push_back(event);
|
||||
}
|
||||
|
||||
void MetaCoreInput::AddTextInput(char32_t codePoint) {
|
||||
TextInput_.push_back(codePoint);
|
||||
}
|
||||
|
||||
bool MetaCoreInput::IsKeyDown(MetaCoreInputKey key) const {
|
||||
return CurrentKeyStates_[static_cast<std::size_t>(key)];
|
||||
}
|
||||
@ -45,6 +55,11 @@ bool MetaCoreInput::WasMouseButtonPressed(MetaCoreMouseButton button) const {
|
||||
return CurrentMouseStates_[buttonIndex] && !PreviousMouseStates_[buttonIndex];
|
||||
}
|
||||
|
||||
bool MetaCoreInput::WasMouseButtonReleased(MetaCoreMouseButton button) const {
|
||||
const std::size_t buttonIndex = static_cast<std::size_t>(button);
|
||||
return !CurrentMouseStates_[buttonIndex] && PreviousMouseStates_[buttonIndex];
|
||||
}
|
||||
|
||||
float MetaCoreInput::GetMouseWheelDelta() const {
|
||||
return MouseWheelDelta_;
|
||||
}
|
||||
@ -57,4 +72,16 @@ const glm::vec2& MetaCoreInput::GetCursorDelta() const {
|
||||
return CursorDelta_;
|
||||
}
|
||||
|
||||
std::vector<MetaCoreKeyEvent> MetaCoreInput::ConsumeKeyEvents() {
|
||||
std::vector<MetaCoreKeyEvent> events;
|
||||
events.swap(KeyEvents_);
|
||||
return events;
|
||||
}
|
||||
|
||||
std::vector<char32_t> MetaCoreInput::ConsumeTextInput() {
|
||||
std::vector<char32_t> text;
|
||||
text.swap(TextInput_);
|
||||
return text;
|
||||
}
|
||||
|
||||
} // namespace MetaCore
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <ctime>
|
||||
#include <exception>
|
||||
#include <filesystem>
|
||||
@ -79,10 +80,84 @@ std::wstring MetaCoreUtf8ToWide(std::string_view utf8Text) {
|
||||
return wideText;
|
||||
}
|
||||
|
||||
std::string MetaCoreWideToUtf8(std::wstring_view wideText) {
|
||||
if (wideText.empty()) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const int requiredLength = WideCharToMultiByte(
|
||||
CP_UTF8,
|
||||
0,
|
||||
wideText.data(),
|
||||
static_cast<int>(wideText.size()),
|
||||
nullptr,
|
||||
0,
|
||||
nullptr,
|
||||
nullptr
|
||||
);
|
||||
if (requiredLength <= 0) {
|
||||
return std::string(wideText.begin(), wideText.end());
|
||||
}
|
||||
|
||||
std::string utf8Text(static_cast<std::size_t>(requiredLength), '\0');
|
||||
const int writtenLength = WideCharToMultiByte(
|
||||
CP_UTF8,
|
||||
0,
|
||||
wideText.data(),
|
||||
static_cast<int>(wideText.size()),
|
||||
utf8Text.data(),
|
||||
requiredLength,
|
||||
nullptr,
|
||||
nullptr
|
||||
);
|
||||
if (writtenLength <= 0) {
|
||||
return std::string(wideText.begin(), wideText.end());
|
||||
}
|
||||
return utf8Text;
|
||||
}
|
||||
|
||||
bool MetaCoreIsVirtualKeyDown(int virtualKey) {
|
||||
return (GetAsyncKeyState(virtualKey) & 0x8000) != 0;
|
||||
}
|
||||
|
||||
int MetaCoreGetWin32InputModifiers() {
|
||||
int modifiers = 0;
|
||||
if (MetaCoreIsVirtualKeyDown(VK_SHIFT)) modifiers |= 0x0001;
|
||||
if (MetaCoreIsVirtualKeyDown(VK_CONTROL)) modifiers |= 0x0002;
|
||||
if (MetaCoreIsVirtualKeyDown(VK_MENU)) modifiers |= 0x0004;
|
||||
if (MetaCoreIsVirtualKeyDown(VK_LWIN) || MetaCoreIsVirtualKeyDown(VK_RWIN)) modifiers |= 0x0008;
|
||||
return modifiers;
|
||||
}
|
||||
|
||||
int MetaCoreMapVirtualKeyToRuntimeKey(WPARAM virtualKey) {
|
||||
if (virtualKey >= '0' && virtualKey <= '9') return static_cast<int>(virtualKey);
|
||||
if (virtualKey >= 'A' && virtualKey <= 'Z') return static_cast<int>(virtualKey);
|
||||
switch (virtualKey) {
|
||||
case VK_SPACE: return 32;
|
||||
case VK_ESCAPE: return 256;
|
||||
case VK_RETURN: return 257;
|
||||
case VK_TAB: return 258;
|
||||
case VK_BACK: return 259;
|
||||
case VK_INSERT: return 260;
|
||||
case VK_DELETE: return 261;
|
||||
case VK_RIGHT: return 262;
|
||||
case VK_LEFT: return 263;
|
||||
case VK_DOWN: return 264;
|
||||
case VK_UP: return 265;
|
||||
case VK_PRIOR: return 266;
|
||||
case VK_NEXT: return 267;
|
||||
case VK_HOME: return 268;
|
||||
case VK_END: return 269;
|
||||
case VK_LSHIFT: return 340;
|
||||
case VK_LCONTROL: return 341;
|
||||
case VK_LMENU: return 342;
|
||||
case VK_RSHIFT: return 344;
|
||||
case VK_RCONTROL: return 345;
|
||||
case VK_RMENU: return 346;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
std::unordered_map<HWND, class MetaCoreWindow::MetaCoreWindowImpl*>& MetaCoreGetWindowMap() {
|
||||
static std::unordered_map<HWND, class MetaCoreWindow::MetaCoreWindowImpl*> windowMap;
|
||||
return windowMap;
|
||||
@ -130,6 +205,21 @@ LRESULT CALLBACK MetaCoreWindowSubclassProc(HWND hwnd, UINT msg, WPARAM wparam,
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN || msg == WM_KEYUP || msg == WM_SYSKEYUP) {
|
||||
const int key = MetaCoreMapVirtualKeyToRuntimeKey(wparam);
|
||||
if (key != 0) {
|
||||
owner.Input.AddKeyEvent(MetaCoreKeyEvent{
|
||||
key,
|
||||
msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN,
|
||||
MetaCoreGetWin32InputModifiers()
|
||||
});
|
||||
}
|
||||
} else if (msg == WM_CHAR) {
|
||||
if (wparam >= 0x20 && wparam != 0x7F) {
|
||||
owner.Input.AddTextInput(static_cast<char32_t>(wparam));
|
||||
}
|
||||
}
|
||||
|
||||
bool handledByEditor = false;
|
||||
if (owner.MessageHandler) {
|
||||
handledByEditor = owner.MessageHandler(hwnd, msg, static_cast<std::uintptr_t>(wparam), static_cast<std::intptr_t>(lparam));
|
||||
@ -341,6 +431,46 @@ std::vector<std::filesystem::path> MetaCoreWindow::ConsumeDroppedFiles() {
|
||||
return droppedFiles;
|
||||
}
|
||||
|
||||
std::string MetaCoreWindow::GetClipboardText() const {
|
||||
if (Impl_->NativeHandle == nullptr || OpenClipboard(Impl_->NativeHandle) == FALSE) {
|
||||
return {};
|
||||
}
|
||||
|
||||
std::string result;
|
||||
HANDLE clipboardData = GetClipboardData(CF_UNICODETEXT);
|
||||
if (clipboardData != nullptr) {
|
||||
const auto* wideText = static_cast<const wchar_t*>(GlobalLock(clipboardData));
|
||||
if (wideText != nullptr) {
|
||||
result = MetaCoreWideToUtf8(wideText);
|
||||
GlobalUnlock(clipboardData);
|
||||
}
|
||||
}
|
||||
CloseClipboard();
|
||||
return result;
|
||||
}
|
||||
|
||||
void MetaCoreWindow::SetClipboardText(const std::string& text) {
|
||||
if (Impl_->NativeHandle == nullptr || OpenClipboard(Impl_->NativeHandle) == FALSE) {
|
||||
return;
|
||||
}
|
||||
|
||||
const std::wstring wideText = MetaCoreUtf8ToWide(text);
|
||||
const std::size_t byteCount = (wideText.size() + 1U) * sizeof(wchar_t);
|
||||
HGLOBAL memory = GlobalAlloc(GMEM_MOVEABLE, byteCount);
|
||||
if (memory != nullptr) {
|
||||
void* buffer = GlobalLock(memory);
|
||||
if (buffer != nullptr) {
|
||||
std::memcpy(buffer, wideText.c_str(), byteCount);
|
||||
GlobalUnlock(memory);
|
||||
EmptyClipboard();
|
||||
SetClipboardData(CF_UNICODETEXT, memory);
|
||||
memory = nullptr;
|
||||
}
|
||||
}
|
||||
if (memory != nullptr) GlobalFree(memory);
|
||||
CloseClipboard();
|
||||
}
|
||||
|
||||
void MetaCoreWindow::SetNativeWindowMessageHandler(MetaCoreNativeWindowMessageHandler handler) {
|
||||
Impl_->MessageHandler = std::move(handler);
|
||||
}
|
||||
|
||||
@ -97,6 +97,20 @@ void MetaCoreGlfwDropCallback(GLFWwindow* window, int count, const char** paths)
|
||||
}
|
||||
}
|
||||
|
||||
void MetaCoreGlfwKeyCallback(GLFWwindow* window, int key, int, int action, int modifiers) {
|
||||
if (auto* owner = MetaCoreGetWindowImpl(window); owner != nullptr) {
|
||||
if (action == GLFW_PRESS || action == GLFW_REPEAT || action == GLFW_RELEASE) {
|
||||
owner->Input.AddKeyEvent({key, action != GLFW_RELEASE, modifiers});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MetaCoreGlfwCharacterCallback(GLFWwindow* window, unsigned int codePoint) {
|
||||
if (auto* owner = MetaCoreGetWindowImpl(window); owner != nullptr) {
|
||||
owner->Input.AddTextInput(static_cast<char32_t>(codePoint));
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
MetaCoreWindow::MetaCoreWindow()
|
||||
@ -132,6 +146,8 @@ bool MetaCoreWindow::Initialize(int width, int height, const std::string& title)
|
||||
glfwSetWindowCloseCallback(Impl_->NativeHandle, MetaCoreGlfwWindowCloseCallback);
|
||||
glfwSetScrollCallback(Impl_->NativeHandle, MetaCoreGlfwScrollCallback);
|
||||
glfwSetDropCallback(Impl_->NativeHandle, MetaCoreGlfwDropCallback);
|
||||
glfwSetKeyCallback(Impl_->NativeHandle, MetaCoreGlfwKeyCallback);
|
||||
glfwSetCharCallback(Impl_->NativeHandle, MetaCoreGlfwCharacterCallback);
|
||||
Impl_->CloseRequested = false;
|
||||
Impl_->LastFrameTime = std::chrono::steady_clock::now();
|
||||
Impl_->Initialized = true;
|
||||
@ -154,6 +170,8 @@ bool MetaCoreWindow::Initialize(int width, int height, const std::string& title)
|
||||
void MetaCoreWindow::Shutdown() {
|
||||
if (Impl_->NativeHandle != nullptr) {
|
||||
glfwSetDropCallback(Impl_->NativeHandle, nullptr);
|
||||
glfwSetKeyCallback(Impl_->NativeHandle, nullptr);
|
||||
glfwSetCharCallback(Impl_->NativeHandle, nullptr);
|
||||
glfwSetWindowUserPointer(Impl_->NativeHandle, nullptr);
|
||||
glfwDestroyWindow(Impl_->NativeHandle);
|
||||
Impl_->NativeHandle = nullptr;
|
||||
@ -271,6 +289,16 @@ std::vector<std::filesystem::path> MetaCoreWindow::ConsumeDroppedFiles() {
|
||||
return droppedFiles;
|
||||
}
|
||||
|
||||
std::string MetaCoreWindow::GetClipboardText() const {
|
||||
if (Impl_->NativeHandle == nullptr) return {};
|
||||
const char* text = glfwGetClipboardString(Impl_->NativeHandle);
|
||||
return text != nullptr ? std::string(text) : std::string{};
|
||||
}
|
||||
|
||||
void MetaCoreWindow::SetClipboardText(const std::string& text) {
|
||||
if (Impl_->NativeHandle != nullptr) glfwSetClipboardString(Impl_->NativeHandle, text.c_str());
|
||||
}
|
||||
|
||||
void MetaCoreWindow::SetNativeWindowMessageHandler(MetaCoreNativeWindowMessageHandler handler) {
|
||||
Impl_->MessageHandler = std::move(handler);
|
||||
}
|
||||
|
||||
@ -4,6 +4,9 @@
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace MetaCore {
|
||||
|
||||
@ -29,6 +32,12 @@ enum class MetaCoreMouseButton : unsigned int {
|
||||
Count
|
||||
};
|
||||
|
||||
struct MetaCoreKeyEvent {
|
||||
int Key = 0;
|
||||
bool Pressed = false;
|
||||
int Modifiers = 0;
|
||||
};
|
||||
|
||||
class MetaCoreInput {
|
||||
public:
|
||||
void BeginFrame();
|
||||
@ -36,14 +45,19 @@ public:
|
||||
void SetMouseButtonState(MetaCoreMouseButton button, bool isDown);
|
||||
void SetCursorPosition(const glm::vec2& cursorPosition);
|
||||
void AddMouseWheelDelta(float delta);
|
||||
void AddKeyEvent(MetaCoreKeyEvent event);
|
||||
void AddTextInput(char32_t codePoint);
|
||||
|
||||
[[nodiscard]] bool IsKeyDown(MetaCoreInputKey key) const;
|
||||
[[nodiscard]] bool WasKeyPressed(MetaCoreInputKey key) const;
|
||||
[[nodiscard]] bool IsMouseButtonDown(MetaCoreMouseButton button) const;
|
||||
[[nodiscard]] bool WasMouseButtonPressed(MetaCoreMouseButton button) const;
|
||||
[[nodiscard]] bool WasMouseButtonReleased(MetaCoreMouseButton button) const;
|
||||
[[nodiscard]] float GetMouseWheelDelta() const;
|
||||
[[nodiscard]] const glm::vec2& GetCursorPosition() const;
|
||||
[[nodiscard]] const glm::vec2& GetCursorDelta() const;
|
||||
[[nodiscard]] std::vector<MetaCoreKeyEvent> ConsumeKeyEvents();
|
||||
[[nodiscard]] std::vector<char32_t> ConsumeTextInput();
|
||||
|
||||
private:
|
||||
static constexpr std::size_t KeyCount_ = static_cast<std::size_t>(MetaCoreInputKey::Count);
|
||||
@ -57,6 +71,8 @@ private:
|
||||
glm::vec2 PreviousCursorPosition_{0.0F, 0.0F};
|
||||
glm::vec2 CursorDelta_{0.0F, 0.0F};
|
||||
float MouseWheelDelta_ = 0.0F;
|
||||
std::vector<MetaCoreKeyEvent> KeyEvents_{};
|
||||
std::vector<char32_t> TextInput_{};
|
||||
};
|
||||
|
||||
} // namespace MetaCore
|
||||
|
||||
@ -39,6 +39,8 @@ public:
|
||||
[[nodiscard]] std::pair<int, int> GetWindowSize() const;
|
||||
[[nodiscard]] std::pair<int, int> GetFramebufferSize() const;
|
||||
[[nodiscard]] std::vector<std::filesystem::path> ConsumeDroppedFiles();
|
||||
[[nodiscard]] std::string GetClipboardText() const;
|
||||
void SetClipboardText(const std::string& text);
|
||||
|
||||
void SetNativeWindowMessageHandler(MetaCoreNativeWindowMessageHandler handler);
|
||||
|
||||
|
||||
@ -131,6 +131,12 @@ void MetaCoreEditorViewportRenderer::SetEditorGridVisible(bool visible) {
|
||||
FilamentSceneBridge_.SetEditorGridVisible(visible);
|
||||
}
|
||||
|
||||
void MetaCoreEditorViewportRenderer::SetRuntimeOverlayRenderCallback(
|
||||
MetaCoreFilamentSceneBridge::RuntimeOverlayRenderCallback callback
|
||||
) {
|
||||
FilamentSceneBridge_.SetRuntimeOverlayRenderCallback(std::move(callback));
|
||||
}
|
||||
|
||||
uint32_t MetaCoreEditorViewportRenderer::GetFilamentGLTextureId() const {
|
||||
return FilamentSceneBridge_.GetGLTextureId();
|
||||
}
|
||||
|
||||
@ -446,6 +446,10 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
void SetRuntimeOverlayRenderCallback(MetaCoreFilamentSceneBridge::RuntimeOverlayRenderCallback callback) {
|
||||
RuntimeOverlayRenderCallback_ = std::move(callback);
|
||||
}
|
||||
|
||||
[[nodiscard]] bool VerifyEditorGridVisibleForTesting() const {
|
||||
return EditorGridEntityInScene_ && EditorGridAxisEntityInScene_;
|
||||
}
|
||||
@ -722,20 +726,28 @@ public:
|
||||
[[nodiscard]] filament::Texture* LoadKtx1Texture(
|
||||
const std::filesystem::path& path,
|
||||
bool srgb,
|
||||
filament::math::float3* outSphericalHarmonics = nullptr
|
||||
) const {
|
||||
filament::math::float3* outSphericalHarmonics = nullptr,
|
||||
std::vector<std::uint8_t>* retainedBytes = nullptr
|
||||
) {
|
||||
if (Engine_ == nullptr || path.empty()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const auto bytes = ReadBinaryFile(path);
|
||||
auto bytes = ReadBinaryFile(path);
|
||||
if (!bytes.has_value()) {
|
||||
return nullptr;
|
||||
}
|
||||
const std::uint8_t* data = bytes->data();
|
||||
std::uint32_t size = static_cast<std::uint32_t>(bytes->size());
|
||||
if (retainedBytes != nullptr) {
|
||||
*retainedBytes = std::move(*bytes);
|
||||
data = retainedBytes->data();
|
||||
size = static_cast<std::uint32_t>(retainedBytes->size());
|
||||
}
|
||||
|
||||
auto bundle = std::make_unique<ktxreader::Ktx1Bundle>(
|
||||
bytes->data(),
|
||||
static_cast<std::uint32_t>(bytes->size())
|
||||
data,
|
||||
size
|
||||
);
|
||||
if (outSphericalHarmonics != nullptr) {
|
||||
if (!bundle->getSphericalHarmonics(outSphericalHarmonics)) {
|
||||
@ -743,7 +755,17 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
return ktxreader::Ktx1Reader::createTexture(Engine_, bundle.release(), srgb);
|
||||
filament::Texture* texture = ktxreader::Ktx1Reader::createTexture(Engine_, bundle.release(), srgb);
|
||||
if (texture != nullptr) {
|
||||
// Ktx1Bundle references the supplied bytes while Filament queues backend uploads.
|
||||
// Keep environment KTX payloads alive alongside their textures, and also flush
|
||||
// here for temporary callers.
|
||||
Engine_->flushAndWait();
|
||||
}
|
||||
if (texture == nullptr && retainedBytes != nullptr) {
|
||||
retainedBytes->clear();
|
||||
}
|
||||
return texture;
|
||||
}
|
||||
|
||||
[[nodiscard]] static bool IsSafeProjectRelativeKtxPath(const std::filesystem::path& path) {
|
||||
@ -864,9 +886,11 @@ public:
|
||||
const std::filesystem::path& iblPath,
|
||||
const std::filesystem::path& skyboxPath
|
||||
) {
|
||||
EnvironmentIblKtxBytes_.clear();
|
||||
EnvironmentSkyboxKtxBytes_.clear();
|
||||
filament::math::float3 sphericalHarmonics[9]{};
|
||||
EnvironmentIblTexture_ = LoadKtx1Texture(iblPath, false, sphericalHarmonics);
|
||||
EnvironmentSkyboxTexture_ = LoadKtx1Texture(skyboxPath, false);
|
||||
EnvironmentIblTexture_ = LoadKtx1Texture(iblPath, false, sphericalHarmonics, &EnvironmentIblKtxBytes_);
|
||||
EnvironmentSkyboxTexture_ = LoadKtx1Texture(skyboxPath, false, nullptr, &EnvironmentSkyboxKtxBytes_);
|
||||
if (EnvironmentIblTexture_ == nullptr || EnvironmentSkyboxTexture_ == nullptr) {
|
||||
return false;
|
||||
}
|
||||
@ -1013,6 +1037,8 @@ public:
|
||||
EnvironmentIblTexture_ = nullptr;
|
||||
}
|
||||
}
|
||||
EnvironmentIblKtxBytes_.clear();
|
||||
EnvironmentSkyboxKtxBytes_.clear();
|
||||
EnvironmentLoaded_ = false;
|
||||
EnvironmentBackgroundVisible_ = false;
|
||||
LoadedEnvironmentIblPath_.clear();
|
||||
@ -2243,6 +2269,10 @@ public:
|
||||
} else {
|
||||
// 3. 直接上屏渲染
|
||||
renderScenePass(false);
|
||||
if (RuntimeOverlayRenderCallback_) {
|
||||
const auto viewport = View_->getViewport();
|
||||
RuntimeOverlayRenderCallback_(*Engine_, *Renderer_, viewport.width, viewport.height);
|
||||
}
|
||||
}
|
||||
|
||||
Renderer_->endFrame();
|
||||
@ -3328,6 +3358,8 @@ private:
|
||||
MetaCoreSceneEnvironmentSettings ActiveEnvironmentSettings_{};
|
||||
std::filesystem::path LoadedEnvironmentIblPath_{};
|
||||
std::filesystem::path LoadedEnvironmentSkyboxPath_{};
|
||||
std::vector<std::uint8_t> EnvironmentIblKtxBytes_{};
|
||||
std::vector<std::uint8_t> EnvironmentSkyboxKtxBytes_{};
|
||||
std::string LastEnvironmentValidationFailure_{};
|
||||
glm::mat4 CameraModelMatrix_{1.0F};
|
||||
|
||||
@ -3365,6 +3397,7 @@ private:
|
||||
|
||||
filament::View* UIView_ = nullptr;
|
||||
MetaCoreImGuiHelper* ImGuiHelper_ = nullptr;
|
||||
MetaCoreFilamentSceneBridge::RuntimeOverlayRenderCallback RuntimeOverlayRenderCallback_{};
|
||||
|
||||
GLuint GLTextureId_ = 0;
|
||||
struct PendingRenderTargetResource {
|
||||
@ -3420,6 +3453,10 @@ void MetaCoreFilamentSceneBridge::SetEditorGridVisible(bool visible) {
|
||||
Impl_->SetEditorGridVisible(visible);
|
||||
}
|
||||
|
||||
void MetaCoreFilamentSceneBridge::SetRuntimeOverlayRenderCallback(RuntimeOverlayRenderCallback callback) {
|
||||
Impl_->SetRuntimeOverlayRenderCallback(std::move(callback));
|
||||
}
|
||||
|
||||
void MetaCoreFilamentSceneBridge::RenderAll() {
|
||||
Impl_->RenderAll();
|
||||
}
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
#include <imgui.h>
|
||||
|
||||
@ -100,10 +102,18 @@ void MetaCoreImGuiHelper::createAtlasTexture(Engine* engine) {
|
||||
int width, height;
|
||||
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
|
||||
size_t size = (size_t) (width * height * 4);
|
||||
void* uploadPixels = std::malloc(size);
|
||||
if (uploadPixels == nullptr) {
|
||||
return;
|
||||
}
|
||||
std::memcpy(uploadPixels, pixels, size);
|
||||
|
||||
Texture::PixelBufferDescriptor pb(
|
||||
pixels, size,
|
||||
Texture::Format::RGBA, Texture::Type::UBYTE);
|
||||
uploadPixels, size,
|
||||
Texture::Format::RGBA, Texture::Type::UBYTE,
|
||||
[](void* buffer, size_t, void*) {
|
||||
std::free(buffer);
|
||||
});
|
||||
|
||||
mTexture = Texture::Builder()
|
||||
.width((uint32_t) width)
|
||||
@ -429,11 +439,21 @@ void MetaCoreImGuiHelper::updateTexture(ImTextureData* textureData) {
|
||||
}
|
||||
}
|
||||
|
||||
const size_t uploadSize = static_cast<size_t>(textureData->GetSizeInBytes());
|
||||
void* uploadPixels = std::malloc(uploadSize);
|
||||
if (uploadPixels == nullptr) {
|
||||
return;
|
||||
}
|
||||
std::memcpy(uploadPixels, textureData->GetPixels(), uploadSize);
|
||||
|
||||
Texture::PixelBufferDescriptor pb(
|
||||
textureData->GetPixels(),
|
||||
static_cast<size_t>(textureData->GetSizeInBytes()),
|
||||
uploadPixels,
|
||||
uploadSize,
|
||||
Texture::Format::RGBA,
|
||||
Texture::Type::UBYTE);
|
||||
Texture::Type::UBYTE,
|
||||
[](void* buffer, size_t, void*) {
|
||||
std::free(buffer);
|
||||
});
|
||||
|
||||
Texture* createdTexture = Texture::Builder()
|
||||
.width(static_cast<uint32_t>(textureData->Width))
|
||||
@ -478,15 +498,25 @@ void MetaCoreImGuiHelper::updateTexture(ImTextureData* textureData) {
|
||||
}
|
||||
|
||||
for (const ImTextureRect& rect : textureData->Updates) {
|
||||
const size_t uploadSize = static_cast<size_t>(textureData->GetSizeInBytes());
|
||||
void* uploadPixels = std::malloc(uploadSize);
|
||||
if (uploadPixels == nullptr) {
|
||||
continue;
|
||||
}
|
||||
std::memcpy(uploadPixels, textureData->GetPixels(), uploadSize);
|
||||
|
||||
Texture::PixelBufferDescriptor pb(
|
||||
textureData->GetPixels(),
|
||||
static_cast<size_t>(textureData->GetSizeInBytes()),
|
||||
uploadPixels,
|
||||
uploadSize,
|
||||
Texture::Format::RGBA,
|
||||
Texture::Type::UBYTE,
|
||||
1,
|
||||
static_cast<uint32_t>(rect.x),
|
||||
static_cast<uint32_t>(rect.y),
|
||||
static_cast<uint32_t>(textureData->Width));
|
||||
static_cast<uint32_t>(textureData->Width),
|
||||
[](void* buffer, size_t, void*) {
|
||||
std::free(buffer);
|
||||
});
|
||||
texture->setImage(
|
||||
*mEngine,
|
||||
0,
|
||||
|
||||
@ -197,6 +197,43 @@ MetaCoreSceneRenderSyncSnapshot MetaCoreSceneRenderSync::BuildSnapshot(const Met
|
||||
});
|
||||
}
|
||||
|
||||
if (!gameObject.HasComponent<MetaCoreMeshRendererComponent>() &&
|
||||
gameObject.HasComponent<MetaCoreUiRendererComponent>()) {
|
||||
const auto& uiRenderer = gameObject.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (uiRenderer.Visible && uiRenderer.RenderMode == MetaCoreUiRenderMode::WorldSpace) {
|
||||
snapshot.Renderables.push_back(MetaCoreRenderSyncRenderable{
|
||||
objectId,
|
||||
parentId,
|
||||
gameObject.GetName(),
|
||||
localMatrix,
|
||||
worldMatrix,
|
||||
true,
|
||||
MetaCoreMeshSourceKind::Builtin,
|
||||
MetaCoreBuiltinMeshType::Cube,
|
||||
MetaCoreAssetGuid{},
|
||||
MetaCoreAssetGuid{},
|
||||
{},
|
||||
-1,
|
||||
objectId,
|
||||
gameObject.GetName(),
|
||||
false,
|
||||
{},
|
||||
glm::vec3(0.12F, 0.38F, 0.78F),
|
||||
0.0F,
|
||||
0.38F,
|
||||
glm::vec3(0.02F, 0.08F, 0.16F),
|
||||
MetaCoreMeshAlphaMode::Opaque,
|
||||
0.5F,
|
||||
true,
|
||||
{},
|
||||
{},
|
||||
{},
|
||||
{},
|
||||
{}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (gameObject.HasComponent<MetaCoreCameraComponent>()) {
|
||||
const auto& camera = gameObject.GetComponent<MetaCoreCameraComponent>();
|
||||
MetaCoreRenderSyncCamera syncCamera;
|
||||
|
||||
@ -24,6 +24,7 @@ public:
|
||||
void RenderAll();
|
||||
void SetProjectRootPath(const std::filesystem::path& projectRootPath);
|
||||
void SetEditorGridVisible(bool visible);
|
||||
void SetRuntimeOverlayRenderCallback(MetaCoreFilamentSceneBridge::RuntimeOverlayRenderCallback callback);
|
||||
[[nodiscard]] uint32_t GetFilamentGLTextureId() const;
|
||||
[[nodiscard]] void* GetFilamentTexturePointer() const;
|
||||
|
||||
|
||||
@ -4,10 +4,17 @@
|
||||
|
||||
#include <glm/mat4x4.hpp>
|
||||
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
namespace filament {
|
||||
class Engine;
|
||||
class Renderer;
|
||||
}
|
||||
|
||||
namespace MetaCore {
|
||||
|
||||
class MetaCoreWindow;
|
||||
@ -20,6 +27,13 @@ struct MetaCoreSceneRenderSyncSnapshot;
|
||||
*/
|
||||
class MetaCoreFilamentSceneBridge {
|
||||
public:
|
||||
using RuntimeOverlayRenderCallback = std::function<void(
|
||||
filament::Engine& engine,
|
||||
filament::Renderer& renderer,
|
||||
uint32_t width,
|
||||
uint32_t height
|
||||
)>;
|
||||
|
||||
MetaCoreFilamentSceneBridge();
|
||||
~MetaCoreFilamentSceneBridge();
|
||||
|
||||
@ -31,6 +45,7 @@ public:
|
||||
void SyncScene(const MetaCoreSceneRenderSyncSnapshot& snapshot, MetaCoreScene* scene = nullptr, bool compatibilityMeshOnly = false, bool useScenePrimaryCamera = false);
|
||||
void ApplySceneView(const MetaCoreSceneView& sceneView);
|
||||
void SetEditorGridVisible(bool visible);
|
||||
void SetRuntimeOverlayRenderCallback(RuntimeOverlayRenderCallback callback);
|
||||
void RenderAll();
|
||||
[[nodiscard]] uint32_t GetGLTextureId() const;
|
||||
[[nodiscard]] void* GetFilamentTexturePointer() const;
|
||||
|
||||
@ -89,6 +89,21 @@ std::optional<MetaCoreRuntimeBindingsDocument> MetaCoreReadRuntimeBindingsDocume
|
||||
return MetaCoreReadBinaryDocument<MetaCoreRuntimeBindingsDocument>(path, registry);
|
||||
}
|
||||
|
||||
bool MetaCoreWriteRuntimeUiManifest(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreRuntimeUiManifest& document,
|
||||
const MetaCoreTypeRegistry& registry
|
||||
) {
|
||||
return MetaCoreWriteBinaryDocument(path, document, registry);
|
||||
}
|
||||
|
||||
std::optional<MetaCoreRuntimeUiManifest> MetaCoreReadRuntimeUiManifest(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreTypeRegistry& registry
|
||||
) {
|
||||
return MetaCoreReadBinaryDocument<MetaCoreRuntimeUiManifest>(path, registry);
|
||||
}
|
||||
|
||||
bool MetaCoreWriteRuntimeProjectDocument(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreRuntimeProjectDocument& document,
|
||||
|
||||
@ -116,6 +116,37 @@ struct MetaCoreRuntimeProjectDocument {
|
||||
|
||||
MC_PROPERTY()
|
||||
std::filesystem::path DiagnosticsPath{};
|
||||
|
||||
MC_PROPERTY()
|
||||
std::filesystem::path UiManifestPath{};
|
||||
};
|
||||
|
||||
MC_STRUCT()
|
||||
struct MetaCoreRuntimeUiDocumentEntry {
|
||||
MC_GENERATED_BODY()
|
||||
|
||||
MC_PROPERTY()
|
||||
std::string DocumentId{};
|
||||
|
||||
MC_PROPERTY()
|
||||
std::filesystem::path RmlPath{};
|
||||
|
||||
MC_PROPERTY()
|
||||
std::int32_t Layer = 0;
|
||||
|
||||
MC_PROPERTY()
|
||||
bool Visible = true;
|
||||
|
||||
MC_PROPERTY()
|
||||
bool InputEnabled = true;
|
||||
};
|
||||
|
||||
MC_STRUCT()
|
||||
struct MetaCoreRuntimeUiManifest {
|
||||
MC_GENERATED_BODY()
|
||||
|
||||
MC_PROPERTY()
|
||||
std::vector<MetaCoreRuntimeUiDocumentEntry> Documents{};
|
||||
};
|
||||
|
||||
[[nodiscard]] bool MetaCoreWriteRuntimeDataSourcesDocument(
|
||||
@ -140,6 +171,17 @@ struct MetaCoreRuntimeProjectDocument {
|
||||
const MetaCoreTypeRegistry& registry
|
||||
);
|
||||
|
||||
[[nodiscard]] bool MetaCoreWriteRuntimeUiManifest(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreRuntimeUiManifest& document,
|
||||
const MetaCoreTypeRegistry& registry
|
||||
);
|
||||
|
||||
[[nodiscard]] std::optional<MetaCoreRuntimeUiManifest> MetaCoreReadRuntimeUiManifest(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreTypeRegistry& registry
|
||||
);
|
||||
|
||||
[[nodiscard]] bool MetaCoreWriteRuntimeProjectDocument(
|
||||
const std::filesystem::path& path,
|
||||
const MetaCoreRuntimeProjectDocument& document,
|
||||
|
||||
21
Source/MetaCoreRuntimeUi/Private/Materials/rml_ui.mat
Normal file
21
Source/MetaCoreRuntimeUi/Private/Materials/rml_ui.mat
Normal file
@ -0,0 +1,21 @@
|
||||
material {
|
||||
name : MetaCoreRmlUi,
|
||||
shadingModel : unlit,
|
||||
blending : transparent,
|
||||
transparency : default,
|
||||
depthWrite : false,
|
||||
depthCulling : false,
|
||||
doubleSided : true,
|
||||
requires : [ uv0, color ],
|
||||
parameters : [
|
||||
{ type : sampler2d, name : albedo }
|
||||
],
|
||||
}
|
||||
|
||||
fragment {
|
||||
void material(inout MaterialInputs material) {
|
||||
prepareMaterial(material);
|
||||
material.baseColor = texture(materialParams_albedo, getUV0()) * getColor();
|
||||
material.baseColor.rgb *= material.baseColor.a;
|
||||
}
|
||||
}
|
||||
718
Source/MetaCoreRuntimeUi/Private/MetaCoreRuntimeUiSystem.cpp
Normal file
718
Source/MetaCoreRuntimeUi/Private/MetaCoreRuntimeUiSystem.cpp
Normal file
@ -0,0 +1,718 @@
|
||||
#include "MetaCoreRuntimeUi/MetaCoreRuntimeUiSystem.h"
|
||||
|
||||
#include "MetaCorePlatform/MetaCoreInput.h"
|
||||
#include "MetaCorePlatform/MetaCoreWindow.h"
|
||||
#include "MetaCoreRender/MetaCoreEditorViewportRenderer.h"
|
||||
#include "stb/stb_image.h"
|
||||
|
||||
#include <RmlUi/Core.h>
|
||||
|
||||
#include <GLFW/glfw3.h>
|
||||
|
||||
#include <filament/Camera.h>
|
||||
#include <filament/Engine.h>
|
||||
#include <filament/IndexBuffer.h>
|
||||
#include <filament/Material.h>
|
||||
#include <filament/MaterialInstance.h>
|
||||
#include <filament/RenderableManager.h>
|
||||
#include <filament/Renderer.h>
|
||||
#include <filament/Scene.h>
|
||||
#include <filament/Texture.h>
|
||||
#include <filament/TextureSampler.h>
|
||||
#include <filament/TransformManager.h>
|
||||
#include <filament/VertexBuffer.h>
|
||||
#include <filament/View.h>
|
||||
#include <filament/Viewport.h>
|
||||
|
||||
#include <utils/EntityManager.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
#include <limits>
|
||||
#include <sstream>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace MetaCore {
|
||||
|
||||
namespace {
|
||||
|
||||
[[nodiscard]] bool IsPathInsideRoot(const std::filesystem::path& root, const std::filesystem::path& candidate) {
|
||||
std::error_code error;
|
||||
const std::filesystem::path canonicalRoot = std::filesystem::weakly_canonical(root, error);
|
||||
if (error) return false;
|
||||
const std::filesystem::path canonicalCandidate = std::filesystem::weakly_canonical(candidate, error);
|
||||
if (error) return false;
|
||||
const std::filesystem::path relative = canonicalCandidate.lexically_relative(canonicalRoot);
|
||||
return !relative.empty() && !relative.is_absolute() && *relative.begin() != "..";
|
||||
}
|
||||
|
||||
[[nodiscard]] std::string FormatValue(const MetaCoreRuntimeDataValue& value, const std::string& format) {
|
||||
std::ostringstream stream;
|
||||
if (!format.empty()) stream << std::fixed << std::setprecision(std::max(0, std::atoi(format.c_str())));
|
||||
switch (value.Type) {
|
||||
case MetaCoreRuntimeValueType::Bool: return value.BoolValue ? "true" : "false";
|
||||
case MetaCoreRuntimeValueType::Int64: stream << value.Int64Value; break;
|
||||
case MetaCoreRuntimeValueType::Double: stream << value.DoubleValue; break;
|
||||
case MetaCoreRuntimeValueType::String: return value.StringValue;
|
||||
case MetaCoreRuntimeValueType::Vec3:
|
||||
stream << value.Vec3Value.x << ", " << value.Vec3Value.y << ", " << value.Vec3Value.z;
|
||||
break;
|
||||
}
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
[[nodiscard]] Rml::Input::KeyIdentifier MetaCoreMapGlfwKeyToRml(int key) {
|
||||
if (key >= GLFW_KEY_0 && key <= GLFW_KEY_9) {
|
||||
return static_cast<Rml::Input::KeyIdentifier>(Rml::Input::KI_0 + (key - GLFW_KEY_0));
|
||||
}
|
||||
if (key >= GLFW_KEY_A && key <= GLFW_KEY_Z) {
|
||||
return static_cast<Rml::Input::KeyIdentifier>(Rml::Input::KI_A + (key - GLFW_KEY_A));
|
||||
}
|
||||
switch (key) {
|
||||
case GLFW_KEY_SPACE: return Rml::Input::KI_SPACE;
|
||||
case GLFW_KEY_BACKSPACE: return Rml::Input::KI_BACK;
|
||||
case GLFW_KEY_TAB: return Rml::Input::KI_TAB;
|
||||
case GLFW_KEY_ENTER: return Rml::Input::KI_RETURN;
|
||||
case GLFW_KEY_ESCAPE: return Rml::Input::KI_ESCAPE;
|
||||
case GLFW_KEY_LEFT: return Rml::Input::KI_LEFT;
|
||||
case GLFW_KEY_UP: return Rml::Input::KI_UP;
|
||||
case GLFW_KEY_RIGHT: return Rml::Input::KI_RIGHT;
|
||||
case GLFW_KEY_DOWN: return Rml::Input::KI_DOWN;
|
||||
case GLFW_KEY_HOME: return Rml::Input::KI_HOME;
|
||||
case GLFW_KEY_END: return Rml::Input::KI_END;
|
||||
case GLFW_KEY_PAGE_UP: return Rml::Input::KI_PRIOR;
|
||||
case GLFW_KEY_PAGE_DOWN: return Rml::Input::KI_NEXT;
|
||||
case GLFW_KEY_INSERT: return Rml::Input::KI_INSERT;
|
||||
case GLFW_KEY_DELETE: return Rml::Input::KI_DELETE;
|
||||
case GLFW_KEY_LEFT_SHIFT: return Rml::Input::KI_LSHIFT;
|
||||
case GLFW_KEY_RIGHT_SHIFT: return Rml::Input::KI_RSHIFT;
|
||||
case GLFW_KEY_LEFT_CONTROL: return Rml::Input::KI_LCONTROL;
|
||||
case GLFW_KEY_RIGHT_CONTROL: return Rml::Input::KI_RCONTROL;
|
||||
case GLFW_KEY_LEFT_ALT: return Rml::Input::KI_LMENU;
|
||||
case GLFW_KEY_RIGHT_ALT: return Rml::Input::KI_RMENU;
|
||||
default: return Rml::Input::KI_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] int MetaCoreMapGlfwModifiersToRml(int modifiers) {
|
||||
int result = 0;
|
||||
if ((modifiers & GLFW_MOD_CONTROL) != 0) result |= Rml::Input::KM_CTRL;
|
||||
if ((modifiers & GLFW_MOD_SHIFT) != 0) result |= Rml::Input::KM_SHIFT;
|
||||
if ((modifiers & GLFW_MOD_ALT) != 0) result |= Rml::Input::KM_ALT;
|
||||
if ((modifiers & GLFW_MOD_SUPER) != 0) result |= Rml::Input::KM_META;
|
||||
if ((modifiers & GLFW_MOD_CAPS_LOCK) != 0) result |= Rml::Input::KM_CAPSLOCK;
|
||||
if ((modifiers & GLFW_MOD_NUM_LOCK) != 0) result |= Rml::Input::KM_NUMLOCK;
|
||||
return result;
|
||||
}
|
||||
|
||||
[[nodiscard]] std::vector<char> MetaCoreLoadRuntimeUiMaterialPackage() {
|
||||
for (const std::filesystem::path& candidate : {
|
||||
std::filesystem::path("rml_ui.filamat"),
|
||||
std::filesystem::path("../rml_ui.filamat"),
|
||||
std::filesystem::path("uiBlit.filamat"),
|
||||
std::filesystem::path("../uiBlit.filamat")
|
||||
}) {
|
||||
std::ifstream input(candidate, std::ios::binary);
|
||||
if (!input.is_open()) {
|
||||
continue;
|
||||
}
|
||||
std::vector<char> package((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
|
||||
if (!package.empty()) {
|
||||
return package;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
class MetaCoreRmlSystemInterface final : public Rml::SystemInterface {
|
||||
public:
|
||||
explicit MetaCoreRmlSystemInterface(MetaCoreWindow& window) : Window_(window) {}
|
||||
|
||||
void SetClipboardText(const Rml::String& text) override { Window_.SetClipboardText(text); }
|
||||
void GetClipboardText(Rml::String& text) override { text = Window_.GetClipboardText(); }
|
||||
|
||||
private:
|
||||
MetaCoreWindow& Window_;
|
||||
};
|
||||
|
||||
class MetaCoreRmlFilamentRenderInterface final : public Rml::RenderInterface {
|
||||
public:
|
||||
struct DrawCommand {
|
||||
Rml::CompiledGeometryHandle Geometry = 0;
|
||||
Rml::Vector2f Translation{};
|
||||
Rml::TextureHandle Texture = 0;
|
||||
bool ScissorEnabled = false;
|
||||
Rml::Rectanglei Scissor{};
|
||||
};
|
||||
|
||||
Rml::CompiledGeometryHandle CompileGeometry(Rml::Span<const Rml::Vertex> vertices, Rml::Span<const int> indices) override {
|
||||
if (vertices.empty() || indices.empty() || vertices.size() > std::numeric_limits<std::uint32_t>::max()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Geometry geometry;
|
||||
geometry.Vertices.reserve(vertices.size());
|
||||
for (const Rml::Vertex& vertex : vertices) {
|
||||
geometry.Vertices.push_back({
|
||||
vertex.position.x,
|
||||
vertex.position.y,
|
||||
vertex.tex_coord.x,
|
||||
vertex.tex_coord.y,
|
||||
{vertex.colour.red, vertex.colour.green, vertex.colour.blue, vertex.colour.alpha}
|
||||
});
|
||||
}
|
||||
geometry.Indices.reserve(indices.size());
|
||||
for (const int index : indices) {
|
||||
if (index < 0 || static_cast<std::size_t>(index) >= vertices.size()) return 0;
|
||||
geometry.Indices.push_back(static_cast<std::uint32_t>(index));
|
||||
}
|
||||
|
||||
const Rml::CompiledGeometryHandle handle = NextGeometryHandle_++;
|
||||
Geometries_.emplace(handle, std::move(geometry));
|
||||
return handle;
|
||||
}
|
||||
|
||||
void RenderGeometry(Rml::CompiledGeometryHandle geometry, Rml::Vector2f translation, Rml::TextureHandle texture) override {
|
||||
if (!Geometries_.contains(geometry)) return;
|
||||
DrawCommands_.push_back({geometry, translation, texture, ScissorEnabled_, Scissor_});
|
||||
}
|
||||
|
||||
void ReleaseGeometry(Rml::CompiledGeometryHandle geometry) override { Geometries_.erase(geometry); }
|
||||
|
||||
Rml::TextureHandle LoadTexture(Rml::Vector2i& dimensions, const Rml::String& source) override {
|
||||
std::filesystem::path path(source);
|
||||
if (path.is_relative()) path = UiRoot_ / path;
|
||||
if (!IsPathInsideRoot(UiRoot_, path)) return 0;
|
||||
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
int channels = 0;
|
||||
stbi_uc* pixels = stbi_load(path.string().c_str(), &width, &height, &channels, STBI_rgb_alpha);
|
||||
if (pixels == nullptr || width <= 0 || height <= 0) {
|
||||
stbi_image_free(pixels);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Texture texture;
|
||||
texture.Width = width;
|
||||
texture.Height = height;
|
||||
texture.Pixels.assign(pixels, pixels + static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4U);
|
||||
stbi_image_free(pixels);
|
||||
dimensions = {width, height};
|
||||
return StoreTexture(std::move(texture));
|
||||
}
|
||||
|
||||
Rml::TextureHandle GenerateTexture(Rml::Span<const Rml::byte> source, Rml::Vector2i dimensions) override {
|
||||
if (dimensions.x <= 0 || dimensions.y <= 0) return 0;
|
||||
const std::size_t byteCount = static_cast<std::size_t>(dimensions.x) * static_cast<std::size_t>(dimensions.y) * 4U;
|
||||
if (source.size() != byteCount) return 0;
|
||||
Texture texture;
|
||||
texture.Width = dimensions.x;
|
||||
texture.Height = dimensions.y;
|
||||
texture.Pixels.assign(source.begin(), source.end());
|
||||
return StoreTexture(std::move(texture));
|
||||
}
|
||||
|
||||
void ReleaseTexture(Rml::TextureHandle texture) override {
|
||||
const auto found = Textures_.find(texture);
|
||||
if (found == Textures_.end()) return;
|
||||
if (Engine_ != nullptr && found->second.FilamentTexture != nullptr) {
|
||||
Engine_->destroy(found->second.FilamentTexture);
|
||||
}
|
||||
Textures_.erase(found);
|
||||
}
|
||||
|
||||
void EnableScissorRegion(bool enable) override { ScissorEnabled_ = enable; }
|
||||
void SetScissorRegion(Rml::Rectanglei region) override { Scissor_ = region; }
|
||||
|
||||
void BeginFrame() { DrawCommands_.clear(); }
|
||||
|
||||
void Render(filament::Engine& engine, filament::Renderer& renderer, uint32_t width, uint32_t height) {
|
||||
if (width == 0 || height == 0 || DrawCommands_.empty()) return;
|
||||
EnsureFilamentResources(engine);
|
||||
if (Scene_ == nullptr || View_ == nullptr || Material_ == nullptr || Camera_ == nullptr) return;
|
||||
|
||||
ClearFrameResources();
|
||||
View_->setViewport({0, 0, width, height});
|
||||
Camera_->setProjection(filament::Camera::Projection::ORTHO, 0.0, static_cast<double>(width),
|
||||
static_cast<double>(height), 0.0, 0.0, 1.0);
|
||||
|
||||
std::vector<DrawCommand> commands;
|
||||
commands.reserve(DrawCommands_.size());
|
||||
for (const DrawCommand& command : DrawCommands_) {
|
||||
if (Geometries_.contains(command.Geometry)) commands.push_back(command);
|
||||
}
|
||||
if (commands.empty()) return;
|
||||
|
||||
FrameRenderable_ = utils::EntityManager::get().create();
|
||||
filament::RenderableManager::Builder builder(static_cast<uint32_t>(commands.size()));
|
||||
builder.boundingBox({{0.0f, 0.0f, -1.0f}, {static_cast<float>(width), static_cast<float>(height), 1.0f}})
|
||||
.culling(false)
|
||||
.castShadows(false)
|
||||
.receiveShadows(false);
|
||||
|
||||
for (std::size_t primitiveIndex = 0; primitiveIndex < commands.size(); ++primitiveIndex) {
|
||||
const DrawCommand& command = commands[primitiveIndex];
|
||||
const Geometry& geometry = Geometries_.at(command.Geometry);
|
||||
if (!CreateFrameGeometry(engine, geometry, command.Translation)) continue;
|
||||
|
||||
filament::MaterialInstance* materialInstance = Material_->createInstance();
|
||||
FrameMaterialInstances_.push_back(materialInstance);
|
||||
const filament::Texture* texture = ResolveTexture(engine, command.Texture);
|
||||
if (texture != nullptr) {
|
||||
materialInstance->setParameter("albedo", texture, filament::TextureSampler(
|
||||
filament::TextureSampler::MinFilter::LINEAR,
|
||||
filament::TextureSampler::MagFilter::LINEAR
|
||||
));
|
||||
}
|
||||
if (command.ScissorEnabled) {
|
||||
const uint32_t left = static_cast<uint32_t>(std::max(0, command.Scissor.Left()));
|
||||
const uint32_t bottom = static_cast<uint32_t>(std::max(0, static_cast<int>(height) - command.Scissor.Bottom()));
|
||||
const uint32_t scissorWidth = static_cast<uint32_t>(std::max(0, command.Scissor.Width()));
|
||||
const uint32_t scissorHeight = static_cast<uint32_t>(std::max(0, command.Scissor.Height()));
|
||||
materialInstance->setScissor(left, bottom, scissorWidth, scissorHeight);
|
||||
} else {
|
||||
materialInstance->unsetScissor();
|
||||
}
|
||||
|
||||
builder.geometry(static_cast<uint8_t>(primitiveIndex), filament::RenderableManager::PrimitiveType::TRIANGLES,
|
||||
FrameVertexBuffers_.back(), FrameIndexBuffers_.back(), 0, static_cast<uint32_t>(geometry.Indices.size()))
|
||||
.material(static_cast<uint8_t>(primitiveIndex), materialInstance)
|
||||
.blendOrder(static_cast<uint16_t>(primitiveIndex), static_cast<uint16_t>(primitiveIndex));
|
||||
}
|
||||
|
||||
if (FrameVertexBuffers_.empty()) {
|
||||
utils::EntityManager::get().destroy(FrameRenderable_);
|
||||
FrameRenderable_ = {};
|
||||
return;
|
||||
}
|
||||
builder.build(engine, FrameRenderable_);
|
||||
Scene_->addEntity(FrameRenderable_);
|
||||
renderer.render(View_);
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
if (Engine_ == nullptr) return;
|
||||
ClearFrameResources();
|
||||
for (auto& [_, texture] : Textures_) {
|
||||
if (texture.FilamentTexture != nullptr) Engine_->destroy(texture.FilamentTexture);
|
||||
}
|
||||
Textures_.clear();
|
||||
if (WhiteTexture_ != nullptr) Engine_->destroy(WhiteTexture_);
|
||||
if (Material_ != nullptr) Engine_->destroy(Material_);
|
||||
if (View_ != nullptr) Engine_->destroy(View_);
|
||||
if (Camera_ != nullptr) {
|
||||
const utils::Entity cameraEntity = Camera_->getEntity();
|
||||
Engine_->destroyCameraComponent(cameraEntity);
|
||||
utils::EntityManager::get().destroy(cameraEntity);
|
||||
}
|
||||
if (Scene_ != nullptr) Engine_->destroy(Scene_);
|
||||
Material_ = nullptr;
|
||||
WhiteTexture_ = nullptr;
|
||||
View_ = nullptr;
|
||||
Camera_ = nullptr;
|
||||
Scene_ = nullptr;
|
||||
Engine_ = nullptr;
|
||||
}
|
||||
|
||||
void SetUiRoot(std::filesystem::path root) { UiRoot_ = std::move(root); }
|
||||
|
||||
private:
|
||||
struct GpuVertex {
|
||||
float Position[2];
|
||||
float Uv[2];
|
||||
std::array<std::uint8_t, 4> Color{};
|
||||
};
|
||||
|
||||
struct Geometry {
|
||||
std::vector<GpuVertex> Vertices;
|
||||
std::vector<std::uint32_t> Indices;
|
||||
};
|
||||
|
||||
struct Texture {
|
||||
int Width = 0;
|
||||
int Height = 0;
|
||||
std::vector<std::uint8_t> Pixels;
|
||||
filament::Texture* FilamentTexture = nullptr;
|
||||
};
|
||||
|
||||
[[nodiscard]] Rml::TextureHandle StoreTexture(Texture texture) {
|
||||
const Rml::TextureHandle handle = NextTextureHandle_++;
|
||||
Textures_.emplace(handle, std::move(texture));
|
||||
return handle;
|
||||
}
|
||||
|
||||
void EnsureFilamentResources(filament::Engine& engine) {
|
||||
if (Engine_ != nullptr && Engine_ != &engine) Shutdown();
|
||||
if (Engine_ != nullptr) return;
|
||||
Engine_ = &engine;
|
||||
Scene_ = Engine_->createScene();
|
||||
View_ = Engine_->createView();
|
||||
View_->setScene(Scene_);
|
||||
View_->setPostProcessingEnabled(false);
|
||||
View_->setBlendMode(filament::View::BlendMode::TRANSLUCENT);
|
||||
View_->setShadowingEnabled(false);
|
||||
const utils::Entity cameraEntity = utils::EntityManager::get().create();
|
||||
Camera_ = Engine_->createCamera(cameraEntity);
|
||||
View_->setCamera(Camera_);
|
||||
|
||||
const std::vector<char> package = MetaCoreLoadRuntimeUiMaterialPackage();
|
||||
if (!package.empty()) Material_ = filament::Material::Builder().package(package.data(), package.size()).build(*Engine_);
|
||||
CreateWhiteTexture();
|
||||
}
|
||||
|
||||
[[nodiscard]] const filament::Texture* ResolveTexture(filament::Engine& engine, Rml::TextureHandle handle) {
|
||||
const auto found = Textures_.find(handle);
|
||||
if (found == Textures_.end()) return WhiteTexture_;
|
||||
Texture& texture = found->second;
|
||||
if (texture.FilamentTexture != nullptr) return texture.FilamentTexture;
|
||||
if (texture.Width <= 0 || texture.Height <= 0 || texture.Pixels.empty()) return WhiteTexture_;
|
||||
|
||||
void* pixelBytes = std::malloc(texture.Pixels.size());
|
||||
if (pixelBytes == nullptr) return nullptr;
|
||||
std::memcpy(pixelBytes, texture.Pixels.data(), texture.Pixels.size());
|
||||
filament::Texture::PixelBufferDescriptor descriptor(pixelBytes, texture.Pixels.size(),
|
||||
filament::Texture::Format::RGBA, filament::Texture::Type::UBYTE,
|
||||
[](void* buffer, std::size_t, void*) { std::free(buffer); }, nullptr);
|
||||
texture.FilamentTexture = filament::Texture::Builder()
|
||||
.width(static_cast<uint32_t>(texture.Width))
|
||||
.height(static_cast<uint32_t>(texture.Height))
|
||||
.levels(1)
|
||||
.format(filament::Texture::InternalFormat::RGBA8)
|
||||
.sampler(filament::Texture::Sampler::SAMPLER_2D)
|
||||
.build(engine);
|
||||
texture.FilamentTexture->setImage(engine, 0, std::move(descriptor));
|
||||
return texture.FilamentTexture;
|
||||
}
|
||||
|
||||
void CreateWhiteTexture() {
|
||||
if (Engine_ == nullptr || WhiteTexture_ != nullptr) return;
|
||||
std::array<std::uint8_t, 4> pixels{255, 255, 255, 255};
|
||||
void* pixelBytes = std::malloc(pixels.size());
|
||||
if (pixelBytes == nullptr) return;
|
||||
std::memcpy(pixelBytes, pixels.data(), pixels.size());
|
||||
filament::Texture::PixelBufferDescriptor descriptor(pixelBytes, pixels.size(),
|
||||
filament::Texture::Format::RGBA, filament::Texture::Type::UBYTE,
|
||||
[](void* buffer, std::size_t, void*) { std::free(buffer); }, nullptr);
|
||||
WhiteTexture_ = filament::Texture::Builder()
|
||||
.width(1)
|
||||
.height(1)
|
||||
.levels(1)
|
||||
.format(filament::Texture::InternalFormat::RGBA8)
|
||||
.sampler(filament::Texture::Sampler::SAMPLER_2D)
|
||||
.build(*Engine_);
|
||||
WhiteTexture_->setImage(*Engine_, 0, std::move(descriptor));
|
||||
}
|
||||
|
||||
[[nodiscard]] bool CreateFrameGeometry(filament::Engine& engine, const Geometry& geometry, Rml::Vector2f translation) {
|
||||
if (geometry.Vertices.empty() || geometry.Indices.empty()) return false;
|
||||
std::vector<GpuVertex> translatedVertices = geometry.Vertices;
|
||||
for (GpuVertex& vertex : translatedVertices) {
|
||||
vertex.Position[0] += translation.x;
|
||||
vertex.Position[1] += translation.y;
|
||||
}
|
||||
|
||||
auto* vertexBuffer = filament::VertexBuffer::Builder()
|
||||
.vertexCount(static_cast<uint32_t>(translatedVertices.size()))
|
||||
.bufferCount(1)
|
||||
.attribute(filament::VertexAttribute::POSITION, 0, filament::VertexBuffer::AttributeType::FLOAT2, 0, sizeof(GpuVertex))
|
||||
.attribute(filament::VertexAttribute::UV0, 0, filament::VertexBuffer::AttributeType::FLOAT2, sizeof(float) * 2, sizeof(GpuVertex))
|
||||
.attribute(filament::VertexAttribute::COLOR, 0, filament::VertexBuffer::AttributeType::UBYTE4, sizeof(float) * 4, sizeof(GpuVertex))
|
||||
.normalized(filament::VertexAttribute::COLOR)
|
||||
.build(engine);
|
||||
auto* indexBuffer = filament::IndexBuffer::Builder()
|
||||
.indexCount(static_cast<uint32_t>(geometry.Indices.size()))
|
||||
.bufferType(filament::IndexBuffer::IndexType::UINT)
|
||||
.build(engine);
|
||||
|
||||
const std::size_t vertexBytes = translatedVertices.size() * sizeof(GpuVertex);
|
||||
void* copiedVertices = std::malloc(vertexBytes);
|
||||
const std::size_t indexBytes = geometry.Indices.size() * sizeof(std::uint32_t);
|
||||
void* copiedIndices = std::malloc(indexBytes);
|
||||
if (copiedVertices == nullptr || copiedIndices == nullptr) {
|
||||
std::free(copiedVertices);
|
||||
std::free(copiedIndices);
|
||||
engine.destroy(vertexBuffer);
|
||||
engine.destroy(indexBuffer);
|
||||
return false;
|
||||
}
|
||||
std::memcpy(copiedVertices, translatedVertices.data(), vertexBytes);
|
||||
std::memcpy(copiedIndices, geometry.Indices.data(), indexBytes);
|
||||
vertexBuffer->setBufferAt(engine, 0, filament::VertexBuffer::BufferDescriptor(copiedVertices, vertexBytes,
|
||||
[](void* buffer, std::size_t, void*) { std::free(buffer); }, nullptr));
|
||||
indexBuffer->setBuffer(engine, filament::IndexBuffer::BufferDescriptor(copiedIndices, indexBytes,
|
||||
[](void* buffer, std::size_t, void*) { std::free(buffer); }, nullptr));
|
||||
FrameVertexBuffers_.push_back(vertexBuffer);
|
||||
FrameIndexBuffers_.push_back(indexBuffer);
|
||||
return true;
|
||||
}
|
||||
|
||||
void ClearFrameResources() {
|
||||
if (Engine_ == nullptr) return;
|
||||
if (FrameRenderable_) {
|
||||
Engine_->getRenderableManager().destroy(FrameRenderable_);
|
||||
if (Scene_ != nullptr) Scene_->remove(FrameRenderable_);
|
||||
utils::EntityManager::get().destroy(FrameRenderable_);
|
||||
FrameRenderable_ = {};
|
||||
}
|
||||
for (filament::MaterialInstance* instance : FrameMaterialInstances_) Engine_->destroy(instance);
|
||||
for (filament::VertexBuffer* buffer : FrameVertexBuffers_) Engine_->destroy(buffer);
|
||||
for (filament::IndexBuffer* buffer : FrameIndexBuffers_) Engine_->destroy(buffer);
|
||||
FrameMaterialInstances_.clear();
|
||||
FrameVertexBuffers_.clear();
|
||||
FrameIndexBuffers_.clear();
|
||||
}
|
||||
|
||||
std::filesystem::path UiRoot_;
|
||||
std::unordered_map<Rml::CompiledGeometryHandle, Geometry> Geometries_;
|
||||
std::unordered_map<Rml::TextureHandle, Texture> Textures_;
|
||||
std::vector<DrawCommand> DrawCommands_;
|
||||
Rml::CompiledGeometryHandle NextGeometryHandle_ = 1;
|
||||
Rml::TextureHandle NextTextureHandle_ = 1;
|
||||
bool ScissorEnabled_ = false;
|
||||
Rml::Rectanglei Scissor_{};
|
||||
|
||||
filament::Engine* Engine_ = nullptr;
|
||||
filament::Scene* Scene_ = nullptr;
|
||||
filament::View* View_ = nullptr;
|
||||
filament::Camera* Camera_ = nullptr;
|
||||
filament::Material* Material_ = nullptr;
|
||||
filament::Texture* WhiteTexture_ = nullptr;
|
||||
utils::Entity FrameRenderable_{};
|
||||
std::vector<filament::MaterialInstance*> FrameMaterialInstances_;
|
||||
std::vector<filament::VertexBuffer*> FrameVertexBuffers_;
|
||||
std::vector<filament::IndexBuffer*> FrameIndexBuffers_;
|
||||
};
|
||||
|
||||
class MetaCoreRmlFileInterface final : public Rml::FileInterface {
|
||||
public:
|
||||
explicit MetaCoreRmlFileInterface(std::filesystem::path root) : Root_(std::move(root)) {}
|
||||
|
||||
Rml::FileHandle Open(const Rml::String& path) override {
|
||||
std::filesystem::path candidate(path);
|
||||
if (candidate.is_relative()) candidate = Root_ / candidate;
|
||||
if (!IsPathInsideRoot(Root_, candidate)) return 0;
|
||||
auto* file = new std::ifstream(candidate, std::ios::binary);
|
||||
if (!file->is_open()) { delete file; return 0; }
|
||||
return reinterpret_cast<Rml::FileHandle>(file);
|
||||
}
|
||||
void Close(Rml::FileHandle file) override { delete reinterpret_cast<std::ifstream*>(file); }
|
||||
size_t Read(void* buffer, size_t size, Rml::FileHandle file) override {
|
||||
auto& input = *reinterpret_cast<std::ifstream*>(file);
|
||||
input.read(static_cast<char*>(buffer), static_cast<std::streamsize>(size));
|
||||
return static_cast<size_t>(input.gcount());
|
||||
}
|
||||
bool Seek(Rml::FileHandle file, long offset, int origin) override {
|
||||
auto& input = *reinterpret_cast<std::ifstream*>(file);
|
||||
input.seekg(offset, static_cast<std::ios_base::seekdir>(origin));
|
||||
return input.good();
|
||||
}
|
||||
size_t Tell(Rml::FileHandle file) override {
|
||||
return static_cast<size_t>(reinterpret_cast<std::ifstream*>(file)->tellg());
|
||||
}
|
||||
private:
|
||||
std::filesystem::path Root_;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
class MetaCoreRuntimeUiSystem::Impl {
|
||||
public:
|
||||
struct DocumentState {
|
||||
MetaCoreRuntimeUiDocumentEntry Entry{};
|
||||
Rml::ElementDocument* Document = nullptr;
|
||||
};
|
||||
|
||||
class EventListener final : public Rml::EventListener {
|
||||
public:
|
||||
EventListener(Impl& owner, std::string documentId) : Owner_(owner), DocumentId_(std::move(documentId)) {}
|
||||
void ProcessEvent(Rml::Event& event) override {
|
||||
Rml::Element* target = event.GetTargetElement();
|
||||
if (target == nullptr) return;
|
||||
const std::string action = target->GetAttribute<Rml::String>("data-metacore-action", "");
|
||||
if (action.empty()) return;
|
||||
MetaCoreRuntimeUiEvent uiEvent;
|
||||
uiEvent.DocumentId = DocumentId_;
|
||||
uiEvent.ElementId = target->GetId();
|
||||
uiEvent.Action = action;
|
||||
uiEvent.Type = event.GetType();
|
||||
uiEvent.Value = target->GetAttribute<Rml::String>("value", "");
|
||||
Owner_.Events_.push_back(uiEvent);
|
||||
if (Owner_.Callback_) Owner_.Callback_(uiEvent);
|
||||
}
|
||||
private:
|
||||
Impl& Owner_;
|
||||
std::string DocumentId_;
|
||||
};
|
||||
|
||||
MetaCoreWindow* Window_ = nullptr;
|
||||
MetaCoreEditorViewportRenderer* ViewportRenderer_ = nullptr;
|
||||
std::filesystem::path UiRoot_;
|
||||
MetaCoreRmlFilamentRenderInterface RenderInterface_;
|
||||
std::unique_ptr<MetaCoreRmlFileInterface> FileInterface_;
|
||||
std::unique_ptr<MetaCoreRmlSystemInterface> SystemInterface_;
|
||||
Rml::Context* Context_ = nullptr;
|
||||
std::vector<DocumentState> Documents_;
|
||||
std::vector<std::unique_ptr<EventListener>> Listeners_;
|
||||
std::unordered_map<std::string, MetaCoreRuntimeDataValue> Values_;
|
||||
std::vector<MetaCoreRuntimeUiEvent> Events_;
|
||||
std::vector<std::string> Errors_;
|
||||
EventCallback Callback_;
|
||||
bool Initialized_ = false;
|
||||
|
||||
[[nodiscard]] bool HasInputEnabledDocument() const {
|
||||
return std::any_of(Documents_.begin(), Documents_.end(), [](const DocumentState& state) {
|
||||
return state.Entry.Visible && state.Entry.InputEnabled && state.Document != nullptr;
|
||||
});
|
||||
}
|
||||
|
||||
void ApplyBindings() {
|
||||
for (DocumentState& state : Documents_) {
|
||||
if (state.Document == nullptr) continue;
|
||||
Rml::ElementList elements;
|
||||
state.Document->QuerySelectorAll(elements, "[data-metacore-bind]");
|
||||
for (Rml::Element* element : elements) {
|
||||
const std::string dataPointId = element->GetAttribute<Rml::String>("data-metacore-bind", "");
|
||||
const auto value = Values_.find(dataPointId);
|
||||
if (value == Values_.end()) continue;
|
||||
const std::string format = element->GetAttribute<Rml::String>("data-metacore-format", "");
|
||||
element->SetInnerRML(FormatValue(value->second, format));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
MetaCoreRuntimeUiSystem::MetaCoreRuntimeUiSystem() : Impl_(std::make_unique<Impl>()) {}
|
||||
MetaCoreRuntimeUiSystem::~MetaCoreRuntimeUiSystem() { Shutdown(); }
|
||||
|
||||
bool MetaCoreRuntimeUiSystem::Initialize(MetaCoreWindow& window, const std::filesystem::path&, const std::filesystem::path& uiRoot, const MetaCoreRuntimeUiManifest& manifest) {
|
||||
Shutdown();
|
||||
if (uiRoot.empty() || !std::filesystem::is_directory(uiRoot)) return false;
|
||||
Impl_->Window_ = &window;
|
||||
Impl_->UiRoot_ = std::filesystem::weakly_canonical(uiRoot);
|
||||
Impl_->RenderInterface_.SetUiRoot(Impl_->UiRoot_);
|
||||
Impl_->FileInterface_ = std::make_unique<MetaCoreRmlFileInterface>(Impl_->UiRoot_);
|
||||
Impl_->SystemInterface_ = std::make_unique<MetaCoreRmlSystemInterface>(window);
|
||||
Rml::SetRenderInterface(&Impl_->RenderInterface_);
|
||||
Rml::SetFileInterface(Impl_->FileInterface_.get());
|
||||
Rml::SetSystemInterface(Impl_->SystemInterface_.get());
|
||||
if (!Rml::Initialise()) return false;
|
||||
const auto [width, height] = window.GetFramebufferSize();
|
||||
Impl_->Context_ = Rml::CreateContext("MetaCoreRuntime", {width, height});
|
||||
if (Impl_->Context_ == nullptr) {
|
||||
Rml::Shutdown();
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<MetaCoreRuntimeUiDocumentEntry> entries = manifest.Documents;
|
||||
std::sort(entries.begin(), entries.end(), [](const auto& lhs, const auto& rhs) { return lhs.Layer < rhs.Layer; });
|
||||
for (const MetaCoreRuntimeUiDocumentEntry& entry : entries) {
|
||||
const std::filesystem::path absolutePath = Impl_->UiRoot_ / entry.RmlPath;
|
||||
if (entry.DocumentId.empty() || entry.RmlPath.empty() || !IsPathInsideRoot(Impl_->UiRoot_, absolutePath)) {
|
||||
Impl_->Errors_.push_back("Invalid UI manifest entry: " + entry.DocumentId);
|
||||
continue;
|
||||
}
|
||||
Rml::ElementDocument* document = Impl_->Context_->LoadDocument(absolutePath.string());
|
||||
if (document == nullptr) {
|
||||
Impl_->Errors_.push_back("Failed to load RML: " + entry.RmlPath.generic_string());
|
||||
continue;
|
||||
}
|
||||
if (entry.Visible) document->Show(); else document->Hide();
|
||||
Impl_->Listeners_.push_back(std::make_unique<Impl::EventListener>(*Impl_, entry.DocumentId));
|
||||
document->AddEventListener("click", Impl_->Listeners_.back().get());
|
||||
document->AddEventListener("submit", Impl_->Listeners_.back().get());
|
||||
document->AddEventListener("change", Impl_->Listeners_.back().get());
|
||||
Impl_->Documents_.push_back({entry, document});
|
||||
}
|
||||
Impl_->Initialized_ = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void MetaCoreRuntimeUiSystem::AttachToViewportRenderer(MetaCoreEditorViewportRenderer& viewportRenderer) {
|
||||
Impl_->ViewportRenderer_ = &viewportRenderer;
|
||||
viewportRenderer.SetRuntimeOverlayRenderCallback([this](filament::Engine& engine, filament::Renderer& renderer, uint32_t width, uint32_t height) {
|
||||
if (Impl_ && Impl_->Initialized_) Impl_->RenderInterface_.Render(engine, renderer, width, height);
|
||||
});
|
||||
}
|
||||
|
||||
void MetaCoreRuntimeUiSystem::Shutdown() {
|
||||
if (!Impl_) return;
|
||||
if (Impl_->ViewportRenderer_ != nullptr) {
|
||||
Impl_->ViewportRenderer_->SetRuntimeOverlayRenderCallback({});
|
||||
Impl_->ViewportRenderer_ = nullptr;
|
||||
}
|
||||
if (Impl_->Initialized_) Rml::Shutdown();
|
||||
Impl_->RenderInterface_.Shutdown();
|
||||
Impl_->Documents_.clear();
|
||||
Impl_->Listeners_.clear();
|
||||
Impl_->Context_ = nullptr;
|
||||
Impl_->FileInterface_.reset();
|
||||
Impl_->SystemInterface_.reset();
|
||||
Impl_->Values_.clear();
|
||||
Impl_->Initialized_ = false;
|
||||
}
|
||||
|
||||
void MetaCoreRuntimeUiSystem::Update(float) {
|
||||
if (!Impl_->Initialized_ || Impl_->Context_ == nullptr || Impl_->Window_ == nullptr) return;
|
||||
const auto [width, height] = Impl_->Window_->GetFramebufferSize();
|
||||
Impl_->Context_->SetDimensions({width, height});
|
||||
MetaCoreInput& input = Impl_->Window_->GetInput();
|
||||
if (Impl_->HasInputEnabledDocument()) {
|
||||
const glm::vec2 cursor = input.GetCursorPosition();
|
||||
Impl_->Context_->ProcessMouseMove(static_cast<int>(cursor.x), static_cast<int>(cursor.y), 0);
|
||||
for (int button = 0; button < 3; ++button) {
|
||||
const auto mouseButton = static_cast<MetaCoreMouseButton>(button);
|
||||
if (input.WasMouseButtonPressed(mouseButton)) Impl_->Context_->ProcessMouseButtonDown(button, 0);
|
||||
if (input.WasMouseButtonReleased(mouseButton)) Impl_->Context_->ProcessMouseButtonUp(button, 0);
|
||||
}
|
||||
if (std::abs(input.GetMouseWheelDelta()) > 0.001F) Impl_->Context_->ProcessMouseWheel(input.GetMouseWheelDelta(), 0);
|
||||
for (const MetaCoreKeyEvent& event : input.ConsumeKeyEvents()) {
|
||||
const Rml::Input::KeyIdentifier key = MetaCoreMapGlfwKeyToRml(event.Key);
|
||||
const int modifiers = MetaCoreMapGlfwModifiersToRml(event.Modifiers);
|
||||
if (event.Pressed) Impl_->Context_->ProcessKeyDown(key, modifiers);
|
||||
else Impl_->Context_->ProcessKeyUp(key, modifiers);
|
||||
}
|
||||
for (const char32_t codePoint : input.ConsumeTextInput()) {
|
||||
Impl_->Context_->ProcessTextInput(static_cast<Rml::Character>(codePoint));
|
||||
}
|
||||
} else {
|
||||
(void)input.ConsumeKeyEvents();
|
||||
(void)input.ConsumeTextInput();
|
||||
}
|
||||
Impl_->RenderInterface_.BeginFrame();
|
||||
Impl_->Context_->Update();
|
||||
Impl_->Context_->Render();
|
||||
}
|
||||
|
||||
void MetaCoreRuntimeUiSystem::ApplyDataUpdates(const std::vector<MetaCoreRuntimeDataUpdate>& updates) {
|
||||
if (!Impl_->Initialized_) return;
|
||||
for (const MetaCoreRuntimeDataUpdate& update : updates) Impl_->Values_[update.DataPointId] = update.Value;
|
||||
Impl_->ApplyBindings();
|
||||
}
|
||||
|
||||
bool MetaCoreRuntimeUiSystem::SetDocumentVisible(const std::string& documentId, bool visible) {
|
||||
for (Impl::DocumentState& state : Impl_->Documents_) {
|
||||
if (state.Entry.DocumentId != documentId || state.Document == nullptr) continue;
|
||||
if (visible) state.Document->Show(); else state.Document->Hide();
|
||||
state.Entry.Visible = visible;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<MetaCoreRuntimeUiEvent> MetaCoreRuntimeUiSystem::ConsumeEvents() { return std::exchange(Impl_->Events_, {}); }
|
||||
void MetaCoreRuntimeUiSystem::SetEventCallback(EventCallback callback) { Impl_->Callback_ = std::move(callback); }
|
||||
bool MetaCoreRuntimeUiSystem::IsInitialized() const { return Impl_->Initialized_; }
|
||||
std::size_t MetaCoreRuntimeUiSystem::GetLoadedDocumentCount() const { return Impl_->Documents_.size(); }
|
||||
const std::vector<std::string>& MetaCoreRuntimeUiSystem::GetErrors() const { return Impl_->Errors_; }
|
||||
|
||||
} // namespace MetaCore
|
||||
@ -0,0 +1,57 @@
|
||||
#pragma once
|
||||
|
||||
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataProject.h"
|
||||
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataTypes.h"
|
||||
|
||||
#include <filesystem>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace MetaCore {
|
||||
|
||||
class MetaCoreWindow;
|
||||
class MetaCoreEditorViewportRenderer;
|
||||
|
||||
struct MetaCoreRuntimeUiEvent {
|
||||
std::string DocumentId{};
|
||||
std::string ElementId{};
|
||||
std::string Action{};
|
||||
std::string Type{};
|
||||
std::string Value{};
|
||||
};
|
||||
|
||||
class MetaCoreRuntimeUiSystem {
|
||||
public:
|
||||
using EventCallback = std::function<void(const MetaCoreRuntimeUiEvent&)>;
|
||||
|
||||
MetaCoreRuntimeUiSystem();
|
||||
~MetaCoreRuntimeUiSystem();
|
||||
|
||||
[[nodiscard]] bool Initialize(
|
||||
MetaCoreWindow& window,
|
||||
const std::filesystem::path& projectRoot,
|
||||
const std::filesystem::path& uiRoot,
|
||||
const MetaCoreRuntimeUiManifest& manifest
|
||||
);
|
||||
void Shutdown();
|
||||
|
||||
void AttachToViewportRenderer(MetaCoreEditorViewportRenderer& viewportRenderer);
|
||||
|
||||
void Update(float deltaSeconds);
|
||||
void ApplyDataUpdates(const std::vector<MetaCoreRuntimeDataUpdate>& updates);
|
||||
[[nodiscard]] bool SetDocumentVisible(const std::string& documentId, bool visible);
|
||||
[[nodiscard]] std::vector<MetaCoreRuntimeUiEvent> ConsumeEvents();
|
||||
void SetEventCallback(EventCallback callback);
|
||||
|
||||
[[nodiscard]] bool IsInitialized() const;
|
||||
[[nodiscard]] std::size_t GetLoadedDocumentCount() const;
|
||||
[[nodiscard]] const std::vector<std::string>& GetErrors() const;
|
||||
|
||||
private:
|
||||
class Impl;
|
||||
std::unique_ptr<Impl> Impl_;
|
||||
};
|
||||
|
||||
} // namespace MetaCore
|
||||
@ -287,6 +287,9 @@ std::vector<MetaCoreId> MetaCoreScene::DuplicateGameObjects(const std::vector<Me
|
||||
|
||||
if (sourceObject.HasComponent<MetaCoreScriptComponent>())
|
||||
clonedObject.AddComponent<MetaCoreScriptComponent>(sourceObject.GetComponent<MetaCoreScriptComponent>());
|
||||
|
||||
if (sourceObject.HasComponent<MetaCoreUiRendererComponent>())
|
||||
clonedObject.AddComponent<MetaCoreUiRendererComponent>(sourceObject.GetComponent<MetaCoreUiRendererComponent>());
|
||||
|
||||
if (sourceObject.HasComponent<MetaCorePrefabInstanceMetadata>())
|
||||
clonedObject.AddComponent<MetaCorePrefabInstanceMetadata>(sourceObject.GetComponent<MetaCorePrefabInstanceMetadata>());
|
||||
@ -449,6 +452,8 @@ MetaCoreSceneSnapshot MetaCoreScene::CaptureSnapshot() const {
|
||||
data.Rotator = obj.GetComponent<MetaCoreRotatorComponent>();
|
||||
if (obj.HasComponent<MetaCoreScriptComponent>())
|
||||
data.Script = obj.GetComponent<MetaCoreScriptComponent>();
|
||||
if (obj.HasComponent<MetaCoreUiRendererComponent>())
|
||||
data.UiRenderer = obj.GetComponent<MetaCoreUiRendererComponent>();
|
||||
if (obj.HasComponent<MetaCorePrefabInstanceMetadata>())
|
||||
data.PrefabInstance = obj.GetComponent<MetaCorePrefabInstanceMetadata>();
|
||||
if (obj.HasComponent<MetaCoreModelRootTag>())
|
||||
@ -480,6 +485,8 @@ void MetaCoreScene::RestoreSnapshot(const MetaCoreSceneSnapshot& snapshot) {
|
||||
obj.AddComponent<MetaCoreRotatorComponent>(data.Rotator.value());
|
||||
if (data.Script.has_value())
|
||||
obj.AddComponent<MetaCoreScriptComponent>(data.Script.value());
|
||||
if (data.UiRenderer.has_value())
|
||||
obj.AddComponent<MetaCoreUiRendererComponent>(data.UiRenderer.value());
|
||||
if (data.PrefabInstance.has_value())
|
||||
obj.AddComponent<MetaCorePrefabInstanceMetadata>(data.PrefabInstance.value());
|
||||
if (data.ModelRootTag.has_value())
|
||||
|
||||
@ -159,6 +159,22 @@ static json GameObjectDataToJson(const MetaCoreGameObjectData& obj, const MetaCo
|
||||
}
|
||||
scriptJson["Instances"] = std::move(instancesJson);
|
||||
objJson["Script"] = std::move(scriptJson);
|
||||
} else if (objField.Name == "UiRenderer" && obj.UiRenderer.has_value()) {
|
||||
const MetaCoreStructDescriptor* uiDesc = registry.FindStruct<MetaCoreUiRendererComponent>();
|
||||
if (uiDesc) {
|
||||
json uiJson = json::object();
|
||||
const auto& ui = obj.UiRenderer.value();
|
||||
for (const auto& uiField : uiDesc->Fields) {
|
||||
if (uiField.Name == "UiDocumentAssetGuid") uiJson["UiDocumentAssetGuid"] = GuidToString(ui.UiDocumentAssetGuid);
|
||||
else if (uiField.Name == "RenderMode") uiJson["RenderMode"] = static_cast<int>(ui.RenderMode);
|
||||
else if (uiField.Name == "Visible") uiJson["Visible"] = ui.Visible;
|
||||
else if (uiField.Name == "InputEnabled") uiJson["InputEnabled"] = ui.InputEnabled;
|
||||
else if (uiField.Name == "Layer") uiJson["Layer"] = ui.Layer;
|
||||
else if (uiField.Name == "PixelsPerUnit") uiJson["PixelsPerUnit"] = ui.PixelsPerUnit;
|
||||
else if (uiField.Name == "WorldSize") uiJson["WorldSize"] = Vec3ToJson(ui.WorldSize);
|
||||
}
|
||||
objJson["UiRenderer"] = std::move(uiJson);
|
||||
}
|
||||
} else if (objField.Name == "Camera" && obj.Camera.has_value()) {
|
||||
const MetaCoreStructDescriptor* camDesc = registry.FindStruct<MetaCoreCameraComponent>();
|
||||
if (camDesc) {
|
||||
@ -311,6 +327,22 @@ static MetaCoreGameObjectData JsonToGameObjectData(const json& objJson, const Me
|
||||
if (!script.Instances.empty()) {
|
||||
obj.Script = std::move(script);
|
||||
}
|
||||
} else if (objField.Name == "UiRenderer" && objJson.contains("UiRenderer")) {
|
||||
const auto& uiJson = objJson["UiRenderer"];
|
||||
const MetaCoreStructDescriptor* uiDesc = registry.FindStruct<MetaCoreUiRendererComponent>();
|
||||
if (uiDesc) {
|
||||
MetaCoreUiRendererComponent ui;
|
||||
for (const auto& uiField : uiDesc->Fields) {
|
||||
if (uiField.Name == "UiDocumentAssetGuid" && uiJson.contains("UiDocumentAssetGuid")) ui.UiDocumentAssetGuid = StringToGuid(uiJson["UiDocumentAssetGuid"].get<std::string>());
|
||||
else if (uiField.Name == "RenderMode" && uiJson.contains("RenderMode")) ui.RenderMode = static_cast<MetaCoreUiRenderMode>(uiJson["RenderMode"].get<int>());
|
||||
else if (uiField.Name == "Visible" && uiJson.contains("Visible")) ui.Visible = uiJson["Visible"].get<bool>();
|
||||
else if (uiField.Name == "InputEnabled" && uiJson.contains("InputEnabled")) ui.InputEnabled = uiJson["InputEnabled"].get<bool>();
|
||||
else if (uiField.Name == "Layer" && uiJson.contains("Layer")) ui.Layer = uiJson["Layer"].get<std::int32_t>();
|
||||
else if (uiField.Name == "PixelsPerUnit" && uiJson.contains("PixelsPerUnit")) ui.PixelsPerUnit = uiJson["PixelsPerUnit"].get<float>();
|
||||
else if (uiField.Name == "WorldSize" && uiJson.contains("WorldSize")) ui.WorldSize = JsonToVec3(uiJson["WorldSize"]);
|
||||
}
|
||||
obj.UiRenderer = ui;
|
||||
}
|
||||
} else if (objField.Name == "Camera" && objJson.contains("Camera")) {
|
||||
const auto& camJson = objJson["Camera"];
|
||||
const MetaCoreStructDescriptor* camDesc = registry.FindStruct<MetaCoreCameraComponent>();
|
||||
|
||||
@ -45,6 +45,12 @@ enum class MetaCoreCameraClearFlags {
|
||||
DontClear
|
||||
};
|
||||
|
||||
MC_ENUM()
|
||||
enum class MetaCoreUiRenderMode {
|
||||
ScreenSpace = 0,
|
||||
WorldSpace
|
||||
};
|
||||
|
||||
MC_STRUCT()
|
||||
struct MetaCoreTransformComponent {
|
||||
MC_GENERATED_BODY()
|
||||
@ -192,6 +198,26 @@ struct MetaCoreScriptComponent {
|
||||
std::vector<MetaCoreScriptInstanceData> Instances{};
|
||||
};
|
||||
|
||||
MC_STRUCT()
|
||||
struct MetaCoreUiRendererComponent {
|
||||
MC_GENERATED_BODY()
|
||||
|
||||
MC_PROPERTY()
|
||||
MetaCoreAssetGuid UiDocumentAssetGuid{};
|
||||
MC_PROPERTY()
|
||||
MetaCoreUiRenderMode RenderMode = MetaCoreUiRenderMode::ScreenSpace;
|
||||
MC_PROPERTY()
|
||||
bool Visible = true;
|
||||
MC_PROPERTY()
|
||||
bool InputEnabled = true;
|
||||
MC_PROPERTY()
|
||||
std::int32_t Layer = 0;
|
||||
MC_PROPERTY()
|
||||
float PixelsPerUnit = 1000.0F;
|
||||
MC_PROPERTY()
|
||||
glm::vec3 WorldSize{1.92F, 1.08F, 0.0F};
|
||||
};
|
||||
|
||||
MC_STRUCT()
|
||||
struct MetaCoreModelRootTag {
|
||||
MC_GENERATED_BODY()
|
||||
|
||||
@ -133,6 +133,8 @@ struct MetaCoreGameObjectData {
|
||||
std::optional<MetaCoreRotatorComponent> Rotator;
|
||||
MC_PROPERTY()
|
||||
std::optional<MetaCoreScriptComponent> Script;
|
||||
MC_PROPERTY()
|
||||
std::optional<MetaCoreUiRendererComponent> UiRenderer;
|
||||
};
|
||||
|
||||
} // namespace MetaCore
|
||||
|
||||
@ -467,6 +467,8 @@ void MetaCoreTestProjectSkeletonHelpers() {
|
||||
MetaCoreExpect(std::filesystem::is_directory(createdProjectRoot / "Assets" / "Materials"), "项目骨架应包含 Materials");
|
||||
MetaCoreExpect(std::filesystem::is_directory(createdProjectRoot / "Assets" / "Textures"), "项目骨架应包含 Textures");
|
||||
MetaCoreExpect(std::filesystem::is_directory(createdProjectRoot / "Assets" / "Prefabs"), "项目骨架应包含 Prefabs");
|
||||
MetaCoreExpect(std::filesystem::exists(createdProjectRoot / "Ui" / "Hud.rml"), "项目骨架应包含默认 HUD RML");
|
||||
MetaCoreExpect(std::filesystem::exists(createdProjectRoot / "Ui" / "Hud.rcss"), "项目骨架应包含默认 HUD RCSS");
|
||||
|
||||
const auto projectDocument = MetaCore::MetaCoreReadProjectFile(createdProjectRoot / "MetaCore.project.json");
|
||||
MetaCoreExpect(projectDocument.has_value(), "项目骨架项目文件应能读取");
|
||||
@ -669,6 +671,7 @@ void MetaCoreTestProjectAssetDatabaseOperations() {
|
||||
std::filesystem::remove_all(tempProjectRoot);
|
||||
std::filesystem::create_directories(tempProjectRoot / "Assets");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Scenes");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Ui");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Library");
|
||||
|
||||
{
|
||||
@ -684,6 +687,14 @@ void MetaCoreTestProjectAssetDatabaseOperations() {
|
||||
std::ofstream sourceFile(tempProjectRoot / "Assets" / "Source.dat", std::ios::trunc);
|
||||
sourceFile << "asset";
|
||||
}
|
||||
{
|
||||
std::ofstream hudFile(tempProjectRoot / "Ui" / "Hud.rml", std::ios::trunc);
|
||||
hudFile << "<rml><head><link type=\"text/rcss\" href=\"Hud.rcss\" /></head><body><div id=\"hud\">HUD</div></body></rml>";
|
||||
}
|
||||
{
|
||||
std::ofstream styleFile(tempProjectRoot / "Ui" / "Hud.rcss", std::ios::trunc);
|
||||
styleFile << "body { color: #ffffff; }";
|
||||
}
|
||||
|
||||
_putenv_s("METACORE_PROJECT_PATH", tempProjectRoot.string().c_str());
|
||||
|
||||
@ -1591,6 +1602,7 @@ void MetaCoreTestJsonSceneSaveCurrentSceneUsesMcsceneJson() {
|
||||
std::filesystem::remove_all(tempProjectRoot);
|
||||
std::filesystem::create_directories(tempProjectRoot / "Assets");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Scenes");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Ui");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Library");
|
||||
|
||||
{
|
||||
@ -1602,6 +1614,14 @@ void MetaCoreTestJsonSceneSaveCurrentSceneUsesMcsceneJson() {
|
||||
<< " \"startup_scene\": \"\"\n"
|
||||
<< "}\n";
|
||||
}
|
||||
{
|
||||
std::ofstream hudFile(tempProjectRoot / "Ui" / "Hud.rml", std::ios::trunc);
|
||||
hudFile << "<rml><head><link type=\"text/rcss\" href=\"Hud.rcss\" /></head><body><div id=\"hud\">HUD</div></body></rml>";
|
||||
}
|
||||
{
|
||||
std::ofstream styleFile(tempProjectRoot / "Ui" / "Hud.rcss", std::ios::trunc);
|
||||
styleFile << "body { font-family: sans-serif; } #hud { color: white; }";
|
||||
}
|
||||
|
||||
_putenv_s("METACORE_PROJECT_PATH", tempProjectRoot.string().c_str());
|
||||
|
||||
@ -2335,7 +2355,13 @@ void MetaCoreTestDeleteModelAssetCorrectlyClearsFromViewport() {
|
||||
// 初始化窗口和 FilamentSceneBridge
|
||||
MetaCore::MetaCoreWindow testWindow;
|
||||
bool winOk = testWindow.Initialize(800, 600, "DeleteModelAssetTestWindow");
|
||||
MetaCoreExpect(winOk, "测试窗口初始化应成功");
|
||||
if (!winOk) {
|
||||
std::cout << "[SKIP] Delete model viewport smoke requires an available display." << std::endl;
|
||||
coreServicesModule->Shutdown(moduleRegistry);
|
||||
moduleRegistry.ShutdownServices();
|
||||
_putenv_s("METACORE_PROJECT_PATH", "");
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCore::MetaCoreFilamentSceneBridge bridge;
|
||||
bridge.SetProjectRootPath(projectRoot);
|
||||
@ -2507,7 +2533,14 @@ void MetaCoreTestDeleteModelSubChildCorrectlyClearsFromViewport() {
|
||||
// 初始化窗口和 FilamentSceneBridge
|
||||
MetaCore::MetaCoreWindow testWindow;
|
||||
bool winOk = testWindow.Initialize(800, 600, "DeleteModelSubChildTestWindow");
|
||||
MetaCoreExpect(winOk, "测试窗口初始化应成功");
|
||||
if (!winOk) {
|
||||
std::cout << "[SKIP] Delete model child viewport smoke requires an available display." << std::endl;
|
||||
coreServicesModule->Shutdown(moduleRegistry);
|
||||
moduleRegistry.ShutdownServices();
|
||||
_putenv_s("METACORE_PROJECT_PATH", "");
|
||||
std::filesystem::remove_all(tempProjectRoot);
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCore::MetaCoreFilamentSceneBridge bridge;
|
||||
bridge.SetProjectRootPath(tempProjectRoot);
|
||||
@ -3274,6 +3307,7 @@ void MetaCoreTestRuntimeProjectDocumentIo() {
|
||||
writtenDocument.DataSourcesPath = std::filesystem::path("Runtime") / "DataSources.mcruntime";
|
||||
writtenDocument.BindingsPath = std::filesystem::path("Runtime") / "Bindings.mcruntime";
|
||||
writtenDocument.DiagnosticsPath = std::filesystem::path("Runtime") / "Diagnostics.mcruntimestate";
|
||||
writtenDocument.UiManifestPath = std::filesystem::path("Runtime") / "Ui.mcruntime";
|
||||
|
||||
MetaCoreExpect(MetaCore::MetaCoreWriteRuntimeProjectDocument(tempPath, writtenDocument, registry), "应能写入 RuntimeProject 文档");
|
||||
|
||||
@ -3281,6 +3315,41 @@ void MetaCoreTestRuntimeProjectDocumentIo() {
|
||||
MetaCoreExpect(loadedDocument.has_value(), "应能读回 RuntimeProject 文档");
|
||||
MetaCoreExpect(loadedDocument->StartupScenePath == writtenDocument.StartupScenePath, "StartupScenePath 应一致");
|
||||
MetaCoreExpect(loadedDocument->DiagnosticsPath == writtenDocument.DiagnosticsPath, "DiagnosticsPath 应一致");
|
||||
MetaCoreExpect(loadedDocument->UiManifestPath == writtenDocument.UiManifestPath, "UiManifestPath 应一致");
|
||||
|
||||
std::filesystem::remove(tempPath);
|
||||
}
|
||||
|
||||
void MetaCoreTestRuntimeUiManifestIo() {
|
||||
MetaCore::MetaCoreTypeRegistry registry;
|
||||
MetaCore::MetaCoreRegisterRuntimeDataGeneratedTypes(registry);
|
||||
|
||||
const std::filesystem::path tempPath = std::filesystem::temp_directory_path() / "MetaCoreRuntimeUi.mcruntime";
|
||||
MetaCore::MetaCoreRuntimeUiManifest writtenManifest;
|
||||
writtenManifest.Documents.push_back(MetaCore::MetaCoreRuntimeUiDocumentEntry{
|
||||
"hud",
|
||||
std::filesystem::path("Hud.rml"),
|
||||
0,
|
||||
true,
|
||||
true
|
||||
});
|
||||
writtenManifest.Documents.push_back(MetaCore::MetaCoreRuntimeUiDocumentEntry{
|
||||
"pause",
|
||||
std::filesystem::path("Menus") / "Pause.rml",
|
||||
10,
|
||||
false,
|
||||
false
|
||||
});
|
||||
|
||||
MetaCoreExpect(MetaCore::MetaCoreWriteRuntimeUiManifest(tempPath, writtenManifest, registry), "应能写入 Runtime UI 清单");
|
||||
const auto loadedManifest = MetaCore::MetaCoreReadRuntimeUiManifest(tempPath, registry);
|
||||
MetaCoreExpect(loadedManifest.has_value(), "应能读回 Runtime UI 清单");
|
||||
MetaCoreExpect(loadedManifest->Documents.size() == 2, "Runtime UI 清单应保留文档数量");
|
||||
MetaCoreExpect(loadedManifest->Documents.front().DocumentId == "hud", "Runtime UI 清单应保留 DocumentId");
|
||||
MetaCoreExpect(loadedManifest->Documents.front().RmlPath == std::filesystem::path("Hud.rml"), "Runtime UI 清单应保留 RML 路径");
|
||||
MetaCoreExpect(loadedManifest->Documents.back().Layer == 10, "Runtime UI 清单应保留层级");
|
||||
MetaCoreExpect(!loadedManifest->Documents.back().Visible, "Runtime UI 清单应保留初始显示状态");
|
||||
MetaCoreExpect(!loadedManifest->Documents.back().InputEnabled, "Runtime UI 清单应保留输入开关");
|
||||
|
||||
std::filesystem::remove(tempPath);
|
||||
}
|
||||
@ -3614,6 +3683,7 @@ void MetaCoreTestEditorContextRuntimeDataConfigSaveLoad() {
|
||||
std::filesystem::remove_all(tempProjectRoot);
|
||||
std::filesystem::create_directories(tempProjectRoot / "Assets");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Scenes");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Ui");
|
||||
std::filesystem::create_directories(tempProjectRoot / "Library");
|
||||
|
||||
{
|
||||
@ -3625,6 +3695,14 @@ void MetaCoreTestEditorContextRuntimeDataConfigSaveLoad() {
|
||||
<< " \"startup_scene\": \"\"\n"
|
||||
<< "}\n";
|
||||
}
|
||||
{
|
||||
std::ofstream hudFile(tempProjectRoot / "Ui" / "Hud.rml", std::ios::trunc);
|
||||
hudFile << "<rml><head><link type=\"text/rcss\" href=\"Hud.rcss\" /></head><body><div id=\"hud\">HUD</div></body></rml>";
|
||||
}
|
||||
{
|
||||
std::ofstream styleFile(tempProjectRoot / "Ui" / "Hud.rcss", std::ios::trunc);
|
||||
styleFile << "body { font-family: sans-serif; } #hud { color: white; }";
|
||||
}
|
||||
|
||||
_putenv_s("METACORE_PROJECT_PATH", tempProjectRoot.string().c_str());
|
||||
|
||||
@ -3688,12 +3766,27 @@ void MetaCoreTestEditorContextRuntimeDataConfigSaveLoad() {
|
||||
tempProjectRoot / "Runtime" / "ProjectRuntime.mcruntimecfg",
|
||||
registry
|
||||
);
|
||||
const auto loadedUiManifest = MetaCore::MetaCoreReadRuntimeUiManifest(
|
||||
tempProjectRoot / "Runtime" / "Ui.mcruntime",
|
||||
registry
|
||||
);
|
||||
MetaCoreExpect(loadedSources.has_value(), "保存后应能读回 Runtime data sources");
|
||||
MetaCoreExpect(loadedBindings.has_value(), "保存后应能读回 Runtime bindings");
|
||||
MetaCoreExpect(loadedProjectRuntime.has_value(), "保存后应能读回 Runtime project");
|
||||
MetaCoreExpect(loadedUiManifest.has_value(), "保存后应能读回 Runtime UI 清单");
|
||||
MetaCoreExpect(loadedSources->Sources.size() == 1, "保存后应保留 source");
|
||||
MetaCoreExpect(loadedBindings->Bindings.size() == 1, "保存后应保留 binding");
|
||||
MetaCoreExpect(loadedProjectRuntime->StartupScenePath == std::filesystem::path("Scenes") / "Main.mcscene.json", "保存后应写入默认 startup scene 路径");
|
||||
MetaCoreExpect(loadedProjectRuntime->UiManifestPath == std::filesystem::path("Runtime") / "Ui.mcruntime", "保存后应写入 UI 清单路径");
|
||||
MetaCoreExpect(loadedUiManifest->Documents.size() == 1, "保存后默认 UI 清单应包含 HUD");
|
||||
MetaCoreExpect(loadedUiManifest->Documents.front().RmlPath == std::filesystem::path("Hud.rml"), "默认 UI 清单应引用 HUD RML");
|
||||
|
||||
const auto cookService = moduleRegistry.ResolveService<MetaCore::MetaCoreICookService>();
|
||||
MetaCoreExpect(cookService != nullptr, "应解析到 CookService");
|
||||
MetaCoreExpect(cookService->CookRuntimeUiAssets(), "CookService 应能复制 Runtime UI 资源到 Build");
|
||||
MetaCoreExpect(std::filesystem::exists(tempProjectRoot / "Build" / "Runtime" / "Ui.mcruntime"), "Build 应包含 Runtime UI 清单");
|
||||
MetaCoreExpect(std::filesystem::exists(tempProjectRoot / "Build" / "Ui" / "Hud.rml"), "Build 应包含 HUD RML");
|
||||
MetaCoreExpect(std::filesystem::exists(tempProjectRoot / "Build" / "Ui" / "Hud.rcss"), "Build 应包含 HUD RCSS");
|
||||
|
||||
coreServicesModule->Shutdown(moduleRegistry);
|
||||
moduleRegistry.ShutdownServices();
|
||||
@ -3774,17 +3867,29 @@ void MetaCoreTestRuntimeDataConfigValidationRejectsMissingTcpPort() {
|
||||
}
|
||||
|
||||
void MetaCoreTestTcpRuntimeDataSourceAdapterReadsSocketStream() {
|
||||
MetaCoreExpect(MetaCoreTestInitializeSocketApi(), "Smoke test 应能初始化 socket API");
|
||||
if (!MetaCoreTestInitializeSocketApi()) {
|
||||
std::cout << "[SKIP] Tcp runtime data source smoke requires socket API." << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCoreTestSocket listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
MetaCoreExpect(listenSocket != MetaCoreTestInvalidSocket, "Smoke test 应能创建监听 socket");
|
||||
if (listenSocket == MetaCoreTestInvalidSocket) {
|
||||
std::cout << "[SKIP] Tcp runtime data source smoke requires a local socket." << std::endl;
|
||||
MetaCoreTestCleanupSocketApi();
|
||||
return;
|
||||
}
|
||||
|
||||
sockaddr_in address{};
|
||||
address.sin_family = AF_INET;
|
||||
address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
address.sin_port = 0;
|
||||
MetaCoreExpect(bind(listenSocket, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != MetaCoreTestSocketError, "Smoke test bind 应成功");
|
||||
MetaCoreExpect(listen(listenSocket, 1) != MetaCoreTestSocketError, "Smoke test listen 应成功");
|
||||
if (bind(listenSocket, reinterpret_cast<sockaddr*>(&address), sizeof(address)) == MetaCoreTestSocketError ||
|
||||
listen(listenSocket, 1) == MetaCoreTestSocketError) {
|
||||
std::cout << "[SKIP] Tcp runtime data source smoke requires loopback listen support." << std::endl;
|
||||
MetaCoreTestCloseSocket(listenSocket);
|
||||
MetaCoreTestCleanupSocketApi();
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCoreTestSocketLength addressLength = sizeof(address);
|
||||
MetaCoreExpect(
|
||||
@ -3972,6 +4077,67 @@ void MetaCoreTestUiDocumentSerialization() {
|
||||
MetaCoreExpectVec3Near(roundTrip.Nodes[0].Style.BackgroundColor, glm::vec3(0.05F, 0.08F, 0.12F), "Ui 背景色应保持");
|
||||
}
|
||||
|
||||
void MetaCoreTestUiRendererComponentSnapshotAndJson() {
|
||||
MetaCore::MetaCoreTypeRegistry registry;
|
||||
MetaCoreRegisterFoundationGeneratedTypes(registry);
|
||||
MetaCoreRegisterSceneGeneratedTypes(registry);
|
||||
|
||||
const MetaCore::MetaCoreAssetGuid uiGuid = MetaCore::MetaCoreAssetGuid::Generate();
|
||||
MetaCore::MetaCoreScene scene;
|
||||
MetaCore::MetaCoreGameObject uiObject = scene.CreateGameObject("Hud Canvas");
|
||||
auto& uiRenderer = uiObject.AddComponent<MetaCore::MetaCoreUiRendererComponent>();
|
||||
uiRenderer.UiDocumentAssetGuid = uiGuid;
|
||||
uiRenderer.RenderMode = MetaCore::MetaCoreUiRenderMode::WorldSpace;
|
||||
uiRenderer.Visible = false;
|
||||
uiRenderer.InputEnabled = false;
|
||||
uiRenderer.Layer = 42;
|
||||
uiRenderer.PixelsPerUnit = 512.0F;
|
||||
uiRenderer.WorldSize = glm::vec3(3.0F, 2.0F, 0.0F);
|
||||
|
||||
const MetaCore::MetaCoreSceneSnapshot snapshot = scene.CaptureSnapshot();
|
||||
MetaCoreExpect(snapshot.GameObjects.size() == 1, "UI Renderer 对象应进入场景快照");
|
||||
MetaCoreExpect(snapshot.GameObjects.front().UiRenderer.has_value(), "场景快照应保存 UI Renderer 组件");
|
||||
|
||||
MetaCore::MetaCoreScene restoredScene;
|
||||
restoredScene.RestoreSnapshot(snapshot);
|
||||
MetaCore::MetaCoreGameObject restoredObject = restoredScene.FindGameObject(uiObject.GetId());
|
||||
MetaCoreExpect(restoredObject && restoredObject.HasComponent<MetaCore::MetaCoreUiRendererComponent>(), "恢复快照后对象应保留 UI Renderer");
|
||||
const auto& restoredRenderer = restoredObject.GetComponent<MetaCore::MetaCoreUiRendererComponent>();
|
||||
MetaCoreExpect(restoredRenderer.UiDocumentAssetGuid == uiGuid, "恢复快照后 UI 资产 Guid 应一致");
|
||||
MetaCoreExpect(restoredRenderer.RenderMode == MetaCore::MetaCoreUiRenderMode::WorldSpace, "恢复快照后渲染模式应一致");
|
||||
MetaCoreExpect(restoredRenderer.Layer == 42, "恢复快照后层级应一致");
|
||||
MetaCoreExpectVec3Near(restoredRenderer.WorldSize, glm::vec3(3.0F, 2.0F, 0.0F), "恢复快照后世界尺寸应一致");
|
||||
|
||||
MetaCore::MetaCoreSceneRenderSync renderSync;
|
||||
const MetaCore::MetaCoreSceneRenderSyncSnapshot hiddenRenderSnapshot = renderSync.BuildSnapshot(scene);
|
||||
MetaCoreExpect(hiddenRenderSnapshot.Renderables.empty(), "隐藏的 3D UI Renderer 不应生成预览 Renderable");
|
||||
scene.FindGameObject(uiObject.GetId()).GetComponent<MetaCore::MetaCoreUiRendererComponent>().Visible = true;
|
||||
const MetaCore::MetaCoreSceneRenderSyncSnapshot renderSnapshot = renderSync.BuildSnapshot(scene);
|
||||
MetaCoreExpect(renderSnapshot.Renderables.size() == 1, "可见的 3D UI Renderer 应生成一个预览 Renderable");
|
||||
MetaCoreExpect(renderSnapshot.Renderables.front().ObjectId == uiObject.GetId(), "UI 预览 Renderable 应映射回 UI 对象");
|
||||
MetaCoreExpect(renderSnapshot.Renderables.front().BuiltinMesh == MetaCore::MetaCoreBuiltinMeshType::Cube, "UI 预览应使用内置 Cube 面板");
|
||||
|
||||
MetaCore::MetaCoreSceneDocument sceneDocument;
|
||||
sceneDocument.Name = "UiRendererScene";
|
||||
sceneDocument.GameObjects = snapshot.GameObjects;
|
||||
const std::filesystem::path scenePath = std::filesystem::temp_directory_path() / "MetaCoreUiRendererScene.mcscene.json";
|
||||
MetaCoreExpect(MetaCore::MetaCoreSceneSerializer::SaveSceneToJson(scenePath, sceneDocument, registry), "应能保存带 UI Renderer 的场景 JSON");
|
||||
const auto loadedDocument = MetaCore::MetaCoreSceneSerializer::LoadSceneFromJson(scenePath, registry);
|
||||
std::error_code ec;
|
||||
std::filesystem::remove(scenePath, ec);
|
||||
MetaCoreExpect(loadedDocument.has_value(), "应能加载带 UI Renderer 的场景 JSON");
|
||||
MetaCoreExpect(loadedDocument->GameObjects.size() == 1, "加载后场景对象数量应一致");
|
||||
MetaCoreExpect(loadedDocument->GameObjects.front().UiRenderer.has_value(), "加载后应保留 UI Renderer 组件");
|
||||
const auto& loadedRenderer = *loadedDocument->GameObjects.front().UiRenderer;
|
||||
MetaCoreExpect(loadedRenderer.UiDocumentAssetGuid == uiGuid, "JSON 往返后 UI 资产 Guid 应一致");
|
||||
MetaCoreExpect(loadedRenderer.RenderMode == MetaCore::MetaCoreUiRenderMode::WorldSpace, "JSON 往返后渲染模式应一致");
|
||||
MetaCoreExpect(!loadedRenderer.Visible, "JSON 往返后可见状态应一致");
|
||||
MetaCoreExpect(!loadedRenderer.InputEnabled, "JSON 往返后输入状态应一致");
|
||||
MetaCoreExpect(loadedRenderer.Layer == 42, "JSON 往返后层级应一致");
|
||||
MetaCoreExpect(std::abs(loadedRenderer.PixelsPerUnit - 512.0F) <= 0.0001F, "JSON 往返后 PPU 应一致");
|
||||
MetaCoreExpectVec3Near(loadedRenderer.WorldSize, glm::vec3(3.0F, 2.0F, 0.0F), "JSON 往返后世界尺寸应一致");
|
||||
}
|
||||
|
||||
void MetaCoreTestDecoupledSnapshotSync() {
|
||||
const std::filesystem::path projectRoot = MetaCoreTestRepositoryRoot() / "TestProject";
|
||||
const std::filesystem::path modelRelativePath = std::filesystem::path("Assets") / "Models" / "Cube.glb";
|
||||
@ -4028,7 +4194,10 @@ void MetaCoreTestDecoupledSnapshotSync() {
|
||||
// 4. 初始化窗口和 FilamentSceneBridge
|
||||
MetaCore::MetaCoreWindow window;
|
||||
bool winOk = window.Initialize(800, 600, "DecoupledSnapshotSyncTestWindow");
|
||||
MetaCoreExpect(winOk, "测试窗口初始化应成功");
|
||||
if (!winOk) {
|
||||
std::cout << "[SKIP] Decoupled snapshot Filament smoke requires an available display." << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCore::MetaCoreFilamentSceneBridge bridge;
|
||||
bridge.SetProjectRootPath(projectRoot);
|
||||
@ -4176,7 +4345,10 @@ void MetaCoreTestNestedModelHierarchyTransformSync() {
|
||||
// 2. 初始化桥接器
|
||||
MetaCore::MetaCoreWindow window;
|
||||
bool winOk = window.Initialize(800, 600, "NestedModelHierarchyTestWindow");
|
||||
MetaCoreExpect(winOk, "测试窗口初始化成功");
|
||||
if (!winOk) {
|
||||
std::cout << "[SKIP] Nested model hierarchy Filament smoke requires an available display." << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
MetaCore::MetaCoreFilamentSceneBridge bridge;
|
||||
bridge.SetProjectRootPath(projectRoot);
|
||||
@ -4787,6 +4959,8 @@ int main() {
|
||||
MetaCoreTestRuntimeDataBinaryDocumentIo();
|
||||
std::cout << "[RUN] MetaCoreTestRuntimeProjectDocumentIo..." << std::endl;
|
||||
MetaCoreTestRuntimeProjectDocumentIo();
|
||||
std::cout << "[RUN] MetaCoreTestRuntimeUiManifestIo..." << std::endl;
|
||||
MetaCoreTestRuntimeUiManifestIo();
|
||||
std::cout << "[RUN] MetaCoreTestRuntimeDiagnosticsSnapshotIo..." << std::endl;
|
||||
MetaCoreTestRuntimeDiagnosticsSnapshotIo();
|
||||
std::cout << "[RUN] MetaCoreTestRuntimeDataDispatcherConstruction..." << std::endl;
|
||||
@ -4819,6 +4993,8 @@ int main() {
|
||||
MetaCoreTestTcpRuntimeDataSourceAdapterReadsSocketStream();
|
||||
std::cout << "[RUN] MetaCoreTestUiDocumentSerialization..." << std::endl;
|
||||
MetaCoreTestUiDocumentSerialization();
|
||||
std::cout << "[RUN] MetaCoreTestUiRendererComponentSnapshotAndJson..." << std::endl;
|
||||
MetaCoreTestUiRendererComponentSnapshotAndJson();
|
||||
|
||||
std::cout << "[RUN] MetaCoreTestDecoupledSnapshotSync..." << std::endl;
|
||||
MetaCoreTestDecoupledSnapshotSync();
|
||||
|
||||
5
vcpkg-triplets/clang-libcxx-toolchain.cmake
Normal file
5
vcpkg-triplets/clang-libcxx-toolchain.cmake
Normal file
@ -0,0 +1,5 @@
|
||||
set(CMAKE_C_COMPILER /usr/bin/clang-15 CACHE FILEPATH "")
|
||||
set(CMAKE_CXX_COMPILER /usr/bin/clang++-15 CACHE FILEPATH "")
|
||||
set(CMAKE_CXX_FLAGS_INIT "-stdlib=libc++")
|
||||
set(CMAKE_EXE_LINKER_FLAGS_INIT "-stdlib=libc++")
|
||||
set(CMAKE_SHARED_LINKER_FLAGS_INIT "-stdlib=libc++")
|
||||
5
vcpkg-triplets/x64-linux-clang-libcxx.cmake
Normal file
5
vcpkg-triplets/x64-linux-clang-libcxx.cmake
Normal file
@ -0,0 +1,5 @@
|
||||
set(VCPKG_TARGET_ARCHITECTURE x64)
|
||||
set(VCPKG_CRT_LINKAGE dynamic)
|
||||
set(VCPKG_LIBRARY_LINKAGE static)
|
||||
set(VCPKG_CMAKE_SYSTEM_NAME Linux)
|
||||
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${CMAKE_CURRENT_LIST_DIR}/clang-libcxx-toolchain.cmake")
|
||||
@ -4,6 +4,7 @@
|
||||
"dependencies": [
|
||||
"glm",
|
||||
"entt",
|
||||
"rmlui",
|
||||
{
|
||||
"name": "imgui",
|
||||
"default-features": false,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user