Brings the agent-work branch tip onto master, keeping master's architecture and putting every agent-work feature on top of it: the window/GpuDevice/ RenderTarget split, explicit per-instance profilers instead of a global, the input layer with scroll sources and ends, the Widgets core and components (shared SelectionModel/Commands lists, popup stack, titled panels, prompt dialogs, file browser, kanban, outline tree, markdown, docking), the gallery on the new UI, the Objects explorer and interpreter fixes, the Taskboard, the Sketch2D render path and its tests and bench, and the headless Wayland runner the UI tests drive. No MODULES_BUILD_* switches are introduced: platform differences are plain if (ANDROID) / if (NOT ANDROID).
219 lines
7.2 KiB
C++
219 lines
7.2 KiB
C++
#include "Compositor.hpp"
|
|
#include "Document.hpp"
|
|
#include "LayerThumbnail.hpp"
|
|
#include "Profiler.hpp"
|
|
|
|
#include "UnitTest++/UnitTest++.h"
|
|
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <cstdio>
|
|
|
|
using namespace tp;
|
|
using namespace tp::sketch2d;
|
|
|
|
namespace {
|
|
struct Measure {
|
|
double ms = 0;
|
|
double dabPixels = 0;
|
|
|
|
template <typename Fn>
|
|
static Measure of(Document& document, Fn&& fn) {
|
|
Profiler profiler;
|
|
Profiler* previous = document.profiler();
|
|
document.setProfiler(&profiler);
|
|
profiler.setEnabled(true);
|
|
profiler.beginFrame();
|
|
const auto start = std::chrono::steady_clock::now();
|
|
fn();
|
|
const auto end = std::chrono::steady_clock::now();
|
|
profiler.endFrame();
|
|
document.setProfiler(previous);
|
|
Measure measure;
|
|
measure.ms = std::chrono::duration<double, std::milli>(end - start).count();
|
|
measure.dabPixels = profiler.counterTotal("brush.pixels_touched");
|
|
return measure;
|
|
}
|
|
};
|
|
|
|
void report(const char* scenario, const Measure& measure) {
|
|
std::printf("[engine-scenario] %-34s %9.2f ms %12.0f dab px\n", scenario, measure.ms, measure.dabPixels);
|
|
}
|
|
|
|
void fillLayer(Document& document, int4 size) {
|
|
Layer* layer = document.activeLayer();
|
|
for (int4 ty = 0; ty < size / kTileSize; ty++) {
|
|
for (int4 tx = 0; tx < size / kTileSize; tx++)
|
|
layer->tileAt({ tx, ty })->clear({ 0.2f, 0.4f, 0.6f, 1.0f });
|
|
}
|
|
document.commit("Fill");
|
|
}
|
|
|
|
Brush bigBrush(halnf size) {
|
|
Brush brush;
|
|
brush.apply(*findBrushPreset(BrushType::Round));
|
|
brush.setSize(size);
|
|
return brush;
|
|
}
|
|
}
|
|
|
|
SUITE(BenchEngineScenarios) {
|
|
TEST(TilesAre128PixelsLikeTheReference) { CHECK_EQUAL(128, kTileSize); }
|
|
|
|
TEST(BigBrushZoomedOutDab) {
|
|
Document document;
|
|
fillLayer(document, 1024);
|
|
document.setZoom(1.0f / 16.0f);
|
|
document.activeLayer()->levels().update(*document.activeLayer(), LayerLevels::levelForZoom(document.zoom()));
|
|
const Brush brush = bigBrush(1500);
|
|
const Measure stroke = Measure::of(document, [&]() {
|
|
for (int4 dab = 0; dab < 8; dab++)
|
|
document.stampBrushDab({ 2000.0f + (halnf) dab * 100.0f, 2000.0f }, brush, 1.0f);
|
|
});
|
|
report("8 dabs 1500px at zoom 1/16", stroke);
|
|
const Measure finish = Measure::of(document, [&]() { document.finishStroke("Paint"); });
|
|
report("finish that stroke", finish);
|
|
CHECK(finish.dabPixels > 0);
|
|
}
|
|
|
|
TEST(TransformDragOnLargeLayer) {
|
|
Document document;
|
|
fillLayer(document, 2048);
|
|
document.setZoom(1.0f / 8.0f);
|
|
REQUIRE CHECK(document.beginTransform());
|
|
const Measure measure = Measure::of(document, [&]() {
|
|
LayerTransform transform;
|
|
transform.pivot = { 1024, 1024 };
|
|
transform.offset = { 37, 11 };
|
|
transform.rotation = 0.1f;
|
|
document.previewTransform(transform);
|
|
});
|
|
report("transform move 2048 layer, zoom 1/8", measure);
|
|
document.cancelTransform();
|
|
CHECK(measure.ms >= 0);
|
|
}
|
|
|
|
TEST(BucketOnLargeLayer) {
|
|
Document document;
|
|
fillLayer(document, 2048);
|
|
const Measure measure = Measure::of(document, [&]() {
|
|
BucketSettings settings;
|
|
settings.allLayers = false;
|
|
(void) document.bucketFill({ 100, 100 }, { 1, 0, 0, 1 }, settings);
|
|
});
|
|
report("bucket 2048 layer", measure);
|
|
CHECK(measure.ms >= 0);
|
|
}
|
|
|
|
TEST(FilterOnLargeLayer) {
|
|
Document document;
|
|
fillLayer(document, 4096);
|
|
const Measure measure = Measure::of(document, [&]() { (void) document.applyFilter(Document::PixelFilter::Invert); });
|
|
report("invert 4096 layer", measure);
|
|
CHECK(measure.ms >= 0);
|
|
}
|
|
|
|
TEST(ThumbnailAfterAHugeZoomedOutStroke) {
|
|
Document document;
|
|
document.setZoom(1.0f / 32.0f);
|
|
document.activeLayer()->levels().update(*document.activeLayer(), 5);
|
|
const Brush brush = bigBrush(3000);
|
|
for (int4 dab = 0; dab < 40; dab++)
|
|
document.stampBrushDab({ (halnf) dab * 600.0f, (halnf) dab * 300.0f }, brush, 1.0f);
|
|
const Measure finish = Measure::of(document, [&]() { document.finishStroke("Paint"); });
|
|
report("finish huge stroke @1/32", finish);
|
|
std::vector<uint1> pixels;
|
|
const Measure thumbnail = Measure::of(document, [&]() {
|
|
document.whilePaintPaused([&]() {
|
|
pixels = LayerThumbnail::render(*document.activeLayer(), LayerThumbnail::documentBounds(document));
|
|
});
|
|
});
|
|
report("layer thumbnail right after", thumbnail);
|
|
const Measure settle = Measure::of(document, [&]() { document.settlePaint(); });
|
|
report("settle the full resolution", settle);
|
|
CHECK(!pixels.empty());
|
|
}
|
|
|
|
TEST(CompositeCostWhilePaintingZoomedOut) {
|
|
Document document;
|
|
document.setZoom(1.0f / 32.0f);
|
|
document.activeLayer()->levels().update(*document.activeLayer(), 5);
|
|
Compositor compositor;
|
|
const Brush brush = bigBrush(700);
|
|
for (int4 dab = 0; dab < 200; dab++) {
|
|
document.stampBrushDab({ (halnf) dab * 60.0f, (halnf) dab * 40.0f }, brush, 1.0f);
|
|
if (dab % 10 == 9) document.finishStroke("Paint");
|
|
}
|
|
document.settlePaint();
|
|
compositor.update(document, 5);
|
|
const Measure stroke = Measure::of(document, [&]() {
|
|
for (int4 dab = 0; dab < 20; dab++) {
|
|
document.stampBrushDab({ 6000.0f + (halnf) dab * 60.0f, 4000.0f }, brush, 1.0f);
|
|
document.whilePaintPaused([&]() {
|
|
compositor.update(document, 5);
|
|
compositor.update(document, 6);
|
|
});
|
|
}
|
|
});
|
|
report("20 dabs + composite each @1/32", stroke);
|
|
std::printf(
|
|
"[engine-scenario] last composited tiles %d pixels %d\n",
|
|
(int) compositor.lastCompositedTiles(),
|
|
(int) compositor.lastCompositedPixels()
|
|
);
|
|
document.finishStroke("Paint");
|
|
CHECK(true);
|
|
}
|
|
|
|
TEST(CompositeWhileTheEngineLandsAZoomedOutStroke) {
|
|
Document document;
|
|
document.setEngineThreads(4);
|
|
document.setZoom(1.0f / 32.0f);
|
|
document.activeLayer()->levels().update(*document.activeLayer(), 5);
|
|
Compositor compositor;
|
|
const Brush brush = bigBrush(700);
|
|
for (int4 dab = 0; dab < 300; dab++)
|
|
document.stampBrushDab({ (halnf) dab * 40.0f, (halnf) dab * 20.0f }, brush, 1.0f);
|
|
document.finishStroke("Paint");
|
|
double worst = 0;
|
|
double total = 0;
|
|
double applyMs = 0;
|
|
double downsampled = 0;
|
|
double level6Ms = 0;
|
|
double level5Ms = 0;
|
|
int4 frames = 0;
|
|
while (document.paintBacklog() > 0 && frames < 2000) {
|
|
const auto start = std::chrono::steady_clock::now();
|
|
document.submitPaint();
|
|
const auto applied = std::chrono::steady_clock::now();
|
|
document.whilePaintPaused([&]() {
|
|
const auto t0 = std::chrono::steady_clock::now();
|
|
compositor.update(document, 6);
|
|
downsampled += (double) document.activeLayer()->levels().lastDownsampledPixels();
|
|
const auto t1 = std::chrono::steady_clock::now();
|
|
compositor.update(document, 5);
|
|
const auto t2 = std::chrono::steady_clock::now();
|
|
level6Ms += std::chrono::duration<double, std::milli>(t1 - t0).count();
|
|
level5Ms += std::chrono::duration<double, std::milli>(t2 - t1).count();
|
|
});
|
|
applyMs += std::chrono::duration<double, std::milli>(applied - start).count();
|
|
const double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
|
|
worst = std::max(worst, ms);
|
|
total += ms;
|
|
frames++;
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(4));
|
|
}
|
|
std::printf(
|
|
"[engine-scenario] landing frames %d worst %.2f ms mean %.2f ms apply %.2f ms downsampled px/frame %.0f L6 %.2f "
|
|
"L5 %.2f\n",
|
|
frames,
|
|
worst,
|
|
total / std::max(frames, 1),
|
|
applyMs / std::max(frames, 1),
|
|
downsampled / std::max(frames, 1),
|
|
level6Ms / std::max(frames, 1),
|
|
level5Ms / std::max(frames, 1)
|
|
);
|
|
CHECK(frames > 0);
|
|
}
|
|
}
|