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

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

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);