okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad38d51c295a8b1b9f95bf1d6f42994de3696f76
EVEngine/test/window_cpp.cpp
T
西风逍遥游 34d1fdb63b refactor(modules): clear remaining back-edges and split the largest TUs (#127) 
* chore(ci): add clang-format gate, CODEOWNERS and agent collaboration rules

* refactor(modules): clear remaining back-edges and split the largest TUs

Three known dependency back-edges are gone (module_depgraph.py KNOWN_BACK_EDGES
is now empty; --check passes with 0 violations, 0 cycles):

- window -> graphics: window queries the new IWindowSurfaceHost capability
  (common/WindowSurfaceHost.h) instead of holding a Graphics pointer;
  Window::setGraphics was removed and all call sites updated.
- window -> image: Window::setIcon was replaced by setIconRGBA(const uint8_t*,
  w, h); the window no longer decodes ImageData.
- scene -> graphics: pickScreenAt / collectFrustumIdsAt implementations moved
  to graphics/ScenePicking.cpp (graphics -> scene is a legal downward edge);
  scene now depends only on spatial.

TU splits (pure moves, verified identical method sets and brace balance):

- vulkan/Graphics.cpp (5118 lines) -> Graphics.cpp (lifecycle), GraphicsPipeline,
  Graphics2D, Graphics3D, GraphicsMesh + shared GraphicsInternal.h.
- scene/Scene.cpp -> Scene.cpp (script layer / host lifecycle / serialization)
  + SceneNodes.cpp + shared SceneInternal.h.

Verified with a real build (MSVC 19.51, prebuilt third-party): full build green;
window.* and Scene.* suites pass, including scene picking/culling and GPU cases.

* refactor(graphics): narrow Graphics interfaces and clear public-header leaks

Step 4 — interface segregation:
- New lean interfaces: IGraphics2D, IGraphics3D, IResourceFactory, IPostFX
  (pure virtuals, forward-declared types only; graphics/Color.h extracted from
  Canvas.h so modules that only need the color type stop pulling Canvas.h).
- Graphics now implements all four facets; consumers can depend on the narrow
  interface they use instead of the 129-method god class.
- Migrated voxel (VoxelWorld::drawVisible -> IGraphics3D*) and model3d
  (ModelRenderer::buildRenderable(s) -> IResourceFactory&).
- Graphics.h slims from 24 sub-header includes to a handful of small type
  headers + forward declarations; the destructor moved out-of-line so
  unique_ptr effect members are destroyed where types are complete.

Step 5 — header leaks (module_depgraph.py '*' marks: 14 -> 7):
- map/TileLayer.h, particles/ParticleEmitter.h, avatar/AvatarInstance.h,
  animation/SpineAnim.h, map/TileSystem.h, model3d/ModelData.h,
  model3d/ModelRenderer.h, audio/Audio.h + Source.h, image/ImageData.h +
  Image.h, dialogue/Dialogue.h, procgen Palette/OutputSpec/TextureRecipe/
  PbrMaterial -> forward declarations, includes moved to .cpp.
- voxel/VoxelWorld.h: terrain sampler Pimpl'd (unique_ptr + out-of-line
  destructor), removing the procgen header dependency.
- gpgpu/vulkan backend headers stop pulling graphics/vulkan/Graphics.h.
- Remaining '*' marks are deliberate: tiny POD/enum headers (GridConfig,
  MapObject, BlendMode, Color), an internal backend header
  (GraphicsInternal.h -> filesystem), and lean interface references.

Verified with a full clean build (MSVC) and tests: window/Scene/voxel/
RenderSystem/Quad/shader/TextureSampler/resourceLifetime pass; broad suite
only shows the pre-existing PHYSFS-init filesystem-environment failures.

* feat(resources): revive ResourceManager as unified IAssetReloader-backed cache

* fix(resources): leak ResourceManager singleton to avoid exit-time teardown crashes

Cached CPU resources may own third-party handles (FreeType faces, Assimp
scenes, image decode handlers) whose libraries are torn down at process
exit in an unspecified TU order; destroying cached entries from the
singleton destructor can segfault at exit (seen on CI Windows in
model3d.materialApi.objMtl). Keep the singleton alive until OS reclaim;
explicit unload()/clear() still release entries during the run.

* refactor(devtools): consume business modules through capability interfaces

DevTools / cmdline no longer include business-module headers, so trimming
scene / physics / procgen / particles / audio / ui / graphics no longer
requires disabling devtools, and devtools can be switched off with
-DEVENGINE_MODULE_DEVTOOLS=OFF.

New capability interfaces in common/:
- ISceneQuery (scene) - host/node inspection + mutation + transform sync
- IRenderCapture (graphics) - render status, PNG capture, camera control,
  visible-entity snapshot, entity-ID mask, G-buffer PNGs
- IPhysicsQuery (physics) - 2D world lifecycle + ray casts
- IProcgenQuery (procgen) - recipe listing, map/mesh generation
- IParticlesQuery (particles) - emitter status + one-shot emit
- IAudioQuery (audio) - volume / stop-all
- IEditorHost (ui) - declarative editor host (used by cmdline too)

Providers register in their module constructors. DevTools rewires McpServer
(render/scene/procgen/physics/particles/audio/host tools), SceneInspect
(now delegates to ISceneQuery + IRenderCapture) and RenderVision (uses
IRenderCapture::capturePngDataUrl); cmdline/Mcp.cpp uses IEditorHost.

manifest: devtools DEPS graphics scene physics procgen particles audio ui
image event filesystem -> event; cmdline DEPS filesystem ui -> filesystem.

Verified: full build green; devtools.mcp.* tests pass; broad suite shows
only the pre-existing PHYSFS-init filesystem-environment failures.

* style: apply clang-format to changed lines after dev merge

* fix(webgpu): include RenderControl/TextureSampler explicitly after Graphics.h slimming

* fix(webgpu): provide newFont/print stubs to satisfy IGraphics2D/IResourceFactory vtables

* fix(common): make ProcgenQuery.h self-sufficient (cstdint/utility for GCC)
2026-08-20 05:53:33 +08:00

369 lines
11 KiB
C++
Raw Blame History

#include <cstdlib>
#include <vector>
#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "graphics/AmbientOcclusion.h"
#include "graphics/AntiAliasing.h"
#include "graphics/Canvas.h"
#include "graphics/DrawItem2D.h"
#include "graphics/Font.h"
#include "graphics/GBuffer.h"
#include "graphics/GlobalIllumination.h"
#include "graphics/Graphics.h"
#include "graphics/Grass.h"
#include "graphics/Light.h"
#include "graphics/Material.h"
#include "graphics/Mesh.h"
#include "graphics/Outline.h"
#include "graphics/Quad.h"
#include "graphics/RenderControl.h"
#include "graphics/ScreenSpaceReflection.h"
#include "graphics/Shader.h"
#include "graphics/Texture.h"
#include "graphics/Volumetric.h"
#include "graphics/Water.h"
#include "graphics/Waterfall.h"
#include "image/ImageData.h"
#include "window/Window.h"
namespace {
using WindowSettings = eve::window::WindowSettings;
void openWindow(eve::window::Window*& win, eve::graphics::Graphics*& gfx, int w = 320, int h = 240) {
win = eve::window::Window::create();
gfx = eve::graphics::Graphics::create();
REQUIRE(win != nullptr);
REQUIRE(gfx != nullptr);
WindowSettings s;
s.width = static_cast<uint16_t>(w);
s.height = static_cast<uint16_t>(h);
s.centered = true;
s.fullscreen = false;
s.resizable = true;
REQUIRE(win->setWindowSettings(s));
}
WindowSettings makeSettings(int w, int h) {
WindowSettings s;
s.width = static_cast<uint16_t>(w);
s.height = static_cast<uint16_t>(h);
s.centered = true;
s.fullscreen = false;
s.desktop_mode = true;
s.resizable = true;
s.borderless = false;
s.vsync = 1;
s.minwidth = 64;
s.minheight = 64;
return s;
}
void checkCoreSettings(const WindowSettings& expected, const WindowSettings& actual) {
CHECK_EQ(actual.width, expected.width);
CHECK_EQ(actual.height, expected.height);
CHECK_EQ(actual.centered, expected.centered);
CHECK_EQ(actual.fullscreen, expected.fullscreen);
CHECK_EQ(actual.desktop_mode, expected.desktop_mode);
CHECK_EQ(actual.resizable, expected.resizable);
CHECK_EQ(actual.borderless, expected.borderless);
CHECK_EQ(actual.vsync, expected.vsync);
CHECK_EQ(actual.minwidth, expected.minwidth);
CHECK_EQ(actual.minheight, expected.minheight);
}
} // namespace
TEST_CASE("window.setWindowSettingsRoundTrip") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
WindowSettings s = makeSettings(320, 240);
REQUIRE(win->setWindowSettings(s));
checkCoreSettings(s, win->getWindowSettings());
CHECK(win->getHandle() != nullptr);
win->close();
}
TEST_CASE("window.setSizeGetDimensions") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
win->setSize(400, 300);
CHECK_EQ(win->getWidth(), 400);
CHECK_EQ(win->getHeight(), 300);
CHECK_EQ(win->getWindowSettings().width, 400u);
CHECK_EQ(win->getWindowSettings().height, 300u);
win->setSize(128, 96);
CHECK_EQ(win->getWidth(), 128);
CHECK_EQ(win->getHeight(), 96);
win->close();
}
TEST_CASE("window.setFullscreenDesktopRoundTrip") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
CHECK(!win->getWindowSettings().fullscreen);
// GitHub macOS runners (and some headless hosts) intermittently refuse
// SDL_WINDOW_FULLSCREEN_DESKTOP; treat that as an environment skip.
if (!win->setFullscreenDesktop(true)) {
CHECK(!win->getWindowSettings().fullscreen);
win->close();
return;
}
CHECK(win->getWindowSettings().fullscreen);
CHECK(win->getWindowSettings().desktop_mode);
CHECK(win->getHandle() != nullptr);
REQUIRE(win->setFullscreenDesktop(false));
CHECK(!win->getWindowSettings().fullscreen);
CHECK_EQ(win->getWidth(), 320);
CHECK_EQ(win->getHeight(), 240);
win->close();
}
TEST_CASE("window.setFullscreenDesktopRoundTripUsesSettings") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
WindowSettings s = win->getWindowSettings();
s.desktop_mode = true;
REQUIRE(win->setWindowSettings(s));
if (!win->setFullscreenDesktop(true)) {
CHECK(!win->getWindowSettings().fullscreen);
win->close();
return;
}
CHECK(win->getWindowSettings().fullscreen);
CHECK(win->getWindowSettings().desktop_mode);
REQUIRE(win->setFullscreenDesktop(false));
CHECK(!win->getWindowSettings().fullscreen);
win->close();
}
TEST_CASE("window.closeClearsHandleAndBlocksFullscreen") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
REQUIRE(win->getHandle() != nullptr);
win->close();
CHECK(win->getHandle() == nullptr);
CHECK(!win->setFullscreenDesktop(true));
CHECK(!win->setFullscreenExclusive(false));
}
TEST_CASE("window.setWindowSettingsRecreatesAfterClose") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
win->close();
CHECK(win->getHandle() == nullptr);
WindowSettings s = makeSettings(320, 240);
REQUIRE(win->setWindowSettings(s));
CHECK(win->getHandle() != nullptr);
checkCoreSettings(s, win->getWindowSettings());
CHECK_EQ(win->getWidth(), 320);
CHECK_EQ(win->getHeight(), 240);
win->close();
}
TEST_CASE("window.zeroSizeUsesDesktopDimensions") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
win = eve::window::Window::create();
gfx = eve::graphics::Graphics::create();
REQUIRE(win != nullptr);
REQUIRE(gfx != nullptr);
WindowSettings s = makeSettings(0, 0);
REQUIRE(win->setWindowSettings(s));
CHECK_GT(win->getWidth(), 0);
CHECK_GT(win->getHeight(), 0);
CHECK_GT(win->getWindowSettings().width, 0u);
CHECK_GT(win->getWindowSettings().height, 0u);
win->close();
}
TEST_CASE("window.isOpenAfterCreateAndClose") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
CHECK(win->isOpen());
win->close();
CHECK(!win->isOpen());
}
TEST_CASE("window.titleAndPositionAndVSync") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
win->setWindowTitle("eve-window-test");
CHECK_EQ(win->getWindowTitle(), std::string("eve-window-test"));
win->setVSync(0);
CHECK_EQ(win->getVSync(), 0);
win->setVSync(1);
CHECK_EQ(win->getVSync(), 1);
int x = 0, y = 0, display = -1;
win->getPosition(x, y, display);
CHECK_GE(display, 0);
win->setPosition(40, 50, display);
int x2 = 0, y2 = 0, d2 = -1;
win->getPosition(x2, y2, d2);
CHECK_EQ(d2, display);
CHECK_LE(std::abs(x2 - 40), 32);
CHECK_LE(std::abs(y2 - 50), 32);
CHECK(win->isVisible());
win->close();
}
TEST_CASE("window.titleCachesBeforeOpen") {
auto* win = eve::window::Window::create();
REQUIRE(win != nullptr);
win->setWindowTitle("cached-title");
CHECK_EQ(win->getWindowTitle(), std::string("cached-title"));
CHECK(!win->isOpen());
}
TEST_CASE("window.displayQueries") {
auto* win = eve::window::Window::create();
REQUIRE(win != nullptr);
int n = win->getDisplayCount();
CHECK_GT(n, 0);
std::string name = win->getDisplayName(0);
CHECK(!name.empty());
std::string ori = win->getDisplayOrientation(0);
const bool validOrientation = ori == "unknown" || ori == "landscape" || ori == "landscapeFlipped"
|| ori == "portrait" || ori == "portraitFlipped";
CHECK(validOrientation);
auto sizes = win->getFullscreenSizes(0);
CHECK_GT(sizes.size(), 0u);
int dw = 0, dh = 0;
win->getDesktopDimensions(0, dw, dh);
CHECK_GT(dw, 0);
CHECK_GT(dh, 0);
CHECK(win->getDisplayName(-1).empty());
CHECK_EQ(win->getDisplayOrientation(999), std::string("unknown"));
CHECK(win->getFullscreenSizes(999).empty());
int zw = 1, zh = 1;
win->getDesktopDimensions(999, zw, zh);
CHECK_EQ(zw, 0);
CHECK_EQ(zh, 0);
}
TEST_CASE("window.pixelSizeAndDpiRoundTrip") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
CHECK_GT(win->getPixelWidth(), 0);
CHECK_GT(win->getPixelHeight(), 0);
CHECK_GT(win->getNativeDPIScale(), 0.0);
double px = 0, py = 0;
win->toPixelsXY(10.0, 20.0, px, py);
double wx = 0, wy = 0;
win->fromPixelsXY(px, py, wx, wy);
CHECK_EQ(wx, 10.0);
CHECK_EQ(wy, 20.0);
double x = 5.0, y = 6.0;
win->windowToPixelCoords(&x, &y);
win->pixelToWindowCoords(&x, &y);
CHECK_EQ(x, 5.0);
CHECK_EQ(y, 6.0);
win->close();
CHECK_EQ(win->getPixelWidth(), 0);
CHECK_EQ(win->getPixelHeight(), 0);
CHECK_EQ(win->getDPIScale(), 1.0);
}
TEST_CASE("window.requestAttentionNoCrash") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
win->requestAttention(false);
win->requestAttention(true);
win->close();
win->requestAttention(false);
}
TEST_CASE("window.setIconRGBA") {
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
static std::vector<uint8_t> pixels(32 * 32 * 4, 0);
for (size_t i = 0; i < pixels.size(); i += 4) {
pixels[i] = 255; // R
pixels[i + 3] = 255; // A
}
CHECK(win->setIconRGBA(pixels.data(), 32, 32));
// Recreating the window (e.g. via setWindowSettings) must re-apply the icon.
WindowSettings s = makeSettings(320, 240);
REQUIRE(win->setWindowSettings(s));
CHECK(win->getHandle() != nullptr);
win->close();
}
TEST_CASE("window.setIconRGBANullFails") {
auto* win = eve::window::Window::create();
REQUIRE(win != nullptr);
CHECK(!win->setIconRGBA(nullptr, 32, 32));
}
TEST_CASE("window.showMessageBoxOptional") {
const char* run = std::getenv("EVENGINE_TEST_MSGBOX");
if (!run || std::string(run) != "1") {
return;
}
eve::window::Window* win = nullptr;
eve::graphics::Graphics* gfx = nullptr;
openWindow(win, gfx, 320, 240);
CHECK(win->showMessageBox("t", "m", "info", true));
eve::window::Window::MessageBoxData data;
data.type = "warning";
data.title = "t";
data.message = "m";
data.buttons = {"OK", "Cancel"};
data.enterButtonIndex = 0;
data.escapeButtonIndex = 1;
data.attachToWindow = true;
int idx = win->showMessageBoxData(data);
CHECK_GE(idx, 0);
win->close();
}
Reference in new issue View Git Blame Copy Permalink