okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad38d51c295a8b1b9f95bf1d6f42994de3696f76
EVEngine/test/renderflow.cpp
T

454 lines
16 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "devtools/RenderFlow.hpp"
#include "common/RenderTrace.h"
#include "common/Exception.h"
#include <string>
#include <vector>
using namespace eve::dev;
static bool pathHas(const RenderSliceResult& s, RenderEventKind kind, const char* nameOrDetail) {
for (const auto& e : s.path) {
if (e.kind != kind) continue;
if (e.name == nameOrDetail || e.detail == nameOrDetail) return true;
}
return false;
}
// ---------------------------------------------------------------------------
// Core slicing
// ---------------------------------------------------------------------------
TEST_CASE("devtools.renderflow.passAndBindSlice") {
RenderFlow flow;
flow.frameBegin();
flow.passBegin("RenderSystem2D");
flow.target("screen");
flow.bind("texture", "hero");
flow.draw("drawTexturedRectShaderUV", "hero");
flow.error("draw failed: bad descriptor");
flow.passEnd("RenderSystem2D");
flow.frameEnd();
RenderSliceResult slice = flow.sliceBackward({});
CHECK(!slice.passes.empty());
CHECK_EQ(slice.passes.back(), std::string("RenderSystem2D"));
CHECK(pathHas(slice, RenderEventKind::Bind, "hero"));
CHECK(pathHas(slice, RenderEventKind::Draw, "drawTexturedRectShaderUV"));
CHECK(pathHas(slice, RenderEventKind::Error, "error"));
const std::string report = flow.formatErrorReport("draw failed: bad descriptor");
CHECK(report.find("Render Pipeline Trace") != std::string::npos);
CHECK(report.find("RenderSystem2D") != std::string::npos);
CHECK(report.find("hero") != std::string::npos);
}
TEST_CASE("devtools.renderflow.nestedPasses") {
RenderFlow flow;
flow.frameBegin();
flow.passBegin("RenderSystem3D");
flow.passBegin("ShadowPass");
flow.bind("mesh", "caster");
flow.draw("drawMeshShadow", "cascade");
flow.passEnd("ShadowPass");
flow.bind("mesh", "rock");
flow.bind("texture", "albedo");
flow.draw("drawMeshShader", "default");
flow.error("pipeline create failed");
// still inside RenderSystem3D
RenderSliceResult slice = flow.sliceBackward({});
REQUIRE(slice.passes.size() >= 1u);
CHECK_EQ(slice.passes[0], std::string("RenderSystem3D"));
CHECK(pathHas(slice, RenderEventKind::Draw, "drawMeshShader"));
const bool sawMeshOrAlbedo = pathHas(slice, RenderEventKind::Bind, "rock") ||
pathHas(slice, RenderEventKind::Bind, "albedo");
CHECK(sawMeshOrAlbedo);
}
TEST_CASE("devtools.renderflow.resourceFocusedCriterion") {
RenderFlow flow;
flow.passBegin("RenderSystem2D");
flow.bind("texture", "bg");
flow.draw("drawTexturedRectShaderUV", "bg");
flow.bind("texture", "hero");
flow.draw("drawTexturedRectShaderUV", "hero");
flow.error("hero atlas missing");
RenderSliceCriterion c;
c.resource = "hero";
RenderSliceResult slice = flow.sliceBackward(c);
CHECK(pathHas(slice, RenderEventKind::Bind, "hero"));
CHECK(pathHas(slice, RenderEventKind::Error, "error"));
}
TEST_CASE("devtools.renderflow.eventIdSeed") {
RenderFlow flow;
flow.passBegin("P");
flow.bind("shader", "s1");
const uint32_t drawId = [&]() {
flow.draw("drawSolidRect", "solid");
return flow.events().back().id;
}();
flow.bind("shader", "s2");
flow.draw("drawSolidRect", "solid2");
flow.error("later");
RenderSliceCriterion c;
c.eventId = drawId;
RenderSliceResult slice = flow.sliceBackward(c);
CHECK(pathHas(slice, RenderEventKind::Draw, "drawSolidRect"));
// Seeded on first draw — should see s1 bind via data deps / parent chain.
bool sawS1 = pathHas(slice, RenderEventKind::Bind, "s1");
CHECK(sawS1);
}
TEST_CASE("devtools.renderflow.emptySlice") {
RenderFlow flow;
RenderSliceResult slice = flow.sliceBackward({});
CHECK(slice.eventIds.empty());
CHECK(slice.summary.find("empty") != std::string::npos);
}
TEST_CASE("devtools.renderflow.clear") {
RenderFlow flow;
flow.frameBegin();
flow.draw("x", "y");
flow.clear();
CHECK_EQ(flow.eventCount(), 0u);
CHECK(flow.event(1) == nullptr);
}
TEST_CASE("devtools.renderflow.drawWithoutBinds") {
RenderFlow flow;
flow.passBegin("RenderSystem2D");
flow.draw("drawSolidRect", "solid");
flow.error("clear color invalid");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::PassBegin, "RenderSystem2D"));
CHECK(pathHas(slice, RenderEventKind::Draw, "drawSolidRect"));
}
TEST_CASE("devtools.renderflow.errorWithoutDraw") {
RenderFlow flow;
flow.passBegin("Present");
flow.error("swapchain recreate failed");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Error, "error"));
CHECK(pathHas(slice, RenderEventKind::PassBegin, "Present"));
}
TEST_CASE("devtools.renderflow.multipleErrorsSeedsLast") {
RenderFlow flow;
flow.passBegin("A");
flow.error("first");
flow.passEnd("A");
flow.passBegin("B");
flow.bind("mesh", "m");
flow.error("second");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::PassBegin, "B"));
CHECK(pathHas(slice, RenderEventKind::Bind, "m"));
// Active passes at last error should be B only.
REQUIRE(!slice.passes.empty());
CHECK_EQ(slice.passes.back(), std::string("B"));
}
TEST_CASE("devtools.renderflow.targetSwitch") {
RenderFlow flow;
flow.passBegin("RenderSystem2D");
flow.target("screen");
flow.draw("drawSolidRect", "a");
flow.target("canvas");
flow.draw("drawSolidRect", "b");
flow.error("canvas size 0");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Target, "canvas"));
}
TEST_CASE("devtools.renderflow.bindKinds") {
RenderFlow flow;
flow.passBegin("RenderSystem3D");
flow.bind("texture", "albedo");
flow.bind("shader", "pbr");
flow.bind("mesh", "rock");
flow.bind("font", "ui");
flow.bind("canvas", "offscreen");
flow.draw("drawMeshShader", "pbr");
flow.error("descriptor");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Bind, "albedo"));
const bool sawShaderOrDraw = pathHas(slice, RenderEventKind::Bind, "pbr") ||
pathHas(slice, RenderEventKind::Draw, "drawMeshShader");
CHECK(sawShaderOrDraw);
CHECK(pathHas(slice, RenderEventKind::Bind, "rock"));
}
TEST_CASE("devtools.renderflow.twoFramesErrorInSecond") {
RenderFlow flow;
flow.frameBegin();
flow.passBegin("RenderSystem2D");
flow.draw("drawSolidRect", "ok");
flow.passEnd("RenderSystem2D");
flow.frameEnd();
flow.frameBegin();
flow.passBegin("RenderSystem2D");
flow.bind("texture", "bad");
flow.draw("drawTexturedRectShaderUV", "bad");
flow.error("oom");
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Bind, "bad"));
CHECK(pathHas(slice, RenderEventKind::Error, "error"));
}
TEST_CASE("devtools.renderflow.formatReportTruncates") {
RenderFlow flow;
flow.passBegin("P");
for (int i = 0; i < 80; ++i) {
flow.bind("texture", ("t" + std::to_string(i)).c_str());
flow.draw("draw", ("d" + std::to_string(i)).c_str());
}
flow.error("boom");
const std::string report = flow.formatErrorReport("boom");
CHECK(report.find("...") != std::string::npos);
CHECK(report.find("render slice:") != std::string::npos);
}
TEST_CASE("devtools.renderflow.passEndPopsStack") {
RenderFlow flow;
flow.passBegin("Outer");
flow.passBegin("Inner");
flow.passEnd("Inner");
flow.error("after inner");
RenderSliceResult slice = flow.sliceBackward({});
REQUIRE(slice.passes.size() == 1u);
CHECK_EQ(slice.passes[0], std::string("Outer"));
}
TEST_CASE("devtools.renderflow.nullNameArgs") {
RenderFlow flow;
flow.passBegin(nullptr);
flow.bind(nullptr, nullptr);
flow.draw(nullptr, nullptr);
flow.target(nullptr);
flow.error(nullptr);
CHECK(flow.eventCount() >= 5u);
RenderSliceResult slice = flow.sliceBackward({});
CHECK(!slice.eventIds.empty());
}
// ---------------------------------------------------------------------------
// Ring buffer
// ---------------------------------------------------------------------------
TEST_CASE("devtools.renderflow.ringBuffer") {
RenderFlow flow;
flow.setMaxEvents(16);
for (int i = 0; i < 40; ++i) flow.draw("drawSolidRect", "solid");
CHECK_EQ(flow.eventCount(), 16u);
CHECK(flow.event(flow.events().front().id - 1) == nullptr);
}
TEST_CASE("devtools.renderflow.setMaxEventsClampShrink") {
RenderFlow flow;
flow.setMaxEvents(1);
CHECK_EQ(flow.maxEvents(), 16u);
for (int i = 0; i < 20; ++i) flow.draw("d", "x");
CHECK_EQ(flow.eventCount(), 16u);
flow.setMaxEvents(16);
CHECK_EQ(flow.eventCount(), 16u);
}
TEST_CASE("devtools.renderflow.ringKeepsRecentErrorContext") {
RenderFlow flow;
flow.setMaxEvents(16);
for (int i = 0; i < 40; ++i) {
flow.passBegin("Old");
flow.draw("old", "x");
flow.passEnd("Old");
}
flow.passBegin("Hot");
flow.bind("mesh", "last");
flow.draw("drawMeshShader", "last");
flow.error("fail");
CHECK_EQ(flow.eventCount(), 16u);
RenderSliceResult slice = flow.sliceBackward({});
const bool sawHotOrError = pathHas(slice, RenderEventKind::PassBegin, "Hot") ||
pathHas(slice, RenderEventKind::Error, "error");
CHECK(sawHotOrError);
const bool sawLast = pathHas(slice, RenderEventKind::Bind, "last") ||
pathHas(slice, RenderEventKind::Draw, "drawMeshShader");
CHECK(sawLast);
}
TEST_CASE("devtools.renderflow.oneInOneOut") {
RenderFlow flow;
flow.setMaxEvents(16);
for (int i = 0; i < 16; ++i) flow.draw("d", "x");
const uint32_t front = flow.events().front().id;
flow.draw("d", "new");
CHECK_EQ(flow.eventCount(), 16u);
CHECK_EQ(flow.events().front().id, front + 1);
CHECK_EQ(flow.events().back().detail, std::string("new"));
}
// ---------------------------------------------------------------------------
// Hooks / Exception / RAII
// ---------------------------------------------------------------------------
TEST_CASE("devtools.renderflow.hookNoopWhenUnset") {
eve::debug::setRenderTracer(nullptr);
eve::debug::rtFrameBegin();
eve::debug::rtPassBegin("X");
eve::debug::rtBind("texture", "t");
eve::debug::rtDraw("draw", "d");
eve::debug::rtPassEnd("X");
eve::debug::rtFrameEnd();
eve::debug::rtError("no tracer");
CHECK(eve::debug::renderTracer() == nullptr);
}
TEST_CASE("devtools.renderflow.hookViaException") {
RenderFlow flow;
eve::debug::setRenderTracer(&flow);
eve::debug::rtFrameBegin();
eve::debug::rtPassBegin("RenderSystem3D");
eve::debug::rtBind("mesh", "rock");
eve::debug::rtDraw("drawMeshShader", "default");
try {
throw eve::Exception("failed to create mesh3d-style pipeline");
} catch (const eve::Exception& e) {
const std::string report = flow.formatErrorReport(e.what());
CHECK(report.find("Render Pipeline Trace") != std::string::npos);
CHECK(report.find("RenderSystem3D") != std::string::npos);
const bool hasDrawOrBind = report.find("drawMeshShader") != std::string::npos ||
report.find("rock") != std::string::npos;
CHECK(hasDrawOrBind);
CHECK(std::string(e.what()).find("mesh3d") != std::string::npos);
}
eve::debug::setRenderTracer(nullptr);
CHECK(eve::debug::renderTracer() == nullptr);
}
TEST_CASE("devtools.renderflow.exceptionWithoutTracer") {
eve::debug::setRenderTracer(nullptr);
try {
throw eve::Exception("newTexture: invalid args");
} catch (const eve::Exception& e) {
CHECK(std::string(e.what()).find("newTexture") != std::string::npos);
}
}
TEST_CASE("devtools.renderflow.passScopeRAII") {
RenderFlow flow;
eve::debug::setRenderTracer(&flow);
{
eve::debug::RenderPassScope scope("ScopedPass");
eve::debug::rtDraw("inside", "x");
}
// After scope, pass should be ended.
bool sawBegin = false, sawEnd = false;
for (const auto& e : flow.events()) {
if (e.kind == RenderEventKind::PassBegin && e.name == "ScopedPass") sawBegin = true;
if (e.kind == RenderEventKind::PassEnd && e.name == "ScopedPass") sawEnd = true;
}
CHECK(sawBegin);
CHECK(sawEnd);
eve::debug::setRenderTracer(nullptr);
}
TEST_CASE("devtools.renderflow.rtHelpersForward") {
RenderFlow flow;
eve::debug::setRenderTracer(&flow);
eve::debug::rtFrameBegin();
eve::debug::rtTarget("screen");
eve::debug::rtBind("font", "main");
eve::debug::rtDraw("print", "text");
eve::debug::rtError("Graphics::drawText: font must not be null");
eve::debug::rtFrameEnd();
CHECK(flow.eventCount() >= 6u);
RenderSliceResult slice = flow.sliceBackward({});
const bool sawPrint = pathHas(slice, RenderEventKind::Bind, "main") ||
pathHas(slice, RenderEventKind::Draw, "print");
CHECK(sawPrint);
eve::debug::setRenderTracer(nullptr);
}
TEST_CASE("devtools.renderflow.shadowThenMainPass") {
RenderFlow flow;
flow.frameBegin();
flow.passBegin("RenderSystem3D");
for (int c = 0; c < 3; ++c) {
flow.passBegin("ShadowPass");
flow.bind("mesh", "caster");
flow.draw("drawMeshShadow", "cascade");
flow.passEnd("ShadowPass");
}
flow.target("screen");
flow.bind("mesh", "hero");
flow.bind("texture", "heroAlbedo");
flow.draw("drawMeshShader", "default");
flow.error("validation: unbound descriptor");
flow.passEnd("RenderSystem3D");
flow.frameEnd();
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Draw, "drawMeshShader"));
CHECK(pathHas(slice, RenderEventKind::PassBegin, "RenderSystem3D"));
const std::string report = flow.formatErrorReport("validation: unbound descriptor");
CHECK(report.find("Active passes") != std::string::npos);
}
TEST_CASE("devtools.renderflow.simulateSpriteBatch") {
RenderFlow flow;
flow.setMaxEvents(128);
flow.frameBegin();
flow.passBegin("RenderSystem2D");
flow.target("screen");
for (int i = 0; i < 50; ++i) {
flow.bind("texture", "sprite");
flow.draw("drawTexturedRectShaderUV", "textured");
}
flow.bind("texture", "boss");
flow.draw("drawTexturedRectLitUV", "lit2d");
flow.error("lit2d normal missing");
flow.passEnd("RenderSystem2D");
flow.passBegin("Present");
flow.passEnd("Present");
flow.frameEnd();
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Draw, "drawTexturedRectLitUV"));
CHECK(pathHas(slice, RenderEventKind::Error, "error"));
}
TEST_CASE("devtools.renderflow.rebindSameNameUpdatesReaching") {
RenderFlow flow;
flow.passBegin("P");
flow.bind("texture", "hero"); // v1
flow.draw("draw", "hero");
flow.bind("texture", "hero"); // v2 overwrite
flow.draw("draw", "hero");
flow.error("bad");
// Last draw should prefer the second bind; both may appear via control chain,
// but data deps for the last draw should include a Bind of hero.
RenderSliceResult slice = flow.sliceBackward({});
CHECK(pathHas(slice, RenderEventKind::Bind, "hero"));
}
TEST_CASE("devtools.renderflow.eventLookupContiguous") {
RenderFlow flow;
flow.setMaxEvents(16);
for (int i = 0; i < 20; ++i) flow.draw("d", "x");
const uint32_t lo = flow.events().front().id;
const uint32_t hi = flow.events().back().id;
for (uint32_t id = lo; id <= hi; ++id) {
REQUIRE(flow.event(id) != nullptr);
CHECK_EQ(flow.event(id)->id, id);
}
CHECK(flow.event(lo - 1) == nullptr);
CHECK(flow.event(hi + 1) == nullptr);
}
Reference in new issue View Git Blame Copy Permalink