gengjiayuan/MetaCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
87bedac5e0
MetaCore/tools/PandaCubeEditorDemo.cpp
ayuan9957 87bedac5e0 metacore+imgui
2026-03-19 18:01:50 +08:00

469 lines
16 KiB
C++
Raw Blame History

#include <array>
#include <cmath>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
#if METACORE_HAS_PANDA3D && METACORE_HAS_IMGUI
#include <callbackObject.h>
#include <displayRegion.h>
#include <graphicsWindow.h>
#include <imgui.h>
#include <imgui_impl_opengl3.h>
#include <imgui_impl_win32.h>
#include <lineSegs.h>
#include <load_prc_file.h>
#include <luse.h>
#include <nodePath.h>
#include <pandaFramework.h>
#include <windowProperties.h>
#include <windows.h>
#endif
#if METACORE_HAS_PANDA3D && METACORE_HAS_IMGUI
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#endif
namespace {
void log_step(const std::string& message) {
std::cout << "[PandaCubeEditorDemo] " << message << std::endl;
}
#if METACORE_HAS_PANDA3D && METACORE_HAS_IMGUI
struct DemoState {
float camera_x = 0.0F;
float camera_y = -8.0F;
float camera_z = 2.0F;
float heading = 0.0F;
float pitch = -10.0F;
float rotation_speed = 20.0F;
bool auto_rotate = true;
bool show_demo_window = false;
bool overlay_enabled = true;
float model_position[3] = {0.0F, 0.0F, 0.0F};
float model_rotation[3] = {0.0F, 0.0F, 0.0F};
float model_scale[3] = {1.0F, 1.0F, 1.0F};
bool using_fallback_cube = false;
};
WNDPROC g_previous_wnd_proc = nullptr;
ImDrawData* g_pending_draw_data = nullptr;
HWND g_panda_hwnd = nullptr;
PT(DisplayRegion) g_overlay_region = nullptr;
class ImGuiOverlayDrawCallback final : public CallbackObject {
public:
void do_callback(CallbackData* cbdata) override {
(void)cbdata;
if (g_pending_draw_data != nullptr) {
ImGui_ImplOpenGL3_RenderDrawData(g_pending_draw_data);
}
}
};
LRESULT CALLBACK panda_imgui_wnd_proc(HWND hwnd, UINT message, WPARAM w_param, LPARAM l_param) {
if (ImGui_ImplWin32_WndProcHandler(hwnd, message, w_param, l_param)) {
return 1;
}
if (g_previous_wnd_proc != nullptr) {
return CallWindowProc(g_previous_wnd_proc, hwnd, message, w_param, l_param);
}
return DefWindowProc(hwnd, message, w_param, l_param);
}
void configure_runtime_environment() {
const auto panda_bin = std::filesystem::path(METACORE_PANDA3D_ROOT_PATH) / "bin";
const auto panda_etc = std::filesystem::path(METACORE_PANDA3D_ROOT_PATH) / "etc";
if (std::filesystem::exists(panda_bin)) {
SetDllDirectoryW(panda_bin.wstring().c_str());
const DWORD required = GetEnvironmentVariableW(L"PATH", nullptr, 0);
std::wstring existing_path(required > 0 ? required - 1 : 0, L'\0');
if (required > 0) {
GetEnvironmentVariableW(L"PATH", existing_path.data(), required);
}
const std::wstring new_path = panda_bin.wstring() + L";" + existing_path;
SetEnvironmentVariableW(L"PATH", new_path.c_str());
}
if (std::filesystem::exists(panda_etc)) {
SetEnvironmentVariableW(L"PANDA_PRC_DIR", panda_etc.wstring().c_str());
}
wchar_t exe_path_buffer[MAX_PATH];
const DWORD path_length = GetModuleFileNameW(nullptr, exe_path_buffer, MAX_PATH);
if (path_length > 0 && path_length < MAX_PATH) {
std::filesystem::current_path(std::filesystem::path(exe_path_buffer).parent_path());
}
}
void configure_local_prc() {
wchar_t exe_path_buffer[MAX_PATH];
const DWORD path_length = GetModuleFileNameW(nullptr, exe_path_buffer, MAX_PATH);
if (path_length == 0 || path_length >= MAX_PATH) {
return;
}
const std::filesystem::path exe_dir = std::filesystem::path(exe_path_buffer).parent_path();
const std::filesystem::path prc_path = exe_dir / "PandaCubeEditorDemo.prc";
const std::filesystem::path panda_bin = std::filesystem::path(METACORE_PANDA3D_ROOT_PATH) / "bin";
std::ofstream prc_file(prc_path, std::ios::trunc);
prc_file
<< "plugin-path " << panda_bin.generic_string() << "\n"
<< "load-display pandagl\n"
<< "aux-display p3tinydisplay\n"
<< "load-file-type p3assimp\n"
<< "load-file-type p3ptloader\n"
<< "window-type onscreen\n"
<< "win-size 1280 720\n"
<< "sync-video #f\n"
<< "audio-library-name null\n";
prc_file.close();
load_prc_file(Filename::from_os_specific(prc_path.string()));
}
NodePath create_wire_cube(const NodePath& parent) {
LineSegs segments("editor-demo-cube");
segments.set_thickness(2.5F);
segments.set_color(0.85F, 0.9F, 1.0F, 1.0F);
const LPoint3f corners[] = {
{-0.5F, -0.5F, -0.5F},
{0.5F, -0.5F, -0.5F},
{0.5F, 0.5F, -0.5F},
{-0.5F, 0.5F, -0.5F},
{-0.5F, -0.5F, 0.5F},
{0.5F, -0.5F, 0.5F},
{0.5F, 0.5F, 0.5F},
{-0.5F, 0.5F, 0.5F},
};
const int edges[][2] = {
{0, 1}, {1, 2}, {2, 3}, {3, 0},
{4, 5}, {5, 6}, {6, 7}, {7, 4},
{0, 4}, {1, 5}, {2, 6}, {3, 7},
};
for (const auto& edge : edges) {
segments.move_to(corners[edge[0]]);
segments.draw_to(corners[edge[1]]);
}
return parent.attach_new_node(segments.create());
}
NodePath create_world_axes(const NodePath& parent) {
LineSegs segments("world-axes");
segments.set_thickness(3.0F);
segments.set_color(0.95F, 0.2F, 0.2F, 1.0F);
segments.move_to(0.0F, 0.0F, 0.0F);
segments.draw_to(2.0F, 0.0F, 0.0F);
segments.set_color(0.2F, 0.95F, 0.35F, 1.0F);
segments.move_to(0.0F, 0.0F, 0.0F);
segments.draw_to(0.0F, 2.0F, 0.0F);
segments.set_color(0.25F, 0.55F, 1.0F, 1.0F);
segments.move_to(0.0F, 0.0F, 0.0F);
segments.draw_to(0.0F, 0.0F, 2.0F);
return parent.attach_new_node(segments.create());
}
NodePath create_ground_grid(const NodePath& parent) {
LineSegs segments("ground-grid");
segments.set_thickness(1.0F);
segments.set_color(0.35F, 0.38F, 0.42F, 0.85F);
constexpr int half_extent = 10;
for (int i = -half_extent; i <= half_extent; ++i) {
segments.move_to(static_cast<float>(i), -static_cast<float>(half_extent), 0.0F);
segments.draw_to(static_cast<float>(i), static_cast<float>(half_extent), 0.0F);
segments.move_to(-static_cast<float>(half_extent), static_cast<float>(i), 0.0F);
segments.draw_to(static_cast<float>(half_extent), static_cast<float>(i), 0.0F);
}
return parent.attach_new_node(segments.create());
}
NodePath load_demo_model(WindowFramework* window, DemoState& state) {
const Filename model_path = Filename::from_os_specific("D:/MetaCore/box1.glb");
NodePath model = window->load_model(window->get_render(), model_path);
if (!model.is_empty()) {
log_step("Loaded model: D:/MetaCore/box1.glb");
state.using_fallback_cube = false;
return model;
}
log_step("Failed to load box1.glb, falling back to wire cube");
state.using_fallback_cube = true;
NodePath fallback = create_wire_cube(window->get_render());
fallback.set_scale(1.5F);
return fallback;
}
void focus_camera_on_model(const NodePath& model, DemoState& state) {
LPoint3 min_point;
LPoint3 max_point;
if (!model.calc_tight_bounds(min_point, max_point)) {
state.camera_x = 0.0F;
state.camera_y = -8.0F;
state.camera_z = 2.0F;
state.model_position[0] = 0.0F;
state.model_position[1] = 0.0F;
state.model_position[2] = 0.0F;
return;
}
const LPoint3 center(
(min_point[0] + max_point[0]) * 0.5F,
(min_point[1] + max_point[1]) * 0.5F,
(min_point[2] + max_point[2]) * 0.5F
);
const LVecBase3 extent = max_point - min_point;
const float max_extent = (std::max)((std::max)(std::fabs(extent[0]), std::fabs(extent[1])), std::fabs(extent[2]));
const float distance = (std::max)(3.0F, max_extent * 3.0F);
state.model_position[0] = -center[0];
state.model_position[1] = -center[1];
state.model_position[2] = -center[2];
state.camera_x = 0.0F;
state.camera_y = -distance;
state.camera_z = (std::max)(1.5F, max_extent * 0.9F);
state.heading = 0.0F;
state.pitch = -10.0F;
log_step(
"Model bounds centered. Extent=" + std::to_string(max_extent) +
" camera_y=" + std::to_string(state.camera_y) +
" camera_z=" + std::to_string(state.camera_z)
);
}
std::uintptr_t native_window_handle(WindowFramework* window) {
if (window == nullptr || window->get_graphics_window() == nullptr) {
return 0;
}
if (WindowHandle* handle = window->get_graphics_window()->get_window_handle(); handle != nullptr) {
if (WindowHandle::OSHandle* os_handle = handle->get_os_handle(); os_handle != nullptr) {
return static_cast<std::uintptr_t>(os_handle->get_int_handle());
}
}
return 0;
}
void render_editor_ui(DemoState& state) {
if (!state.overlay_enabled) {
return;
}
ImGui::SetNextWindowBgAlpha(0.78F);
ImGui::SetNextWindowPos(ImVec2(16.0F, 16.0F), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(360.0F, 0.0F), ImGuiCond_Always);
if (ImGui::Begin("MetaCore Editor Overlay", nullptr,
ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoSavedSettings)) {
ImGui::TextUnformatted("Single-window Panda3D + ImGui test");
ImGui::Separator();
ImGui::Checkbox("Overlay Enabled", &state.overlay_enabled);
ImGui::Checkbox("Auto Rotate", &state.auto_rotate);
ImGui::Checkbox("Show ImGui Demo", &state.show_demo_window);
ImGui::Text("Model: %s", state.using_fallback_cube ? "Fallback Wire Cube" : "box1.glb");
ImGui::SliderFloat("Rotation Speed", &state.rotation_speed, 0.0F, 180.0F, "%.1f deg/s");
ImGui::DragFloat3("Model Position", state.model_position, 0.05F);
ImGui::DragFloat3("Model Rotation", state.model_rotation, 1.0F);
ImGui::DragFloat3("Model Scale", state.model_scale, 0.02F, 0.05F, 10.0F);
ImGui::DragFloat3("Camera Position", &state.camera_x, 0.05F);
ImGui::SliderFloat("Heading", &state.heading, -180.0F, 180.0F, "%.1f");
ImGui::SliderFloat("Pitch", &state.pitch, -89.0F, 89.0F, "%.1f");
ImGui::Separator();
ImGui::TextUnformatted("Controls");
ImGui::BulletText("W/A/S/D move");
ImGui::BulletText("R/F up and down");
ImGui::BulletText("Arrow keys look");
ImGui::BulletText("Esc closes");
ImGui::TextUnformatted("This ImGui panel is rendered over the Panda viewport.");
}
ImGui::End();
if (state.show_demo_window) {
ImGui::ShowDemoWindow(&state.show_demo_window);
}
}
#endif
} // namespace
int main() {
#if METACORE_HAS_PANDA3D && METACORE_HAS_IMGUI
log_step("Starting PandaCubeEditorDemo");
configure_runtime_environment();
configure_local_prc();
PandaFramework framework;
framework.open_framework();
framework.set_window_title("MetaCore Single-Window Editor Demo");
WindowProperties props;
props.set_title("MetaCore Single-Window Editor Demo");
props.set_size(1280, 720);
WindowFramework* panda_window = framework.open_window(props, 0);
if (panda_window == nullptr) {
log_step("Panda window failed to open");
framework.close_framework();
return 2;
}
create_ground_grid(panda_window->get_render());
create_world_axes(panda_window->get_render());
DemoState state;
NodePath model = load_demo_model(panda_window, state);
focus_camera_on_model(model, state);
g_panda_hwnd = reinterpret_cast<HWND>(native_window_handle(panda_window));
if (g_panda_hwnd == nullptr) {
log_step("Failed to resolve Panda window handle");
framework.close_window(panda_window);
framework.close_framework();
return 3;
}
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
ImGui::StyleColorsDark();
ImGui_ImplWin32_Init(g_panda_hwnd);
ImGui_ImplOpenGL3_Init("#version 130");
g_previous_wnd_proc = reinterpret_cast<WNDPROC>(
SetWindowLongPtr(g_panda_hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(panda_imgui_wnd_proc))
);
g_overlay_region = panda_window->get_graphics_output()->make_display_region();
g_overlay_region->set_sort(1000);
g_overlay_region->set_incomplete_render(true);
g_overlay_region->set_clear_color_active(false);
g_overlay_region->set_clear_depth_active(false);
PT(CallbackObject) overlay_callback = new ImGuiOverlayDrawCallback();
g_overlay_region->set_draw_callback(overlay_callback);
DWORD previous_tick = GetTickCount();
bool running = true;
while (running) {
if ((GetAsyncKeyState(VK_ESCAPE) & 0x8000) != 0) {
running = false;
}
if (panda_window->get_graphics_window() != nullptr && panda_window->get_graphics_window()->is_closed()) {
running = false;
}
const DWORD current_tick = GetTickCount();
const float delta_seconds = static_cast<float>(current_tick - previous_tick) / 1000.0F;
previous_tick = current_tick;
const float move_speed = ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0 ? 5.0F : 2.5F) * delta_seconds;
const float turn_speed = 90.0F * delta_seconds;
const auto key_down = [](const int key) {
return (GetAsyncKeyState(key) & 0x8000) != 0;
};
if (key_down(VK_LEFT)) {
state.heading -= turn_speed;
}
if (key_down(VK_RIGHT)) {
state.heading += turn_speed;
}
if (key_down(VK_UP)) {
state.pitch += turn_speed;
}
if (key_down(VK_DOWN)) {
state.pitch -= turn_speed;
}
if (state.pitch > 89.0F) {
state.pitch = 89.0F;
}
if (state.pitch < -89.0F) {
state.pitch = -89.0F;
}
const float heading_radians = state.heading * 3.1415926535F / 180.0F;
const float forward_x = std::sin(heading_radians);
const float forward_y = std::cos(heading_radians);
const float right_x = std::cos(heading_radians);
const float right_y = -std::sin(heading_radians);
if (key_down('W')) {
state.camera_x += forward_x * move_speed;
state.camera_y += forward_y * move_speed;
}
if (key_down('S')) {
state.camera_x -= forward_x * move_speed;
state.camera_y -= forward_y * move_speed;
}
if (key_down('D')) {
state.camera_x += right_x * move_speed;
state.camera_y += right_y * move_speed;
}
if (key_down('A')) {
state.camera_x -= right_x * move_speed;
state.camera_y -= right_y * move_speed;
}
if (key_down('R')) {
state.camera_z += move_speed;
}
if (key_down('F')) {
state.camera_z -= move_speed;
}
panda_window->get_camera_group().set_pos(state.camera_x, state.camera_y, state.camera_z);
panda_window->get_camera_group().set_hpr(state.heading, state.pitch, 0.0F);
model.set_pos(state.model_position[0], state.model_position[1], state.model_position[2]);
model.set_hpr(state.model_rotation[0], state.model_rotation[1], state.model_rotation[2]);
model.set_scale(state.model_scale[0], state.model_scale[1], state.model_scale[2]);
if (state.auto_rotate) {
state.model_rotation[0] += state.rotation_speed * delta_seconds;
}
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
render_editor_ui(state);
ImGui::Render();
g_pending_draw_data = ImGui::GetDrawData();
framework.do_frame(nullptr);
}
if (g_overlay_region != nullptr) {
g_overlay_region->clear_draw_callback();
if (panda_window->get_graphics_output() != nullptr) {
panda_window->get_graphics_output()->remove_display_region(g_overlay_region);
}
g_overlay_region = nullptr;
}
g_pending_draw_data = nullptr;
if (g_previous_wnd_proc != nullptr) {
SetWindowLongPtr(g_panda_hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(g_previous_wnd_proc));
g_previous_wnd_proc = nullptr;
}
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
framework.close_window(panda_window);
framework.close_framework();
return 0;
#else
log_step("Panda3D or Dear ImGui support is not enabled in this build.");
return 1;
#endif
}
Reference in New Issue View Git Blame Copy Permalink