copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

BVH draw cache working

Browse source
This commit is contained in:
Yousef Khadadeh 2025-07-20 15:24:44 +03:00
parent 1e51bf660f
commit caea747f1e
12 changed files with 223 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

78
src/DrawingProgram/DrawingProgram.cpp
View file

@ -28,11 +28,17 @@
#include <poolstl.hpp>
#endif
template <typename T> void parallel_loop_vector_any_type() {
template <typename ContainerType> void parallel_loop_container(ContainerType& c, std::function<void(typename ContainerType::value_type&)> func) {
#ifdef __EMSCRIPTEN__
std::for_each(c.begin(), c.end(), func);
#else
std::for_each(std::execution::par_unseq, c.begin(), c.end(), func);
#endif
}
DrawingProgram::DrawingProgram(World& initWorld):
world(initWorld),
compCache(*this),
components([&](){ return world.get_new_id(); }),
brushTool(*this),
eraserTool(*this),
@ -134,11 +140,7 @@ void DrawingProgram::allocate_collider_memory() {
}
void DrawingProgram::parallel_loop_all_components(std::function<void(const std::shared_ptr<CollabList<std::shared_ptr<DrawComponent>, ServerClientID>::ObjectInfo>&)> func) {
#ifdef __EMSCRIPTEN__
std::for_each(components.client_list().begin(), components.client_list().end(), func);
#else
std::for_each(std::execution::par_unseq, components.client_list().begin(), components.client_list().end(), func);
#endif
parallel_loop_container(components.client_list(), func);
}
void DrawingProgram::check_all_collisions_base(const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) {
@ -249,7 +251,6 @@ void DrawingProgram::tool_options_gui() {
default:
break;
}
t.gui.checkbox_field("Disable Draw Cache", "Disable Cache", &disableCache);
}
}
@ -358,7 +359,7 @@ void DrawingProgram::update() {
c->obj->update(*this);
}
compCache.update(components.client_list());
compCache.update();
}
void DrawingProgram::drag_drop_update() {
@ -446,7 +447,7 @@ void DrawingProgram::initialize_draw_data(cereal::PortableBinaryInputArchive& a)
auto newComp = DrawComponent::allocate_comp_type(t);
a(newComp->coords, *newComp);
components.init_emplace_back(id, newComp);
newComp->final_update(*this);
newComp->final_update_dont_invalidate_cache(*this);
}
}
@ -550,24 +551,23 @@ void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
c->obj->draw(canvas, drawData);
}
else {
if(disableCache) {
if(world.main.drawProgCache.disableDrawCache) {
parallel_loop_all_components([&](auto& c) {
c->obj->calculate_draw_transform(drawData);
});
for(auto& c : components.client_list())
c->obj->draw(canvas, drawData);
}
else {
for(auto& c : components.client_list())
c->obj->drawSetupData.shouldDraw = false;
compCache.traverse_bvh_run_function(drawData.cam.viewingAreaGenerousCollider, [&](DrawingProgramCache::BVHNode* node, const std::vector<CollabListType::ObjectInfoPtr>& comps) {
for(auto& c : comps)
c->obj->calculate_draw_transform(drawData);
return true;
});
SkCanvas* drawProgCacheCanvas = world.main.drawProgCache.surface->getCanvas();
drawProgCacheCanvas->clear(SkColor4f{0.0f, 0.0f, 0.0f, 0.0f});
compCache.refresh_all_draw_cache(drawProgCacheCanvas, drawData);
draw_components_to_canvas(drawProgCacheCanvas, drawData, false);
canvas->drawImage(world.main.drawProgCache.surface->makeTemporaryImage(), 0, 0);
}
for(auto& c : components.client_list()) {
c->obj->draw(canvas, drawData);
for(auto& c : components.client_list())
c->obj->updateDraw = false;
}
}
switch(controls.selectedTool) {
@ -603,6 +603,44 @@ void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
}
}
void DrawingProgram::draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, bool dontUseCache) {
for(auto& c : components.client_list())
c->obj->drawSetupData.shouldDraw = false;
std::vector<DrawingProgramCache::BVHNode*> cachedNodesToDraw;
compCache.traverse_bvh_run_function(drawData.cam.viewingAreaGenerousCollider, [&](DrawingProgramCache::BVHNode* node, const std::vector<CollabListType::ObjectInfoPtr>& comps) {
if(!dontUseCache && node && node->drawCache && node->coords.inverseScale <= drawData.cam.c.inverseScale) {
cachedNodesToDraw.emplace_back(node);
return false;
}
for(auto& c : comps)
c->obj->calculate_draw_transform(drawData);
return true;
});
for(uint64_t i = 0; i < components.client_list().size(); i++) {
auto& c = components.client_list()[i];
c->obj->draw(canvas, drawData);
for(DrawingProgramCache::BVHNode* bvhNode : cachedNodesToDraw) {
auto& drawCache = bvhNode->drawCache.value();
if(drawCache.lastDrawnComponentPlacement == i) {
canvas->save();
bvhNode->coords.transform_sk_canvas(canvas, drawData);
drawCache.lastRenderTime = std::chrono::steady_clock::now();
SkPaint p;
p.setBlendMode(SkBlendMode::kSrc);
// Note, no mipmaps here. You might need to generate mipmaps in the future (withDefaultMipmaps)
canvas->drawImage(drawCache.surface->makeTemporaryImage(), 0, 0, {SkFilterMode::kLinear, SkMipmapMode::kLinear}, &p);
canvas->restore();
}
}
}
}
Vector4f* DrawingProgram::get_foreground_color_ptr() {
return &controls.foregroundColor;
}

4
src/DrawingProgram/DrawingProgram.hpp
View file

@ -55,6 +55,7 @@ class DrawingProgram {
CollabListType components;
Vector4f* get_foreground_color_ptr();
private:
std::atomic<bool> addFileInNextFrame = false;
@ -79,7 +80,7 @@ class DrawingProgram {
void add_undo_place_component(uint64_t placement, const std::shared_ptr<DrawComponent>& comp);
void add_undo_place_components(uint64_t placement, const std::vector<std::shared_ptr<DrawComponent>>& comps);
bool disableCache = true;
void draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, bool dontUseCache);
BrushTool brushTool;
EraserTool eraserTool;
@ -135,4 +136,5 @@ class DrawingProgram {
friend class ScreenshotTool;
friend class EditTool;
friend class ImageTool;
friend class DrawingProgramCache;
};

112
src/DrawingProgram/DrawingProgramCache.cpp
View file

@ -1,8 +1,26 @@
#include "DrawingProgramCache.hpp"
#include "DrawingProgram.hpp"
#include "../World.hpp"
#include "../MainProgram.hpp"
#include <chrono>
#ifdef USE_SKIA_BACKEND_GRAPHITE
#include <include/gpu/graphite/Surface.h>
#elif USE_SKIA_BACKEND_GANESH
#include <include/gpu/ganesh/GrDirectContext.h>
#include <include/gpu/ganesh/SkSurfaceGanesh.h>
#endif
#define MAXIMUM_DRAW_CACHE_SURFACES 32
DrawingProgramCache::DrawingProgramCache(DrawingProgram& initDrawP):
drawP(initDrawP)
{}
void DrawingProgramCache::build(std::vector<CollabListType::ObjectInfoPtr> components) {
bvhRoot = BVHNode();
unsortedComponents.clear();
nodesWithCachedSurfaces.clear();
std::erase_if(components, [&](auto& c) {
if(!c->obj->worldAABB || c->obj->updateDraw) {
unsortedComponents.emplace_back(c);
@ -13,9 +31,9 @@ void DrawingProgramCache::build(std::vector<CollabListType::ObjectInfoPtr> compo
build_bvh_node(bvhRoot, components);
}
void DrawingProgramCache::update(const std::vector<CollabListType::ObjectInfoPtr>& components) {
if(unsortedComponents.size() >= 1)
build(components);
void DrawingProgramCache::update() {
if(unsortedComponents.size() >= 750)
build(drawP.components.client_list());
}
void DrawingProgramCache::add_component(const CollabListType::ObjectInfoPtr& c) {
@ -94,7 +112,9 @@ void DrawingProgramCache::build_bvh_node(BVHNode& node, std::vector<CollabListTy
for(auto& c : components)
node.bounds.include_aabb_in_bounds(c->obj->worldAABB.value());
if(components.size() < 50) {
build_bvh_node_coords_and_resolution(node);
if(components.size() < 100) {
node.components = components;
return;
}
@ -123,6 +143,31 @@ void DrawingProgramCache::build_bvh_node(BVHNode& node, std::vector<CollabListTy
}
}
void DrawingProgramCache::build_bvh_node_coords_and_resolution(BVHNode& node) {
// These are part of the draw cache data, but we're putting it out here, because:
// - We dont have to recalculate it every time we refresh the cache
// - Some of the data here is needed to determine whether to generate the cache in the first place
const int MAX_DIMENSION_RESOLUTION = 2000;
WorldVec cacheBoundDim = node.bounds.dim();
if(cacheBoundDim.x() > cacheBoundDim.y()) {
node.resolution.x() = MAX_DIMENSION_RESOLUTION;
node.resolution.y() = MAX_DIMENSION_RESOLUTION * static_cast<double>(cacheBoundDim.y() / cacheBoundDim.x());
}
else {
node.resolution.y() = MAX_DIMENSION_RESOLUTION;
node.resolution.x() = MAX_DIMENSION_RESOLUTION * static_cast<double>(cacheBoundDim.x() / cacheBoundDim.y());
}
node.coords.rotation = 0.0;
node.coords.pos = node.bounds.min;
// Not necessary, but we choose the number that had less operations done on it for more accuracy
if(node.resolution.x() > node.resolution.y())
node.coords.inverseScale = cacheBoundDim.x().divide_double(node.resolution.x());
else
node.coords.inverseScale = cacheBoundDim.y().divide_double(node.resolution.y());
}
void DrawingProgramCache::invalidate_cache_before_pos(uint64_t placementToInvalidateAt) {
// We could use worldAABB of component to invalidate specific areas. However, that comes with some issues:
// - The AABB couldve been changed from the last frame, so the current worldAABB doesnt actually represent what we should update
@ -137,3 +182,62 @@ void DrawingProgramCache::invalidate_cache_before_pos(uint64_t placementToInvali
return false;
});
}
void DrawingProgramCache::refresh_all_draw_cache(SkCanvas* canvas, const DrawData& drawData) {
std::deque<BVHNode*> nodeFlatList; // We want to render children before parents, so that parents can make use of the cached children
traverse_bvh_run_function(drawData.cam.viewingAreaGenerousCollider, [&](DrawingProgramCache::BVHNode* node, const std::vector<CollabListType::ObjectInfoPtr>& comps) {
if(node && node->coords.inverseScale <= drawData.cam.c.inverseScale) {
if(!node->drawCache)
nodeFlatList.emplace_front(node);
return false;
}
return true;
});
if(!nodeFlatList.empty())
refresh_draw_cache(*nodeFlatList.front(), drawData);
}
void DrawingProgramCache::refresh_draw_cache(BVHNode& bvhNode, const DrawData& drawData) {
if(bvhNode.children.empty() && bvhNode.components.empty())
return;
bvhNode.drawCache = std::nullopt;
BVHNode::DrawCacheData drawCache;
SkImageInfo imgInfo = SkImageInfo::MakeN32Premul(bvhNode.resolution.x(), bvhNode.resolution.y());
#ifdef USE_SKIA_BACKEND_GRAPHITE
drawCache.surface = SkSurfaces::RenderTarget(drawP.world.main.window.recorder(), imgInfo, skgpu::Mipmapped::kNo, drawP.world.main.window.defaultMSAASurfaceProps);
#elif USE_SKIA_BACKEND_GANESH
drawCache.surface = SkSurfaces::RenderTarget(drawP.world.main.window.ctx.get(), skgpu::Budgeted::kNo, imgInfo, drawP.world.main.window.defaultMSAASampleCount, &drawP.world.main.window.defaultMSAASurfaceProps);
#endif
if(!drawCache.surface)
throw std::runtime_error("[DrawingProgramCache::refresh_draw_cache] Could not make cache surface");
SkCanvas* cacheCanvas = drawCache.surface->getCanvas();
cacheCanvas->clear(SkColor4f{0, 0, 0, 0});
DrawData cacheDrawData = drawData;
cacheDrawData.cam.c = bvhNode.coords;
cacheDrawData.cam.changed = nullptr;
cacheDrawData.cam.set_viewing_area(bvhNode.resolution.cast<float>());
cacheDrawData.refresh_draw_optimizing_values();
drawP.draw_components_to_canvas(cacheCanvas, cacheDrawData, false);
drawCache.lastDrawnComponentPlacement = drawP.components.client_list().size() - 1;
drawCache.lastRenderTime = std::chrono::steady_clock::now();
bvhNode.drawCache = drawCache; // Set the drawCache after rendering is done, so that the draw function doesnt assume we have this node cached
while(nodesWithCachedSurfaces.size() >= MAXIMUM_DRAW_CACHE_SURFACES) {
BVHNode* leastUsedNode = *nodesWithCachedSurfaces.begin();
for(BVHNode* n : nodesWithCachedSurfaces) {
if(n->drawCache.value().lastRenderTime < leastUsedNode->drawCache.value().lastRenderTime)
leastUsedNode = n;
}
nodesWithCachedSurfaces.erase(leastUsedNode);
}
nodesWithCachedSurfaces.emplace(&bvhNode);
}

18
src/DrawingProgram/DrawingProgramCache.hpp
View file

@ -3,26 +3,37 @@
#include "../CollabList.hpp"
#include "../DrawComponents/DrawComponent.hpp"
#include <include/core/SkSurface.h>
#include <unordered_set>
class DrawingProgram;
class DrawingProgramCache {
public:
typedef CollabList<std::shared_ptr<DrawComponent>, ServerClientID> CollabListType;
void update(const std::vector<CollabListType::ObjectInfoPtr>& components);
DrawingProgramCache(DrawingProgram& initDrawP);
void update();
void erase_component(const CollabListType::ObjectInfoPtr& c);
void add_component(const CollabListType::ObjectInfoPtr& c);
void refresh_all_draw_cache(SkCanvas* canvas, const DrawData& drawData);
struct BVHNode {
SCollision::AABB<WorldScalar> bounds;
std::vector<CollabListType::ObjectInfoPtr> components;
std::vector<BVHNode> children;
CoordSpaceHelper coords;
Vector2i resolution;
struct DrawCacheData {
uint64_t lastDrawnComponentPlacement;
sk_sp<SkSurface> surface;
std::chrono::steady_clock::time_point lastRenderTime;
};
std::optional<DrawCacheData> drawCache;
};
std::vector<BVHNode*> nodesWithCachedSurfaces;
std::unordered_set<BVHNode*> nodesWithCachedSurfaces;
void traverse_bvh_run_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(BVHNode* node, const std::vector<CollabListType::ObjectInfoPtr>& components)> f);
@ -31,6 +42,8 @@ class DrawingProgramCache {
void invalidate_cache_before_pos(uint64_t placementToInvalidateAt);
private:
void build_bvh_node_coords_and_resolution(BVHNode& node);
void refresh_draw_cache(BVHNode& bvhNode, const DrawData& drawData);
void build(std::vector<CollabListType::ObjectInfoPtr> components);
@ -40,4 +53,5 @@ class DrawingProgramCache {
void build_bvh_node(BVHNode& node, std::vector<CollabListType::ObjectInfoPtr> components);
BVHNode bvhRoot;
std::vector<CollabListType::ObjectInfoPtr> unsortedComponents;
DrawingProgram& drawP;
};

2
src/DrawingProgram/ScreenshotTool.cpp
View file

@ -181,6 +181,8 @@ void ScreenshotTool::take_screenshot_area_hw(const sk_sp<SkSurface>& surface, Sk
WorldScalar newInverseScale = (vectorZoom.x() + vectorZoom.y()) * WorldScalar(0.5);
drawP.world.drawData.cam.set_based_on_properties(drawP.world, topLeft, newInverseScale, controls.coords.rotation);
drawP.world.drawData.cam.set_viewing_area(sectionImageSize.cast<float>());
drawP.world.drawData.refresh_draw_optimizing_values();
GridManager::GridType oldGridType = drawP.world.main.grid.gridType;
drawP.world.main.takingScreenshot = true;