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

Remove colliderAllocated flag

Browse source
This commit is contained in:
Yousef Khadadeh 2025-07-28 14:25:28 +03:00
parent 0a75b0ada3
commit eb9db31d31
18 changed files with 44 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/DrawComponents/DrawBrushStroke.cpp
View file

@ -333,7 +333,7 @@ void DrawBrushStroke::create_triangles(const std::function<bool(Vector2f, Vector
}
}
void DrawBrushStroke::create_collider(bool colliderAllocated) {
void DrawBrushStroke::create_collider() {
using namespace SCollision;
if(d.points.empty())
return;
@ -348,12 +348,12 @@ void DrawBrushStroke::create_collider(bool colliderAllocated) {
collisionTree.calculate_bvh_recursive(strokeObjects);
precheckAABBLevels.clear();
add_precheck_aabb_level(0, collisionTree.children);
if(!colliderAllocated) {
collisionTree.objects.aabb.clear();
collisionTree.objects.circle.clear();
collisionTree.objects.triangle.clear();
collisionTree.children.clear();
}
collisionTree.objects.aabb.clear();
collisionTree.objects.circle.clear();
collisionTree.objects.triangle.clear();
collisionTree.children.clear();
calculate_world_bounds();
}
@ -376,10 +376,7 @@ void DrawBrushStroke::vertices_to_draw_data(sk_sp<SkVertices>& vertexDataPtr, co
void DrawBrushStroke::update(DrawingProgram& drawP) {
}
bool DrawBrushStroke::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) {
if(colliderAllocated)
return collisionTree.is_collide(checkAgainst);
bool DrawBrushStroke::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {
if(!SCollision::collide(checkAgainst, collisionTree.objects.bounds))
return false;
@ -402,17 +399,6 @@ bool DrawBrushStroke::collides_within_coords(const SCollision::ColliderCollectio
return toRet;
}
void DrawBrushStroke::free_collider() {
collisionTree.objects.aabb.clear();
collisionTree.objects.circle.clear();
collisionTree.objects.triangle.clear();
collisionTree.children.clear();
}
void DrawBrushStroke::allocate_collider() {
create_collider(true);
}
SCollision::AABB<float> DrawBrushStroke::get_obj_coord_bounds() const {
return collisionTree.objects.bounds;
}

7
src/DrawComponents/DrawBrushStroke.hpp
View file

@ -37,13 +37,10 @@ class DrawBrushStroke : public DrawComponent {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) override;
virtual void create_collider(bool colliderAllocated) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
virtual void free_collider() override;
virtual void allocate_collider() override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;
sk_sp<SkVertices> vertices;

14
src/DrawComponents/DrawComponent.cpp
View file

@ -172,19 +172,19 @@ void DrawComponent::client_send_erase_set(DrawingProgram& drawP, const std::unor
void DrawComponent::finalize_update(DrawingProgram& drawP, bool invalidateCache) {
if(invalidateCache && collabListInfo.lock())
drawP.compCache.preupdate_component(collabListInfo.lock());
create_collider(drawP.colliderAllocated);
create_collider();
}
bool DrawComponent::collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, bool colliderAllocated) {
return collides_with(camCoords, checkAgainstWorld, camCoords.world_collider_to_coords<SCollision::ColliderCollection<float>>(checkAgainstWorld), colliderAllocated);
bool DrawComponent::collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) {
return collides_with(camCoords, checkAgainstWorld, camCoords.world_collider_to_coords<SCollision::ColliderCollection<float>>(checkAgainstWorld));
}
bool DrawComponent::collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam, bool colliderAllocated) {
return collides_with(camCoords, camCoords.collider_to_world<SCollision::ColliderCollection<WorldScalar>>(checkAgainstCam), checkAgainstCam, colliderAllocated);
bool DrawComponent::collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam) {
return collides_with(camCoords, camCoords.collider_to_world<SCollision::ColliderCollection<WorldScalar>>(checkAgainstCam), checkAgainstCam);
}
// We could just send one of the checkAgainst colliders, since they represent the same thing, but sending both saves on redundant transformations, since we can save both of the versions on the executor side
bool DrawComponent::collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam, bool colliderAllocated) {
bool DrawComponent::collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) {
if((camCoords.inverseScale << DRAWCOMP_MAX_SHIFT_BEFORE_DISAPPEAR) < coords.inverseScale) // Object is too large, just dismiss the collision
return false;
else if((camCoords.inverseScale >> DRAWCOMP_COLLIDE_MIN_SHIFT_TINY) >= coords.inverseScale) {
@ -200,7 +200,7 @@ bool DrawComponent::collides_with(const CoordSpaceHelper& camCoords, const SColl
[&coords = coords](const WorldScalar& a) {
return coords.scalar_to_space(a);
});
return collides_within_coords(c, colliderAllocated);
return collides_within_coords(c);
}
}

13
src/DrawComponents/DrawComponent.hpp
View file

@ -103,7 +103,7 @@ class DrawComponent {
virtual SCollision::AABB<float> get_obj_coord_bounds() const = 0;
virtual std::shared_ptr<DrawComponent> copy() const = 0;
virtual void create_collider(bool colliderAllocated) = 0;
virtual void create_collider() = 0;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;
void temp_update(DrawingProgram& drawP);
void final_update(DrawingProgram& drawP, bool invalidateCache = true); // invalidateCache = false version should be thread safe
@ -111,13 +111,10 @@ class DrawComponent {
virtual void initialize_draw_data(DrawingProgram& drawP) = 0;
virtual void finalize_update(DrawingProgram& drawP, bool invalidateCache = true);
virtual void update(DrawingProgram& drawP) = 0;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) = 0;
bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, bool colliderAllocated);
bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam, bool colliderAllocated);
bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam, bool colliderAllocated);
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) = 0;
bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld);
bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam);
bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam);
virtual void update_from_delayed_ptr() = 0;
virtual void free_collider() = 0;
virtual void allocate_collider() = 0;
#endif
};

10
src/DrawComponents/DrawEllipse.cpp
View file

@ -65,11 +65,11 @@ void DrawEllipse::initialize_draw_data(DrawingProgram& drawP) {
void DrawEllipse::update(DrawingProgram& drawP) {
}
bool DrawEllipse::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) {
bool DrawEllipse::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {
return collisionTree.is_collide(checkAgainst);
}
void DrawEllipse::create_collider(bool colliderAllocated) {
void DrawEllipse::create_collider() {
using namespace SCollision;
ColliderCollection<float> strokeObjects;
@ -128,12 +128,6 @@ void DrawEllipse::create_collider(bool colliderAllocated) {
calculate_world_bounds();
}
void DrawEllipse::free_collider() {
}
void DrawEllipse::allocate_collider() {
}
SCollision::AABB<float> DrawEllipse::get_obj_coord_bounds() const {
return collisionTree.objects.bounds;
}

7
src/DrawComponents/DrawEllipse.hpp
View file

@ -29,13 +29,10 @@ class DrawEllipse : public DrawComponent {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void update_from_delayed_ptr() override;
void create_draw_data();
virtual void create_collider(bool colliderAllocated) override;
virtual void free_collider() override;
virtual void allocate_collider() override;
virtual void create_collider() override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;

10
src/DrawComponents/DrawImage.cpp
View file

@ -70,7 +70,7 @@ void DrawImage::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data();
}
bool DrawImage::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) {
bool DrawImage::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {
return collisionTree.is_collide(checkAgainst);
}
@ -78,7 +78,7 @@ void DrawImage::create_draw_data() {
imRect = SkRect::MakeLTRB(d.p1.x(), d.p1.y(), d.p2.x(), d.p2.y());
}
void DrawImage::create_collider(bool colliderAllocated) {
void DrawImage::create_collider() {
using namespace SCollision;
ColliderCollection<float> strokeObjects;
std::array<Vector2f, 4> newT = triangle_from_rect_points(d.p1, d.p2);
@ -89,12 +89,6 @@ void DrawImage::create_collider(bool colliderAllocated) {
calculate_world_bounds();
}
void DrawImage::free_collider() {
}
void DrawImage::allocate_collider() {
}
SCollision::AABB<float> DrawImage::get_obj_coord_bounds() const {
return collisionTree.objects.bounds;
}

7
src/DrawComponents/DrawImage.hpp
View file

@ -28,14 +28,11 @@ class DrawImage : public DrawComponent {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
void create_draw_data();
virtual void create_collider(bool colliderAllocated) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
virtual void free_collider() override;
virtual void allocate_collider() override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;
SkRect imRect;

10
src/DrawComponents/DrawRectangle.cpp
View file

@ -64,7 +64,7 @@ void DrawRectangle::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data();
}
bool DrawRectangle::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) {
bool DrawRectangle::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {
return collisionTree.is_collide(checkAgainst);
}
@ -80,7 +80,7 @@ void DrawRectangle::create_draw_data() {
}
}
void DrawRectangle::create_collider(bool colliderAllocated) {
void DrawRectangle::create_collider() {
using namespace SCollision;
ColliderCollection<float> strokeObjects;
if(d.fillStrokeMode == 0) {
@ -111,12 +111,6 @@ void DrawRectangle::create_collider(bool colliderAllocated) {
calculate_world_bounds();
}
void DrawRectangle::free_collider() {
}
void DrawRectangle::allocate_collider() {
}
SCollision::AABB<float> DrawRectangle::get_obj_coord_bounds() const {
return collisionTree.objects.bounds;
}

7
src/DrawComponents/DrawRectangle.hpp
View file

@ -30,14 +30,11 @@ class DrawRectangle : public DrawComponent {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
void create_draw_data();
virtual void create_collider(bool colliderAllocated) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
virtual void free_collider() override;
virtual void allocate_collider() override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;
SkPath rectPath;

10
src/DrawComponents/DrawTextBox.cpp
View file

@ -106,11 +106,11 @@ void DrawTextBox::initialize_draw_data(DrawingProgram& drawP) {
init_text_box(drawP);
}
bool DrawTextBox::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) {
bool DrawTextBox::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {
return collisionTree.is_collide(checkAgainst);
}
void DrawTextBox::create_collider(bool colliderAllocated) {
void DrawTextBox::create_collider() {
using namespace SCollision;
ColliderCollection<float> strokeObjects;
std::array<Vector2f, 4> newT = triangle_from_rect_points(d.p1, d.p2);
@ -121,12 +121,6 @@ void DrawTextBox::create_collider(bool colliderAllocated) {
calculate_world_bounds();
}
void DrawTextBox::free_collider() {
}
void DrawTextBox::allocate_collider() {
}
SCollision::AABB<float> DrawTextBox::get_obj_coord_bounds() const {
return collisionTree.objects.bounds;
}

7
src/DrawComponents/DrawTextBox.hpp
View file

@ -31,18 +31,15 @@ class DrawTextBox : public DrawComponent {
virtual std::shared_ptr<DrawComponent> copy() const override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst, bool colliderAllocated) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void update(DrawingProgram& drawP) override;
virtual void create_collider(bool colliderAllocated) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
void init_text_box(DrawingProgram& drawP);
void update_contained_string(DrawingProgram& drawP);
void set_textbox_string(const std::string& str);
Vector2f get_mouse_pos(DrawingProgram& drawP);
virtual void free_collider() override;
virtual void allocate_collider() override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;
bool textboxUpdate = false;

12
src/DrawingProgram/DrawingProgram.cpp
View file

@ -173,18 +173,6 @@ void DrawingProgram::check_updateable_components() {
comp->update(*this);
}
void DrawingProgram::free_collider_memory() {
for(auto& c : components.client_list())
c->obj->free_collider();
colliderAllocated = false;
}
void DrawingProgram::allocate_collider_memory() {
for(auto& c : components.client_list())
c->obj->allocate_collider();
colliderAllocated = true;
}
void DrawingProgram::parallel_loop_all_components(std::function<void(const std::shared_ptr<CollabList<std::shared_ptr<DrawComponent>, ServerClientID>::ObjectInfo>&)> func) {
parallel_loop_container(components.client_list(), func);
}

5
src/DrawingProgram/DrawingProgram.hpp
View file

@ -40,9 +40,6 @@ class DrawingProgram {
void write_to_file(cereal::PortableBinaryOutputArchive& a);
World& world;
void free_collider_memory();
void allocate_collider_memory();
bool prevent_undo_or_redo();
void add_file_to_canvas_by_path(const std::string& filePath, Vector2f dropPos, bool addInSameThread);
@ -50,8 +47,6 @@ class DrawingProgram {
void parallel_loop_all_components(std::function<void(const std::shared_ptr<CollabList<std::shared_ptr<DrawComponent>, ServerClientID>::ObjectInfo>&)> func);
bool colliderAllocated = false;
DrawingProgramCache compCache;
CollabListType components;

2
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -49,7 +49,7 @@ void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCo
return true;
}
std::erase_if(comps, [&](auto& c) {
if(c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC, drawP.colliderAllocated)) {
if(c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
selectedComponents.emplace(c);
drawP.compCache.invalidate_cache_at_aabb_before_pos(c->obj->worldAABB.value(), c->obj->collabListInfo.lock()->pos);
return true;

4
src/DrawingProgram/EditTool.cpp
View file

@ -135,7 +135,7 @@ void EditTool::tool_update() {
drawP.compCache.traverse_bvh_run_function(mouseAABB, [&](const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CollabListType::ObjectInfoPtr>& components) {
for(auto& c : components) {
if(c->pos > lastPos && c->obj->collides_with_world_coords(drawP.world.drawData.cam.c, cMouseAABB, drawP.colliderAllocated)) {
if(c->pos > lastPos && c->obj->collides_with_world_coords(drawP.world.drawData.cam.c, cMouseAABB)) {
lastSelectedObj = c;
lastPos = c->pos;
}
@ -165,7 +165,7 @@ void EditTool::tool_update() {
break;
}
}
if(!isMovingPoint && !a->collides_with_cam_coords(drawP.world.drawData.cam.c, cMouseCircle, drawP.colliderAllocated))
if(!isMovingPoint && !a->collides_with_cam_coords(drawP.world.drawData.cam.c, cMouseCircle))
clickedAway = true;
}
else if(controls.pointDragging) {

2
src/DrawingProgram/EraserTool.cpp
View file

@ -46,7 +46,7 @@ void EraserTool::tool_update() {
return true;
}
std::erase_if(comps, [&](auto& c) {
if(c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC, drawP.colliderAllocated)) {
if(c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
erasedComponents.emplace(c);
drawP.compCache.invalidate_cache_at_aabb_before_pos(c->obj->worldAABB.value(), c->obj->collabListInfo.lock()->pos);
return true;

4
src/DrawingProgram/TextBoxTool.cpp
View file

@ -93,7 +93,7 @@ bool TextBoxTool::edit_update(const std::shared_ptr<DrawTextBox>& a) {
mousePointCollection.recalculate_bounds();
a->textBox.setWidth(std::abs(a->d.p2.x() - a->d.p1.x()));
a->create_collider(drawP.colliderAllocated);
a->create_collider();
InputManager& input = drawP.world.main.input;
auto& textbox = a->textBox;
@ -103,7 +103,7 @@ bool TextBoxTool::edit_update(const std::shared_ptr<DrawTextBox>& a) {
bool movedHeld = false;
bool collidesWithBox = false;
if(a->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection, drawP.colliderAllocated)) {
if(a->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection)) {
//drawP.world.main.input.cursorIcon = InputManager::SystemCursorType::TEXT;
collidesWithBox = true;
}