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

Removed temporary update commits

Browse source
This commit is contained in:
Yousef Khadadeh 2025-07-31 09:34:17 +03:00
parent d19b5c4cb0
commit ed3d5f6d51
25 changed files with 125 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/Helpers/SCollision.hpp
View file

@ -459,7 +459,7 @@ namespace SCollision {
return 3;
}
void calculate_bvh_recursive(ColliderCollection<T>& bvhObjects) {
void calculate_bvh_recursive(ColliderCollection<T>& bvhObjects, int maxDepth = -1) {
bvhObjects.recalculate_bounds();
objects.bounds = bvhObjects.bounds;
@ -468,7 +468,7 @@ namespace SCollision {
return;
}
if(bvhObjects.size() <= 2) {
if(bvhObjects.size() <= 2 || maxDepth == 0) {
objects = bvhObjects;
return;
}
@ -492,7 +492,7 @@ namespace SCollision {
}
else {
children.emplace_back();
children.back().calculate_bvh_recursive(parts[i]);
children.back().calculate_bvh_recursive(parts[i], maxDepth - 1);
}
}
}

11
src/DrawComponents/DrawBrushStroke.cpp
View file

@ -47,7 +47,7 @@ std::shared_ptr<DrawComponent> DrawBrushStroke::deep_copy() const {
return a;
}
void DrawBrushStroke::update_from_delayed_ptr() {
void DrawBrushStroke::update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
std::shared_ptr<DrawBrushStroke> newPtr = std::static_pointer_cast<DrawBrushStroke>(delayedUpdatePtr);
d = newPtr->d;
}
@ -120,6 +120,7 @@ void DrawBrushStroke::initialize_draw_data(DrawingProgram& drawP) {
create_triangles(triangleFunc, points, 30);
vertices_to_draw_data(verticesMipMap[1], vertexData);
}
create_collider();
}
std::vector<size_t> DrawBrushStroke::get_wedge_indices(const std::vector<DrawBrushStrokePoint>& points) {
@ -359,19 +360,19 @@ void DrawBrushStroke::create_collider() {
SCollision::BVHContainer<float> collisionTree;
collisionTree.calculate_bvh_recursive(strokeObjects);
collisionTree.calculate_bvh_recursive(strokeObjects, AABB_PRECHECK_BVH_LEVELS + 1);
precheckAABBLevels.clear();
add_precheck_aabb_level(0, collisionTree.children);
add_precheck_aabb_level(AABB_PRECHECK_BVH_LEVELS, collisionTree.children);
bounds = collisionTree.objects.bounds;
}
void DrawBrushStroke::add_precheck_aabb_level(size_t level, const std::vector<SCollision::BVHContainer<float>>& levelArray) {
for(const auto& a : levelArray) {
if(level == AABB_PRECHECK_BVH_LEVELS || a.children.empty())
if(level == 0 || a.children.empty())
precheckAABBLevels.emplace_back(a.objects.bounds);
else
add_precheck_aabb_level(level + 1, a.children);
add_precheck_aabb_level(level - 1, a.children);
}
}

4
src/DrawComponents/DrawBrushStroke.hpp
View file

@ -41,8 +41,8 @@ class DrawBrushStroke : public DrawComponent {
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
void create_collider();
virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;

63
src/DrawComponents/DrawComponent.cpp
View file

@ -72,26 +72,14 @@ void DrawComponent::server_send_erase_set(MainServer& server, const std::unorder
server.netServer->send_items_to_all_clients(RELIABLE_COMMAND_CHANNEL, CLIENT_ERASE_MANY_COMPONENTS, ids);
}
void DrawComponent::server_send_update_temp(MainServer& server, ServerClientID id) {
server.netServer->send_items_to_all_clients(UNRELIABLE_COMMAND_CHANNEL, CLIENT_UPDATE_COMPONENT, true, id, *this);
}
void DrawComponent::server_send_update_final(MainServer& server, ServerClientID id) {
server.netServer->send_items_to_all_clients(RELIABLE_COMMAND_CHANNEL, CLIENT_UPDATE_COMPONENT, false, id, *this);
void DrawComponent::server_send_update(MainServer& server, ServerClientID id) {
server.netServer->send_items_to_all_clients(UNRELIABLE_COMMAND_CHANNEL, CLIENT_UPDATE_COMPONENT, id, *this);
}
void DrawComponent::server_send_transform_many(MainServer& server, const std::vector<std::pair<ServerClientID, CoordSpaceHelper>>& transforms) {
server.netServer->send_items_to_all_clients(RELIABLE_COMMAND_CHANNEL, CLIENT_TRANSFORM_MANY_COMPONENTS, transforms);
}
bool DrawComponent::server_update(MainServer& server, ServerClientID id, const std::chrono::time_point<std::chrono::steady_clock>& tempServerUpdateTimer) {
if((std::chrono::steady_clock::now() - tempServerUpdateTimer) >= CLIENT_DRAWCOMP_DELAY_TIMER_DURATION) {
server_send_update_final(server, id);
return true;
}
return false;
}
void DrawComponent::get_used_resources(std::unordered_set<ServerClientID>& v) const {
}
@ -105,35 +93,35 @@ bool DrawComponent::bounds_draw_check(const DrawData& drawData) const {
return a;
}
void DrawComponent::check_timers(DrawingProgram& drawP) {
bool DrawComponent::check_timers(DrawingProgram& drawP, const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
if(delayedUpdatePtr) {
if(std::chrono::steady_clock::now() - lastUpdateTime > CLIENT_DRAWCOMP_DELAY_TIMER_DURATION) {
update_from_delayed_ptr();
delayedUpdatePtr = nullptr;
final_update(drawP);
update_from_delayed_ptr(delayedUpdatePtr);
commit_update(drawP);
return true;
}
return false;
}
return true;
}
void DrawComponent::temp_update(DrawingProgram& drawP) {
if(collabListInfo.lock())
drawP.compCache.preupdate_component(collabListInfo.lock());
worldAABB = std::nullopt;
void DrawComponent::commit_update(DrawingProgram& drawP, bool invalidateCache) {
auto lockedCollabInfo = collabListInfo.lock();
if(invalidateCache && lockedCollabInfo && worldAABB)
drawP.compCache.preupdate_component(lockedCollabInfo, worldAABB);
initialize_draw_data(drawP);
calculate_world_bounds();
if(invalidateCache && lockedCollabInfo && worldAABB)
drawP.compCache.preupdate_component(lockedCollabInfo, worldAABB);
}
void DrawComponent::final_update(DrawingProgram& drawP, bool invalidateCache) {
if(invalidateCache && collabListInfo.lock())
drawP.compCache.preupdate_component(collabListInfo.lock());
initialize_draw_data(drawP);
create_collider();
calculate_world_bounds();
}
void DrawComponent::transform_update(DrawingProgram& drawP, bool invalidateCache) {
if(invalidateCache && collabListInfo.lock())
drawP.compCache.preupdate_component(collabListInfo.lock());
void DrawComponent::commit_transform(DrawingProgram& drawP, bool invalidateCache) {
auto lockedCollabInfo = collabListInfo.lock();
if(invalidateCache && lockedCollabInfo && worldAABB)
drawP.compCache.preupdate_component(lockedCollabInfo, worldAABB);
calculate_world_bounds();
if(invalidateCache && lockedCollabInfo && worldAABB)
drawP.compCache.preupdate_component(lockedCollabInfo, worldAABB);
}
void DrawComponent::client_send_place_many(DrawingProgram& drawP, std::vector<CollabListType::ObjectInfoPtr>& comps) {
@ -145,14 +133,9 @@ void DrawComponent::client_send_place(DrawingProgram& drawP) {
drawP.world.con.client_send_items_to_server(RELIABLE_COMMAND_CHANNEL, SERVER_PLACE_SINGLE_COMPONENT, collabListInfo.lock()->pos, get_type(), this->coords, *this);
}
void DrawComponent::client_send_update_temp(DrawingProgram& drawP) {
void DrawComponent::client_send_update(DrawingProgram& drawP) {
if(collabListInfo.lock())
drawP.world.con.client_send_items_to_server(UNRELIABLE_COMMAND_CHANNEL, SERVER_UPDATE_COMPONENT, true, collabListInfo.lock()->id, *this);
}
void DrawComponent::client_send_update_final(DrawingProgram& drawP) {
if(collabListInfo.lock())
drawP.world.con.client_send_items_to_server(RELIABLE_COMMAND_CHANNEL, SERVER_UPDATE_COMPONENT, false, collabListInfo.lock()->id, *this);
drawP.world.con.client_send_items_to_server(UNRELIABLE_COMMAND_CHANNEL, SERVER_UPDATE_COMPONENT, collabListInfo.lock()->id, *this);
}
void DrawComponent::client_send_transform_many(DrawingProgram& drawP, const std::vector<std::pair<ServerClientID, CoordSpaceHelper>>& transforms) {

19
src/DrawComponents/DrawComponent.hpp
View file

@ -67,28 +67,23 @@ class DrawComponent {
static void server_send_place_many(MainServer& server, std::vector<CollabListType::ObjectInfoPtr>& comps);
static void server_send_erase(MainServer& server, ServerClientID id);
static void server_send_erase_set(MainServer& server, const std::unordered_set<ServerClientID>& ids);
void server_send_update_temp(MainServer& server, ServerClientID id);
void server_send_update_final(MainServer& server, ServerClientID id);
void server_send_update(MainServer& server, ServerClientID id);
static void server_send_transform_many(MainServer& server, const std::vector<std::pair<ServerClientID, CoordSpaceHelper>>& transforms);
std::weak_ptr<CollabListType::ObjectInfo> collabListInfo;
std::weak_ptr<DrawingProgramCacheBVHNode> parentBvhNode;
bool server_update(MainServer& server, ServerClientID id, const std::chrono::time_point<std::chrono::steady_clock>& tempServerUpdateTimer);
#ifndef IS_SERVER
std::chrono::time_point<std::chrono::steady_clock> lastUpdateTime;
std::shared_ptr<DrawComponent> delayedUpdatePtr = nullptr;
bool bounds_draw_check(const DrawData& drawData) const;
void check_timers(DrawingProgram& drawP);
bool check_timers(DrawingProgram& drawP, const std::shared_ptr<DrawComponent>& delayedUpdatePtr);
static void client_send_place_many(DrawingProgram& drawP, std::vector<CollabListType::ObjectInfoPtr>& comps);
void client_send_place(DrawingProgram& drawP);
void client_send_erase(DrawingProgram& drawP);
static void client_send_erase_set(DrawingProgram& drawP, const std::unordered_set<ServerClientID>& ids);
void client_send_update_temp(DrawingProgram& drawP);
void client_send_update_final(DrawingProgram& drawP);
void client_send_update(DrawingProgram& drawP);
static void client_send_transform_many(DrawingProgram& drawP, const std::vector<std::pair<ServerClientID, CoordSpaceHelper>>& transforms);
std::optional<SCollision::AABB<WorldScalar>> worldAABB;
@ -100,17 +95,15 @@ class DrawComponent {
virtual std::shared_ptr<DrawComponent> copy() const = 0;
virtual std::shared_ptr<DrawComponent> deep_copy() const = 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
void transform_update(DrawingProgram& drawP, bool invalidateCache = true);
void commit_update(DrawingProgram& drawP, bool invalidateCache = true); // invalidateCache = false version should be thread safe
void commit_transform(DrawingProgram& drawP, bool invalidateCache = true); // invalidateCache = false version should be thread safe
virtual void initialize_draw_data(DrawingProgram& drawP) = 0;
virtual void update(DrawingProgram& drawP) = 0;
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 update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) = 0;
#endif
};

3
src/DrawComponents/DrawEllipse.cpp
View file

@ -35,7 +35,7 @@ std::shared_ptr<DrawComponent> DrawEllipse::deep_copy() const {
return a;
}
void DrawEllipse::update_from_delayed_ptr() {
void DrawEllipse::update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
std::shared_ptr<DrawEllipse> newPtr = std::static_pointer_cast<DrawEllipse>(delayedUpdatePtr);
d = newPtr->d;
}
@ -69,6 +69,7 @@ void DrawEllipse::create_draw_data() {
void DrawEllipse::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data();
create_collider();
}
void DrawEllipse::update(DrawingProgram& drawP) {

4
src/DrawComponents/DrawEllipse.hpp
View file

@ -32,9 +32,9 @@ class DrawEllipse : public DrawComponent {
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void update_from_delayed_ptr() override;
virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
void create_draw_data();
virtual void create_collider() override;
void create_collider();
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;

7
src/DrawComponents/DrawImage.cpp
View file

@ -49,7 +49,7 @@ std::shared_ptr<DrawComponent> DrawImage::deep_copy() const {
return a;
}
void DrawImage::update_from_delayed_ptr() {
void DrawImage::update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
std::shared_ptr<DrawImage> newPtr = std::static_pointer_cast<DrawImage>(delayedUpdatePtr);
d = newPtr->d;
}
@ -70,13 +70,14 @@ void DrawImage::draw(SkCanvas* canvas, const DrawData& drawData) {
void DrawImage::update(DrawingProgram& drawP) {
std::shared_ptr<ResourceDisplay> display = drawP.world.drawData.rMan->get_display_data(d.imageID);
if(display) {
if(display->update_draw())// && bounds_draw_check(drawP.world.drawData, collisionTree))
temp_update(drawP);
if(display->update_draw() && collabListInfo.lock())
drawP.compCache.invalidate_cache_at_optional_aabb_before_pos(worldAABB, collabListInfo.lock()->pos);
}
}
void DrawImage::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data();
create_collider();
}
bool DrawImage::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {

4
src/DrawComponents/DrawImage.hpp
View file

@ -32,8 +32,8 @@ class DrawImage : public DrawComponent {
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
void create_draw_data();
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
void create_collider();
virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;

3
src/DrawComponents/DrawRectangle.cpp
View file

@ -38,7 +38,7 @@ std::shared_ptr<DrawComponent> DrawRectangle::deep_copy() const {
return a;
}
void DrawRectangle::update_from_delayed_ptr() {
void DrawRectangle::update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
std::shared_ptr<DrawRectangle> newPtr = std::static_pointer_cast<DrawRectangle>(delayedUpdatePtr);
d = newPtr->d;
}
@ -71,6 +71,7 @@ void DrawRectangle::update(DrawingProgram& drawP) {
void DrawRectangle::initialize_draw_data(DrawingProgram& drawP) {
create_draw_data();
create_collider();
}
bool DrawRectangle::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {

4
src/DrawComponents/DrawRectangle.hpp
View file

@ -34,8 +34,8 @@ class DrawRectangle : public DrawComponent {
virtual void update(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
void create_draw_data();
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
void create_collider();
virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
virtual SCollision::AABB<float> get_obj_coord_bounds() const override;

5
src/DrawComponents/DrawTextBox.cpp
View file

@ -43,7 +43,7 @@ std::shared_ptr<DrawComponent> DrawTextBox::deep_copy() const {
return a;
}
void DrawTextBox::update_from_delayed_ptr() {
void DrawTextBox::update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) {
std::shared_ptr<DrawTextBox> newPtr = std::static_pointer_cast<DrawTextBox>(delayedUpdatePtr);
d = newPtr->d;
textboxUpdate = true;
@ -105,7 +105,7 @@ void DrawTextBox::set_textbox_string(const std::string& str) {
void DrawTextBox::update_contained_string(DrawingProgram& drawP) {
d.currentText = textBox.get_string();
temp_update(drawP);
commit_update(drawP);
}
Vector2f DrawTextBox::get_mouse_pos(DrawingProgram& drawP) {
@ -114,6 +114,7 @@ Vector2f DrawTextBox::get_mouse_pos(DrawingProgram& drawP) {
void DrawTextBox::initialize_draw_data(DrawingProgram& drawP) {
init_text_box(drawP);
create_collider();
}
bool DrawTextBox::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) {

4
src/DrawComponents/DrawTextBox.hpp
View file

@ -35,8 +35,8 @@ class DrawTextBox : public DrawComponent {
virtual void initialize_draw_data(DrawingProgram& drawP) override;
virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) override;
virtual void update(DrawingProgram& drawP) override;
virtual void create_collider() override;
virtual void update_from_delayed_ptr() override;
void create_collider();
virtual void update_from_delayed_ptr(const std::shared_ptr<DrawComponent>& delayedUpdatePtr) override;
void init_text_box(DrawingProgram& drawP);
void update_contained_string(DrawingProgram& drawP);
void set_textbox_string(const std::string& str);

10
src/DrawingProgram/BrushTool.cpp
View file

@ -107,7 +107,7 @@ void BrushTool::tool_update() {
controls.intermediateItem->lastUpdateTime = std::chrono::steady_clock::now();
uint64_t placement = drawP.components.client_list().size();
auto objAdd = drawP.components.client_insert(placement, controls.intermediateItem);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->commit_update(drawP);
controls.intermediateItem->client_send_place(drawP);
// NOTE: The data isnt finallized at this point, so a BVH isn't generated for an object that you undo while youre drawing (this isnt just for brush strokes)
// The fix for now is to generate a BVH for an object when you redo it
@ -141,7 +141,7 @@ void BrushTool::tool_update() {
if((!controls.drawingMinimumRelativeToSize && distToPrev >= 10.0) || (controls.drawingMinimumRelativeToSize && distToPrev >= drawP.controls.relativeWidth * DRAW_MINIMUM_LIMIT)) {
controls.intermediateItem->d->points.back() = p;
controls.addedTemporaryPoint = false;
controls.intermediateItem->client_send_update_temp(drawP);
controls.intermediateItem->client_send_update(drawP);
if(controls.midwayInterpolation) {
if(controls.intermediateItem->d->points.size() != 2) // Don't interpolate the first point
@ -149,7 +149,7 @@ void BrushTool::tool_update() {
controls.prevPointUnaltered = p.pos;
}
}
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
}
}
@ -175,8 +175,8 @@ bool BrushTool::prevent_undo_or_redo() {
void BrushTool::commit_stroke() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) {
if(!controls.intermediateItem->d->points.empty()) {
controls.intermediateItem->client_send_update_final(drawP);
controls.intermediateItem->final_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
}
controls.intermediateItem = nullptr;

38
src/DrawingProgram/DrawingProgram.cpp
View file

@ -69,25 +69,21 @@ DrawingProgram::DrawingProgram(World& initWorld):
void DrawingProgram::init_client_callbacks() {
world.con.client_add_recv_callback(CLIENT_UPDATE_COMPONENT, [&](cereal::PortableBinaryInputArchive& message) {
bool isTemp;
ServerClientID id;
message(isTemp, id);
message(id);
auto objPtr = components.get_item_by_id(id);
if(!objPtr)
return;
std::shared_ptr<DrawComponent>& comp = objPtr->obj;
if((std::chrono::steady_clock::now() - comp->lastUpdateTime) > CLIENT_DRAWCOMP_DELAY_TIMER_DURATION){
comp->delayedUpdatePtr = nullptr;
if((std::chrono::steady_clock::now() - comp->lastUpdateTime) > CLIENT_DRAWCOMP_DELAY_TIMER_DURATION) {
delayedUpdateComponents.erase(comp);
message(*comp);
if(isTemp)
comp->temp_update(*this);
else
comp->final_update(*this);
comp->commit_update(*this);
}
else {
comp->delayedUpdatePtr = DrawComponent::allocate_comp_type(comp->get_type());
message(*comp->delayedUpdatePtr);
delayedUpdateComponents.emplace(comp);
auto delayedUpdatePtr = DrawComponent::allocate_comp_type(comp->get_type());
message(*delayedUpdatePtr);
delayedUpdateComponents[comp] = delayedUpdatePtr;
}
});
world.con.client_add_recv_callback(CLIENT_TRANSFORM_MANY_COMPONENTS, [&](cereal::PortableBinaryInputArchive& message) {
@ -105,7 +101,7 @@ void DrawingProgram::init_client_callbacks() {
return;
comp->coords = coords;
objsActuallyTransformed++;
comp->transform_update(*this, false);
comp->commit_transform(*this, false);
});
if(objsActuallyTransformed != 0)
force_rebuild_cache();
@ -119,7 +115,7 @@ void DrawingProgram::init_client_callbacks() {
if(comp->coords == coords)
return;
comp->coords = coords;
comp->transform_update(*this);
comp->commit_transform(*this);
}
}
});
@ -132,7 +128,7 @@ void DrawingProgram::init_client_callbacks() {
message(newObjectID, newObj->coords, *newObj);
bool didntExistPreviously = components.server_insert(insertPosition, newObjectID, newObj);
if(didntExistPreviously)
newObj->final_update(*this);
newObj->commit_update(*this);
});
world.con.client_add_recv_callback(CLIENT_PLACE_MANY_COMPONENTS, [&](cereal::PortableBinaryInputArchive& message) {
std::vector<CollabListType::ObjectInfoPtr> sortedPlacedComponents;
@ -143,7 +139,7 @@ void DrawingProgram::init_client_callbacks() {
std::vector<bool> didntExistPreviously = components.server_insert_ordered_vector(sortedPlacedComponents);
bool isSingleThread = sortedPlacedComponents.size() < DrawingProgramCache::MINIMUM_COMPONENTS_TO_START_REBUILD;
parallel_loop_container(sortedPlacedComponents, [&](const auto& c){
c->obj->final_update(*this, isSingleThread);
c->obj->commit_update(*this, isSingleThread);
}, isSingleThread);
if(!isSingleThread)
force_rebuild_cache();
@ -161,9 +157,9 @@ void DrawingProgram::init_client_callbacks() {
}
void DrawingProgram::check_delayed_update_timers() {
std::erase_if(delayedUpdateComponents, [&](auto& comp) {
comp->check_timers(*this);
return !comp->delayedUpdatePtr;
std::erase_if(delayedUpdateComponents, [&](auto& p) {
auto& [comp, delayedUpdatePtr] = p;
return comp->check_timers(*this, delayedUpdatePtr);
});
}
@ -450,7 +446,7 @@ void DrawingProgram::add_file_to_canvas_by_path_execute(const std::string& fileP
img->d.p1 = dropPos - imDim;
img->d.p2 = dropPos + imDim;
img->d.imageID = imageID;
img->final_update(*this);
img->commit_update(*this);
uint64_t placement = components.client_list().size();
auto objAdd = components.client_insert(placement, img);
img->client_send_place(*this);
@ -473,7 +469,7 @@ void DrawingProgram::add_file_to_canvas_by_data(const std::string& fileName, std
img->d.p1 = dropPos - imDim;
img->d.p2 = dropPos + imDim;
img->d.imageID = imageID;
img->final_update(*this);
img->commit_update(*this);
uint64_t placement = components.client_list().size();
auto objAdd = components.client_insert(placement, img);
img->client_send_place(*this);
@ -502,7 +498,7 @@ void DrawingProgram::initialize_draw_data(cereal::PortableBinaryInputArchive& a)
components.init_emplace_back(id, newComp);
}
parallel_loop_all_components([&](const auto& c){
c->obj->final_update(*this, false);
c->obj->commit_update(*this, false);
});
compCache.test_rebuild(components.client_list(), true);
}

2
src/DrawingProgram/DrawingProgram.hpp
View file

@ -52,7 +52,7 @@ class DrawingProgram {
CollabListType components;
std::unordered_set<std::shared_ptr<DrawComponent>> updateableComponents;
std::unordered_set<std::shared_ptr<DrawComponent>> delayedUpdateComponents;
std::unordered_map<std::shared_ptr<DrawComponent>, std::shared_ptr<DrawComponent>> delayedUpdateComponents;
Vector4f* get_foreground_color_ptr();
private:

4
src/DrawingProgram/DrawingProgramCache.cpp
View file

@ -165,14 +165,14 @@ void DrawingProgramCache::traverse_bvh_run_function_recursive(const std::shared_
}
}
void DrawingProgramCache::preupdate_component(const CollabListType::ObjectInfoPtr& c) {
void DrawingProgramCache::preupdate_component(const CollabListType::ObjectInfoPtr& c, const std::optional<SCollision::AABB<WorldScalar>>& aabb) {
auto parentBvhNode = c->obj->parentBvhNode.lock();
if(parentBvhNode) {
unsortedComponents.emplace_back(c);
std::erase(parentBvhNode->components, c);
c->obj->parentBvhNode.reset();
}
invalidate_cache_before_pos(c->pos);
invalidate_cache_at_optional_aabb_before_pos(aabb, c->pos);
}
void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CollabListType::ObjectInfoPtr>& components) {

2
src/DrawingProgram/DrawingProgramCache.hpp
View file

@ -52,7 +52,7 @@ class DrawingProgramCache {
void traverse_bvh_run_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node, const std::vector<CollabListType::ObjectInfoPtr>& components)> f);
void traverse_bvh_erase_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node, std::vector<CollabListType::ObjectInfoPtr>& components)> f);
// Run before actually updating the component
void preupdate_component(const CollabListType::ObjectInfoPtr& c);
void preupdate_component(const CollabListType::ObjectInfoPtr& c, const std::optional<SCollision::AABB<WorldScalar>>& aabb);
void invalidate_cache_before_pos(uint64_t placementToInvalidateAt);
void invalidate_cache_at_aabb_before_pos(const SCollision::AABB<WorldScalar>& aabb, uint64_t placementToInvalidateAt);
void invalidate_cache_at_optional_aabb_before_pos(const std::optional<SCollision::AABB<WorldScalar>>& aabb, uint64_t placementToInvalidateAt);

8
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -94,7 +94,7 @@ void DrawingProgramSelection::deselect_all() {
bool isSingleThread = a.size() < DrawingProgramCache::MINIMUM_COMPONENTS_TO_START_REBUILD;
parallel_loop_container(a, [&](auto& obj) {
obj->obj->coords = selectionTransformCoords.other_coord_space_from_this_space(obj->obj->coords);
obj->obj->transform_update(drawP, false);
obj->obj->commit_transform(drawP, false);
}, isSingleThread);
if(!isSingleThread)
drawP.force_rebuild_cache();
@ -128,7 +128,7 @@ void DrawingProgramSelection::deselect_all() {
parallel_loop_container(transformsFrom, [&](auto& p) {
auto& [comp, coords] = p;
comp->obj->coords = coords;
comp->obj->transform_update(drawP, isSingleThread);
comp->obj->commit_transform(drawP, isSingleThread);
}, isSingleThread);
DrawComponent::client_send_transform_many(drawP, transformsToSend);
@ -154,7 +154,7 @@ void DrawingProgramSelection::deselect_all() {
parallel_loop_container(transformsTo, [&](auto& p) {
auto& [comp, coords] = p;
comp->obj->coords = coords;
comp->obj->transform_update(drawP, isSingleThread);
comp->obj->commit_transform(drawP, isSingleThread);
}, isSingleThread);
DrawComponent::client_send_transform_many(drawP, transformsToSend);
@ -334,7 +334,7 @@ void DrawingProgramSelection::paste_clipboard() {
parallel_loop_container(compListInserted, [&](auto& c) {
c->obj->remap_resource_ids(resourceRemapIDs);
c->obj->coords.translate(-moveVec);
c->obj->transform_update(drawP, false);
c->obj->commit_transform(drawP, false);
});
DrawComponent::client_send_place_many(drawP, compListInserted);
drawP.addToCompCacheOnInsert = true;

12
src/DrawingProgram/EditTool.cpp
View file

@ -49,8 +49,8 @@ void EditTool::gui_toolbox() {
}
}
if(editHappened) {
a->temp_update(drawP);
a->client_send_update_temp(drawP);
a->commit_update(drawP);
a->client_send_update(drawP);
}
}
else {
@ -83,8 +83,8 @@ void EditTool::reset_tool() {
default:
break;
}
a->final_update(drawP);
a->client_send_update_final(drawP);
a->commit_update(drawP);
a->client_send_update(drawP);
}
controls.compToEdit.reset();
controls.pointHandles.clear();
@ -177,8 +177,8 @@ void EditTool::tool_update() {
if(controls.pointDragging->max)
newPos = cwise_vec_min(*controls.pointDragging->max, newPos);
*controls.pointDragging->p = newPos;
a->temp_update(drawP);
a->client_send_update_temp(drawP);
a->commit_update(drawP);
a->client_send_update(drawP);
}
isMovingPoint = true;
}

18
src/DrawingProgram/EllipseDrawTool.cpp
View file

@ -70,15 +70,15 @@ void EllipseDrawTool::commit_edit_updates(const std::shared_ptr<DrawEllipse>& a,
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
@ -112,7 +112,7 @@ void EllipseDrawTool::tool_update() {
auto objAdd = drawP.components.client_insert(placement, controls.intermediateItem);
controls.intermediateItem->client_send_place(drawP);
drawP.add_undo_place_component(objAdd);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->commit_update(drawP);
controls.drawStage = 1;
}
break;
@ -127,8 +127,8 @@ void EllipseDrawTool::tool_update() {
}
controls.intermediateItem->d.p1 = cwise_vec_min(controls.startAt, newPos);
controls.intermediateItem->d.p2 = cwise_vec_max(controls.startAt, newPos);
controls.intermediateItem->client_send_update_temp(drawP);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
else {
commit();
@ -145,8 +145,8 @@ bool EllipseDrawTool::prevent_undo_or_redo() {
void EllipseDrawTool::commit() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) {
controls.intermediateItem->client_send_update_final(drawP);
controls.intermediateItem->final_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
controls.intermediateItem = nullptr;
}

18
src/DrawingProgram/RectDrawTool.cpp
View file

@ -74,15 +74,15 @@ void RectDrawTool::commit_edit_updates(const std::shared_ptr<DrawRectangle>& a,
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
@ -110,7 +110,7 @@ void RectDrawTool::tool_update() {
controls.intermediateItem->lastUpdateTime = std::chrono::steady_clock::now();
uint64_t placement = drawP.components.client_list().size();
auto objAdd = drawP.components.client_insert(placement, controls.intermediateItem);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->commit_update(drawP);
controls.intermediateItem->client_send_place(drawP);
drawP.add_undo_place_component(objAdd);
controls.drawStage = 1;
@ -127,8 +127,8 @@ void RectDrawTool::tool_update() {
}
controls.intermediateItem->d.p1 = cwise_vec_min(controls.startAt, newPos);
controls.intermediateItem->d.p2 = cwise_vec_max(controls.startAt, newPos);
controls.intermediateItem->client_send_update_temp(drawP);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
else {
commit_rectangle();
@ -145,8 +145,8 @@ bool RectDrawTool::prevent_undo_or_redo() {
void RectDrawTool::commit_rectangle() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) {
controls.intermediateItem->client_send_update_final(drawP);
controls.intermediateItem->final_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
controls.intermediateItem = nullptr;
}

22
src/DrawingProgram/TextBoxTool.cpp
View file

@ -57,8 +57,8 @@ void TextBoxTool::commit_edit_updates(const std::shared_ptr<DrawTextBox>& a, std
a->d = pData;
a->set_textbox_string(pData.currentText);
a->d.editing = false;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
@ -66,8 +66,8 @@ void TextBoxTool::commit_edit_updates(const std::shared_ptr<DrawTextBox>& a, std
a->d = cData;
a->set_textbox_string(cData.currentText);
a->d.editing = false;
a->client_send_update_final(drawP);
a->final_update(drawP);
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
@ -82,7 +82,7 @@ void TextBoxTool::edit_start(const std::shared_ptr<DrawTextBox>& a, std::any& pr
cur.pos = cur.selectionBeginPos = cur.selectionEndPos = textbox.getPosition(p);
prevData = a->d;
a->d.editing = true;
a->client_send_update_temp(drawP);
a->client_send_update(drawP);
drawP.editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
drawP.editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
@ -253,8 +253,8 @@ void TextBoxTool::tool_update() {
drawP.editTool.edit_start(i);
}
else {
controls.intermediateItem->client_send_update_temp(drawP);
controls.intermediateItem->temp_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
break;
}
@ -273,14 +273,14 @@ void TextBoxTool::edit_text(std::function<void()> toRun, const std::shared_ptr<D
}
void TextBoxTool::update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox) {
textBox->client_send_update_temp(drawP);
textBox->temp_update(drawP);
textBox->client_send_update(drawP);
textBox->commit_update(drawP);
}
void TextBoxTool::commit() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) {
controls.intermediateItem->client_send_update_final(drawP);
controls.intermediateItem->final_update(drawP);
controls.intermediateItem->client_send_update(drawP);
controls.intermediateItem->commit_update(drawP);
}
controls.intermediateItem = nullptr;
}

16
src/Server/MainServer.cpp
View file

@ -203,14 +203,7 @@ MainServer::MainServer(World& initWorld, const std::string& serverLocalID):
if(it != data.idToComponentMap.end()) {
std::shared_ptr<DrawComponent>& comp = it->second;
message(*comp);
if(isTemp) {
comp->server_send_update_temp(*this, idToUpdate);
data.updateComponentTimers[idToUpdate] = std::chrono::steady_clock::now();
}
else {
comp->server_send_update_final(*this, idToUpdate);
data.updateComponentTimers.erase(idToUpdate);
}
comp->server_send_update(*this, idToUpdate);
}
});
netServer->add_recv_callback(SERVER_RESOURCE_INIT, [&](std::shared_ptr<NetServer::ClientData> client, cereal::PortableBinaryInputArchive& message) {
@ -309,13 +302,6 @@ void MainServer::ensure_display_name_unique(std::string& displayName) {
void MainServer::update() {
netServer->update();
std::erase_if(data.updateComponentTimers, [&](auto& c) {
auto& [id, timer] = c;
auto it = data.idToComponentMap.find(id);
if(it == data.idToComponentMap.end())
return true;
return it->second->server_update(*this, id, timer);
});
if(std::chrono::steady_clock::now() - lastKeepAliveSent > std::chrono::seconds(2)) {
netServer->send_items_to_all_clients(UNRELIABLE_COMMAND_CHANNEL, CLIENT_KEEP_ALIVE);
lastKeepAliveSent = std::chrono::steady_clock::now();

1
src/Server/ServerData.hpp
View file

@ -11,7 +11,6 @@ class ServerData {
std::vector<std::pair<ServerClientID, std::shared_ptr<DrawComponent>>> components;
std::unordered_map<ServerClientID, std::shared_ptr<DrawComponent>> idToComponentMap;
std::unordered_map<ServerClientID, ResourceData> resources;
std::unordered_map<ServerClientID, std::chrono::time_point<std::chrono::steady_clock>> updateComponentTimers;
std::unordered_map<std::string, Bookmark> bookmarks;
void save(cereal::PortableBinaryOutputArchive& a) const;
void write_to_file(cereal::PortableBinaryOutputArchive& a) const;