From 387bf02833c610f93326bf743db463eea8032a62 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 16:43:02 +0100 Subject: added collision features --- src/crepe/api/Rigidbody.h | 3 ++ src/crepe/system/CollisionSystem.cpp | 79 ++++++++++++++++++++++++++++++++---- src/crepe/system/CollisionSystem.h | 18 ++++++++ 3 files changed, 92 insertions(+), 8 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index b08c8db..8169f0c 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -132,6 +132,9 @@ public: */ vec2 offset; + //! Enable collision handeling in collision system + bool kinematic_collision = true; + /** * \brief Defines the collision layers of a GameObject. * diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index af8adce..4e84d8b 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -63,7 +63,7 @@ void CollisionSystem::update() { // For both objects call the collision handler for (auto & collision_pair : collided) { this->collision_handler_request(collision_pair.first, collision_pair.second); - this->collision_handler_request(collision_pair.second, collision_pair.first); + // this->collision_handler_request(collision_pair.second, collision_pair.first); } } @@ -302,16 +302,57 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co } void CollisionSystem::determine_collision_handler(CollisionInfo & info) { - // Check rigidbody type for static - if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; - // If second body is static perform the static collision handler in this system - if (info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) { - this->static_collision_handler(info); - }; - // Call collision event for user + // If both objects are static skip handle call collision script + if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; + + // First body is not dynamic + if(info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) + { + bool static_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; + bool kinematic_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC && info.this_rigidbody.data.kinematic_collision; + // Inverted collision info + CollisionInfo inverted = { + .this_collider = info.other_collider, + .this_transform = info.other_transform, + .this_rigidbody = info.other_rigidbody, + .this_metadata = info.other_metadata, + .other_collider = info.this_collider, + .other_transform = info.this_transform, + .other_rigidbody = info.this_rigidbody, + .other_metadata = info.this_metadata, + .resolution = -info.resolution, + .resolution_direction = info.resolution_direction, + }; + + if(static_collision || kinematic_collision){ + // Static collision + this->static_collision_handler(inverted); + }; + // Call scripts + this->call_collision_events(inverted); + return; + } + + // Second body is not dynamic + if(info.other_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) + { + bool static_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC; + bool kinematic_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.kinematic_collision; + if(static_collision || kinematic_collision) this->static_collision_handler(info); + this->call_collision_events(info); + return; + } + + //dynamic + this->dynamic_collision_handler(info); + this->call_collision_events(info); +} + +void CollisionSystem::call_collision_events(CollisionInfo & info){ CollisionEvent data(info); EventManager & emgr = this->mediator.event_manager; emgr.trigger_event(data, info.this_collider.game_object_id); + emgr.trigger_event(data, info.other_collider.game_object_id); } void CollisionSystem::static_collision_handler(CollisionInfo & info) { @@ -363,6 +404,28 @@ void CollisionSystem::static_collision_handler(CollisionInfo & info) { } } +void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){ + info.this_transform.position += info.resolution/2; + info.other_transform.position += -(info.resolution/2); + + switch (info.resolution_direction) { + case Direction::BOTH: + info.this_rigidbody.data.linear_velocity = {0, 0}; + break; + case Direction::Y_DIRECTION: + info.this_rigidbody.data.linear_velocity.y = 0; + info.this_transform.position.x -= info.resolution.x; + break; + case Direction::X_DIRECTION: + info.this_rigidbody.data.linear_velocity.x = 0; + info.this_transform.position.y -= info.resolution.y; + break; + case Direction::NONE: + // Not possible + break; + } +} + std::vector> CollisionSystem::gather_collisions(std::vector & colliders) { diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 5b136c6..aebb59b 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -194,6 +194,15 @@ private: */ void determine_collision_handler(CollisionInfo & info); + /** + * \brief Calls both collision script + * + * Calls both collision script to let user add additonal handeling or handle full collision. + * + * \param info Collision information containing data about both colliders. + */ + void call_collision_events(CollisionInfo & info); + /** * \brief Handles collisions involving static objects. * @@ -203,6 +212,15 @@ private: */ void static_collision_handler(CollisionInfo & info); + /** + * \brief Handles collisions involving dynamic objects. + * + * Resolves collisions by adjusting positions and modifying velocities if bounce is enabled. + * + * \param info Collision information containing data about both colliders. + */ + void dynamic_collision_handler(CollisionInfo & info); + private: /** * \brief Checks for collisions between colliders. -- cgit v1.2.3 From b3f0e0da03a3cd4976a5a90d040cbe7fd7472987 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 18:32:26 +0100 Subject: added dynamic bounce --- src/crepe/system/CollisionSystem.cpp | 64 +++++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 5 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 4e84d8b..0cd6f5c 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -410,15 +410,69 @@ void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){ switch (info.resolution_direction) { case Direction::BOTH: - info.this_rigidbody.data.linear_velocity = {0, 0}; + if (info.this_rigidbody.data.elastisity_coefficient > 0) { + info.this_rigidbody.data.linear_velocity + = -info.this_rigidbody.data.linear_velocity + * info.this_rigidbody.data.elastisity_coefficient; + } + else { + info.this_rigidbody.data.linear_velocity = {0, 0}; + } + + if (info.other_rigidbody.data.elastisity_coefficient > 0) { + info.other_rigidbody.data.linear_velocity + = -info.other_rigidbody.data.linear_velocity + * info.other_rigidbody.data.elastisity_coefficient; + } + else { + info.other_rigidbody.data.linear_velocity = {0, 0}; + } break; case Direction::Y_DIRECTION: - info.this_rigidbody.data.linear_velocity.y = 0; - info.this_transform.position.x -= info.resolution.x; + if (info.this_rigidbody.data.elastisity_coefficient > 0) { + info.this_rigidbody.data.linear_velocity.y + = -info.this_rigidbody.data.linear_velocity.y + * info.this_rigidbody.data.elastisity_coefficient; + } + // Stop movement + else { + info.this_rigidbody.data.linear_velocity.y = 0; + info.this_transform.position.x -= info.resolution.x; + } + + if (info.other_rigidbody.data.elastisity_coefficient > 0) { + info.other_rigidbody.data.linear_velocity.y + = -info.other_rigidbody.data.linear_velocity.y + * info.other_rigidbody.data.elastisity_coefficient; + } + // Stop movement + else { + info.other_rigidbody.data.linear_velocity.y = 0; + info.other_transform.position.x -= info.resolution.x; + } break; case Direction::X_DIRECTION: - info.this_rigidbody.data.linear_velocity.x = 0; - info.this_transform.position.y -= info.resolution.y; + if (info.this_rigidbody.data.elastisity_coefficient > 0) { + info.this_rigidbody.data.linear_velocity.x + = -info.this_rigidbody.data.linear_velocity.x + * info.this_rigidbody.data.elastisity_coefficient; + } + // Stop movement + else { + info.this_rigidbody.data.linear_velocity.x = 0; + info.this_transform.position.y -= info.resolution.y; + } + + if (info.other_rigidbody.data.elastisity_coefficient > 0) { + info.other_rigidbody.data.linear_velocity.x + = -info.other_rigidbody.data.linear_velocity.x + * info.other_rigidbody.data.elastisity_coefficient; + } + // Stop movement + else { + info.other_rigidbody.data.linear_velocity.x = 0; + info.other_transform.position.y -= info.resolution.y; + } break; case Direction::NONE: // Not possible -- cgit v1.2.3 From 17587d6b3d57c7e063514701f88d22a9a50e402f Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 18:38:44 +0100 Subject: scale collider by transform --- src/crepe/system/CollisionSystem.cpp | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 0cd6f5c..cb6fe2c 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -609,11 +609,15 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxC vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1); vec2 final_position2 = this->get_current_position(box2.offset, transform2, rigidbody2); + // Scale dimensions + vec2 scaled_box1 = box1.dimensions * transform1.scale; + vec2 scaled_box2 = box2.dimensions * transform2.scale; + // Calculate half-extents (half width and half height) - float half_width1 = box1.dimensions.x / 2.0; - float half_height1 = box1.dimensions.y / 2.0; - float half_width2 = box2.dimensions.x / 2.0; - float half_height2 = box2.dimensions.y / 2.0; + float half_width1 = scaled_box1.x / 2.0; + float half_height1 = scaled_box1.y / 2.0; + float half_width2 = scaled_box2.x / 2.0; + float half_height2 = scaled_box2.y / 2.0; // Check if the boxes overlap along the X and Y axes return (final_position1.x + half_width1 > final_position2.x - half_width2 @@ -632,9 +636,13 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1); vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2); + // Scale dimensions + vec2 scaled_box = box1.dimensions * transform1.scale; + float scaled_circle = circle2.radius * transform2.scale; + // Calculate box half-extents - float half_width = box1.dimensions.x / 2.0; - float half_height = box1.dimensions.y / 2.0; + float half_width = scaled_box.x / 2.0; + float half_height = scaled_box.y / 2.0; // Find the closest point on the box to the circle's center float closest_x = std::max(final_position1.x - half_width, @@ -648,7 +656,7 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, float distance_squared = distance_x * distance_x + distance_y * distance_y; // Compare distance squared with the square of the circle's radius - return distance_squared < circle2.radius * circle2.radius; + return distance_squared < scaled_circle * scaled_circle; } bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1, @@ -661,12 +669,16 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 vec2 final_position1 = this->get_current_position(circle1.offset, transform1, rigidbody1); vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2); + // Scale dimensions + float scaled_circle1 = circle1.radius * transform1.scale; + float scaled_circle2 = circle2.radius * transform2.scale; + float distance_x = final_position1.x - final_position2.x; float distance_y = final_position1.y - final_position2.y; float distance_squared = distance_x * distance_x + distance_y * distance_y; // Calculate the sum of the radii - float radius_sum = circle1.radius + circle2.radius; + float radius_sum = scaled_circle1 + scaled_circle2; // Check if the distance between the centers is less than or equal to the sum of the radii return distance_squared < radius_sum * radius_sum; -- cgit v1.2.3 From b2a7105fa88b7d23dcb5b698c3c10b76c19c789b Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 18:52:06 +0100 Subject: removed rigidbody offset --- src/crepe/api/Rigidbody.h | 10 ------ src/crepe/system/CollisionSystem.cpp | 70 ++++++++++++++++-------------------- src/crepe/system/CollisionSystem.h | 13 ------- 3 files changed, 31 insertions(+), 62 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index 8169f0c..8566d00 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -122,16 +122,6 @@ public: */ float elastisity_coefficient = 0.0; - /** - * \brief Offset of all colliders relative to the object's transform position. - * - * The `offset` defines a positional shift applied to all colliders associated with the object, relative to the object's - * transform position. This allows for the colliders to be placed at a different position than the object's actual - * position, without modifying the object's transform itself. - * - */ - vec2 offset; - //! Enable collision handeling in collision system bool kinematic_collision = true; diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index cb6fe2c..fc8c430 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -23,6 +23,23 @@ using namespace crepe; +vec2 get_current_position(const Transform & transform,const vec2 & offset) { + // Get the rotation in radians + float radians1 = transform.rotation * (M_PI / 180.0); + + // Calculate total offset with scale + vec2 total_offset = offset * transform.scale; + + // Rotate + float rotated_total_offset_x1 + = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); + float rotated_total_offset_y1 + = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); + + // Final positions considering scaling and rotation + return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); +} + void CollisionSystem::update() { std::vector all_colliders; game_object_id_t id = 0; @@ -138,10 +155,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, - data1.rigidbody); - vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, - data2.rigidbody); + vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); + vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -151,10 +166,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, - data1.rigidbody); - vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, - data2.rigidbody); + vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); + vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2, collider_pos1); break; @@ -164,10 +177,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, - data1.rigidbody); - vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, - data2.rigidbody); + vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); + vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); resolution = this->get_circle_circle_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -177,10 +188,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, - data1.rigidbody); - vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, - data2.rigidbody); + vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); + vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -606,8 +615,8 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxC const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1); - vec2 final_position2 = this->get_current_position(box2.offset, transform2, rigidbody2); + vec2 final_position1 = get_current_position(transform1,box1.offset); + vec2 final_position2 = get_current_position(transform2,box2.offset); // Scale dimensions vec2 scaled_box1 = box1.dimensions * transform1.scale; @@ -633,8 +642,8 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1); - vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2); + vec2 final_position1 = get_current_position(transform1,box1.offset); + vec2 final_position2 = get_current_position(transform2,circle2.offset); // Scale dimensions vec2 scaled_box = box1.dimensions * transform1.scale; @@ -666,8 +675,8 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = this->get_current_position(circle1.offset, transform1, rigidbody1); - vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2); + vec2 final_position1 = get_current_position(transform1,circle1.offset); + vec2 final_position2 = get_current_position(transform2,circle2.offset); // Scale dimensions float scaled_circle1 = circle1.radius * transform1.scale; @@ -684,21 +693,4 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 return distance_squared < radius_sum * radius_sum; } -vec2 CollisionSystem::get_current_position(const vec2 & collider_offset, - const Transform & transform, - const Rigidbody & rigidbody) const { - // Get the rotation in radians - float radians1 = transform.rotation * (M_PI / 180.0); - - // Calculate total offset with scale - vec2 total_offset = (rigidbody.data.offset + collider_offset) * transform.scale; - - // Rotate - float rotated_total_offset_x1 - = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); - float rotated_total_offset_y1 - = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); - // Final positions considering scaling and rotation - return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); -} diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index aebb59b..78fce46 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -100,19 +100,6 @@ private: CollisionInternalType get_collider_type(const collider_variant & collider1, const collider_variant & collider2) const; - /** - * \brief Calculates the current position of a collider. - * - * Combines the Collider offset, Transform position, and Rigidbody offset to compute the position of the collider. - * - * \param collider_offset The offset of the collider. - * \param transform The Transform of the associated game object. - * \param rigidbody The Rigidbody of the associated game object. - * \return The calculated position of the collider. - */ - vec2 get_current_position(const vec2 & collider_offset, const Transform & transform, - const Rigidbody & rigidbody) const; - private: /** * \brief Handles collision resolution between two colliders. -- cgit v1.2.3 From 16f3aa77cfbfd3327a50a3f11f27e7d7dd303026 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 21:14:46 +0100 Subject: Added util for position --- src/crepe/facade/SDLContext.cpp | 2 +- src/crepe/system/CollisionSystem.cpp | 79 +++++++++++++++--------------------- src/crepe/system/CollisionSystem.h | 2 +- src/crepe/system/RenderSystem.cpp | 5 ++- src/crepe/util/AbsoluutPosition.cpp | 21 ++++++++++ src/crepe/util/AbsoluutPosition.h | 17 ++++++++ src/crepe/util/CMakeLists.txt | 2 + src/example/game.cpp | 53 ++++++++++++++++-------- src/test/CollisionTest.cpp | 20 ++++----- 9 files changed, 123 insertions(+), 78 deletions(-) create mode 100644 src/crepe/util/AbsoluutPosition.cpp create mode 100644 src/crepe/util/AbsoluutPosition.h (limited to 'src/crepe') diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 20bb030..ee7d149 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -235,7 +235,7 @@ SDL_FRect SDLContext::get_dst_rect(const DestinationRectangleData & ctx) const { } size *= cam_aux_data.render_scale * ctx.img_scale * data.scale_offset; - vec2 screen_pos = (ctx.pos + data.position_offset - cam_aux_data.cam_pos + vec2 screen_pos = (ctx.pos - cam_aux_data.cam_pos + (cam_aux_data.zoomed_viewport) / 2) * cam_aux_data.render_scale - size / 2 + cam_aux_data.bar_size; diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index fc8c430..294e7b3 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -15,31 +15,15 @@ #include "api/Rigidbody.h" #include "api/Transform.h" #include "api/Vector2.h" +#include "util/OptionalRef.h" +#include "util/AbsoluutPosition.h" #include "Collider.h" #include "CollisionSystem.h" #include "types.h" -#include "util/OptionalRef.h" using namespace crepe; -vec2 get_current_position(const Transform & transform,const vec2 & offset) { - // Get the rotation in radians - float radians1 = transform.rotation * (M_PI / 180.0); - - // Calculate total offset with scale - vec2 total_offset = offset * transform.scale; - - // Rotate - float rotated_total_offset_x1 - = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); - float rotated_total_offset_y1 - = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); - - // Final positions considering scaling and rotation - return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); -} - void CollisionSystem::update() { std::vector all_colliders; game_object_id_t id = 0; @@ -155,8 +139,9 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); - vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); + + vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); + vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -166,8 +151,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); - vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); + vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); + vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2, collider_pos1); break; @@ -177,8 +162,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); - vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); + vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); + vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); resolution = this->get_circle_circle_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -188,8 +173,8 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = get_current_position(data1.transform,collider1.offset); - vec2 collider_pos2 = get_current_position(data2.transform,collider2.offset); + vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); + vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -311,15 +296,7 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co } void CollisionSystem::determine_collision_handler(CollisionInfo & info) { - // If both objects are static skip handle call collision script - if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; - - // First body is not dynamic - if(info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) - { - bool static_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; - bool kinematic_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC && info.this_rigidbody.data.kinematic_collision; - // Inverted collision info + // Inverted collision info CollisionInfo inverted = { .this_collider = info.other_collider, .this_transform = info.other_transform, @@ -332,13 +309,22 @@ void CollisionSystem::determine_collision_handler(CollisionInfo & info) { .resolution = -info.resolution, .resolution_direction = info.resolution_direction, }; + // If both objects are static skip handle call collision script + if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; + + // First body is not dynamic + if(info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) + { + bool static_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; + bool kinematic_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC && info.this_rigidbody.data.kinematic_collision; + if(static_collision || kinematic_collision){ // Static collision this->static_collision_handler(inverted); }; // Call scripts - this->call_collision_events(inverted); + this->call_collision_events(inverted,info); return; } @@ -348,20 +334,21 @@ void CollisionSystem::determine_collision_handler(CollisionInfo & info) { bool static_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC; bool kinematic_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.kinematic_collision; if(static_collision || kinematic_collision) this->static_collision_handler(info); - this->call_collision_events(info); + this->call_collision_events(info,inverted); return; } //dynamic this->dynamic_collision_handler(info); - this->call_collision_events(info); + this->call_collision_events(info,inverted); } -void CollisionSystem::call_collision_events(CollisionInfo & info){ +void CollisionSystem::call_collision_events(CollisionInfo & info,CollisionInfo & info_inverted){ CollisionEvent data(info); + CollisionEvent data_inverted(info_inverted); EventManager & emgr = this->mediator.event_manager; emgr.trigger_event(data, info.this_collider.game_object_id); - emgr.trigger_event(data, info.other_collider.game_object_id); + emgr.trigger_event(data_inverted, info_inverted.this_collider.game_object_id); } void CollisionSystem::static_collision_handler(CollisionInfo & info) { @@ -615,8 +602,8 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxC const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = get_current_position(transform1,box1.offset); - vec2 final_position2 = get_current_position(transform2,box2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1,box1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2,box2.offset); // Scale dimensions vec2 scaled_box1 = box1.dimensions * transform1.scale; @@ -642,8 +629,8 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = get_current_position(transform1,box1.offset); - vec2 final_position2 = get_current_position(transform2,circle2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1,box1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2,circle2.offset); // Scale dimensions vec2 scaled_box = box1.dimensions * transform1.scale; @@ -675,8 +662,8 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = get_current_position(transform1,circle1.offset); - vec2 final_position2 = get_current_position(transform2,circle2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1,circle1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2,circle2.offset); // Scale dimensions float scaled_circle1 = circle1.radius * transform1.scale; diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 78fce46..b802426 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -188,7 +188,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void call_collision_events(CollisionInfo & info); + void call_collision_events(CollisionInfo & info,CollisionInfo & info_inverted); /** * \brief Handles collisions involving static objects. diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index afd9548..d14d78d 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -13,6 +13,7 @@ #include "../facade/Texture.h" #include "../manager/ComponentManager.h" #include "../manager/ResourceManager.h" +#include "util/AbsoluutPosition.h" #include "RenderSystem.h" #include "types.h" @@ -105,11 +106,11 @@ void RenderSystem::render_normal(const Sprite & sprite, const Transform & tm) { SDLContext & ctx = this->mediator.sdl_context; ResourceManager & resource_manager = this->mediator.resource_manager; const Texture & res = resource_manager.get(sprite.source); - + vec2 pos = AbsoluutPosition::get_position(tm,sprite.data.position_offset); ctx.draw(SDLContext::RenderContext{ .sprite = sprite, .texture = res, - .pos = tm.position, + .pos = pos, .angle = tm.rotation, .scale = tm.scale, }); diff --git a/src/crepe/util/AbsoluutPosition.cpp b/src/crepe/util/AbsoluutPosition.cpp new file mode 100644 index 0000000..8be625e --- /dev/null +++ b/src/crepe/util/AbsoluutPosition.cpp @@ -0,0 +1,21 @@ +#include "AbsoluutPosition.h" + +using namespace crepe; + +vec2 AbsoluutPosition::get_position(const Transform & transform,const vec2 & offset) { + // Get the rotation in radians + float radians1 = transform.rotation * (M_PI / 180.0); + + // Calculate total offset with scale + vec2 total_offset = offset * transform.scale; + + // Rotate + float rotated_total_offset_x1 + = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); + float rotated_total_offset_y1 + = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); + + // Final positions considering scaling and rotation + return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); +} + diff --git a/src/crepe/util/AbsoluutPosition.h b/src/crepe/util/AbsoluutPosition.h new file mode 100644 index 0000000..4441f90 --- /dev/null +++ b/src/crepe/util/AbsoluutPosition.h @@ -0,0 +1,17 @@ +#pragma once + + +#include "api/Transform.h" + +#include "types.h" + +namespace crepe { + + +class AbsoluutPosition { +public: + static vec2 get_position(const Transform & transform,const vec2 & offset); + +}; + +} // namespace crepe diff --git a/src/crepe/util/CMakeLists.txt b/src/crepe/util/CMakeLists.txt index 94ed906..b4b9221 100644 --- a/src/crepe/util/CMakeLists.txt +++ b/src/crepe/util/CMakeLists.txt @@ -1,6 +1,7 @@ target_sources(crepe PUBLIC LogColor.cpp Log.cpp + AbsoluutPosition.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -11,5 +12,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Proxy.hpp OptionalRef.h OptionalRef.hpp + AbsoluutPosition.h ) diff --git a/src/example/game.cpp b/src/example/game.cpp index 8ea50ea..3ba15d2 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -3,6 +3,7 @@ #include "manager/ComponentManager.h" #include "manager/Mediator.h" #include "types.h" +#include #include #include #include @@ -66,11 +67,6 @@ class MyScript1 : public Script { //add collider switch break; } - case Keycode::Q: { - Rigidbody & rg = this->get_component(); - rg.data.angular_velocity = 1; - break; - } default: break; } @@ -139,6 +135,31 @@ class MyScript2 : public Script { //add collider switch break; } + case Keycode::J: { + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity.x = -10; + break; + } + case Keycode::I: { + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity.y -= 1; + break; + } + case Keycode::K: { + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity.y += 1; + break; + } + case Keycode::L: { + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity.x = 10; + break; + } + case Keycode::O: { + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity.x = 0; + break; + } default: break; } @@ -175,7 +196,6 @@ public: .mass = 0, .gravity_scale = 0, .body_type = Rigidbody::BodyType::STATIC, - .offset = {0, 0}, .collision_layers = {0}, }); world.add_component( @@ -198,24 +218,26 @@ public: }); GameObject game_object1 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 45, 1); game_object1.add_component(Rigidbody::Data{ .mass = 1, - .gravity_scale = 1, - .body_type = Rigidbody::BodyType::DYNAMIC, + .gravity_scale = 0, + .body_type = Rigidbody::BodyType::KINEMATIC, .linear_velocity = {0, 1}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, - .offset = {0, 0}, .collision_layers = {0}, }); // add box with boxcollider game_object1.add_component(vec2{0, 0}, vec2{20, 20}); game_object1.add_component().set_script(); - Asset img1{"asset/texture/square.png"}; + Asset img1{"asset/texture/test_ap43.png"}; game_object1.add_component(img1, Sprite::Data{ + .sorting_in_layer = 2, + .order_in_layer = 2, .size = {20, 20}, + .position_offset = {0,-10}, }); //add circle with cirlcecollider deactiveated @@ -233,16 +255,15 @@ public: "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); game_object2.add_component(Rigidbody::Data{ .mass = 1, - .gravity_scale = 0, - .body_type = Rigidbody::BodyType::STATIC, + .gravity_scale = 1, + .body_type = Rigidbody::BodyType::KINEMATIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, - .elastisity_coefficient = 1, - .offset = {0, 0}, + .elastisity_coefficient = 0.66, .collision_layers = {0}, }); // add box with boxcollider - game_object2.add_component(vec2{0, 0}, vec2{20, 20}); + game_object2.add_component(vec2{0, 0}, vec2{INFINITY, 20}); game_object2.add_component().set_script(); game_object2.add_component(img1, Sprite::Data{ diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp index 2ad65fa..43bf77d 100644 --- a/src/test/CollisionTest.cpp +++ b/src/test/CollisionTest.cpp @@ -66,7 +66,6 @@ public: world.add_component(Rigidbody::Data{ // TODO: remove unrelated properties: .body_type = Rigidbody::BodyType::STATIC, - .offset = {0, 0}, }); // Create a box with an inner size of 10x10 units world.add_component(vec2{0, -100}, vec2{100, 100}); // Top @@ -81,7 +80,6 @@ public: .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, - .offset = {0, 0}, .collision_layers = {0}, }); game_object1.add_component(vec2{0, 0}, vec2{10, 10}); @@ -97,7 +95,6 @@ public: .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, - .offset = {0, 0}, .collision_layers = {0}, }); game_object2.add_component(vec2{0, 0}, vec2{10, 10}); @@ -138,8 +135,8 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) { script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; EXPECT_EQ(ev.info.this_collider.game_object_id, 2); - EXPECT_EQ(ev.info.resolution.x, 10); - EXPECT_EQ(ev.info.resolution.y, 10); + EXPECT_EQ(ev.info.resolution.x, -10); + EXPECT_EQ(ev.info.resolution.y, -10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; EXPECT_FALSE(collision_happend); @@ -211,8 +208,8 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both) { script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; EXPECT_EQ(ev.info.this_collider.game_object_id, 2); - EXPECT_EQ(ev.info.resolution.x, 10); - EXPECT_EQ(ev.info.resolution.y, 10); + EXPECT_EQ(ev.info.resolution.x, -10); + EXPECT_EQ(ev.info.resolution.y, -10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; EXPECT_FALSE(collision_happend); @@ -294,8 +291,7 @@ TEST_F(CollisionTest, collision_box_box_static_both) { EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { - // is static should not be called - FAIL(); + collision_happend = true; }; EXPECT_FALSE(collision_happend); Transform & tf = this->mgr.get_components_by_id(1).front().get(); @@ -318,7 +314,7 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { // is static should not be called - FAIL(); + //FAIL(); }; EXPECT_FALSE(collision_happend); Transform & tf = this->mgr.get_components_by_id(1).front().get(); @@ -343,7 +339,7 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { // is static should not be called - FAIL(); + //FAIL(); }; EXPECT_FALSE(collision_happend); Transform & tf = this->mgr.get_components_by_id(1).front().get(); @@ -368,7 +364,7 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) { //todo check visually }; script_object2_ref->test_fn = [&](const CollisionEvent & ev) { // is static should not be called - FAIL(); + //FAIL(); }; EXPECT_FALSE(collision_happend); Transform & tf = this->mgr.get_components_by_id(1).front().get(); -- cgit v1.2.3 From ea7beae5974838b6e1727c539b0899ad157bc1fb Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 21:18:28 +0100 Subject: updated particle --- src/crepe/system/ParticleSystem.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 35a1d41..fb6cfd7 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -7,6 +7,7 @@ #include "../api/Transform.h" #include "../manager/ComponentManager.h" #include "../manager/LoopTimerManager.h" +#include "util/AbsoluutPosition.h" #include "ParticleSystem.h" @@ -47,8 +48,8 @@ void ParticleSystem::update() { void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & transform) { constexpr float DEG_TO_RAD = M_PI / 180.0; - - vec2 initial_position = emitter.data.offset + transform.position; + + vec2 initial_position = AbsoluutPosition::get_position(transform, emitter.data.offset); float random_angle = this->generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); -- cgit v1.2.3 From 5bece30f9ad495a0e82097b2c5668e979856fb69 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Mon, 16 Dec 2024 21:22:35 +0100 Subject: make format --- src/crepe/facade/SDLContext.cpp | 3 +- src/crepe/system/CollisionSystem.cpp | 123 +++++++++++++++++++---------------- src/crepe/system/CollisionSystem.h | 2 +- src/crepe/system/ParticleSystem.cpp | 2 +- src/crepe/system/RenderSystem.cpp | 2 +- src/crepe/util/AbsoluutPosition.cpp | 3 +- src/crepe/util/AbsoluutPosition.h | 5 +- src/example/game.cpp | 2 +- src/test/CollisionTest.cpp | 5 +- src/test/Profiling.cpp | 26 ++++---- 10 files changed, 90 insertions(+), 83 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index ee7d149..a1a6f97 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -235,8 +235,7 @@ SDL_FRect SDLContext::get_dst_rect(const DestinationRectangleData & ctx) const { } size *= cam_aux_data.render_scale * ctx.img_scale * data.scale_offset; - vec2 screen_pos = (ctx.pos - cam_aux_data.cam_pos - + (cam_aux_data.zoomed_viewport) / 2) + vec2 screen_pos = (ctx.pos - cam_aux_data.cam_pos + (cam_aux_data.zoomed_viewport) / 2) * cam_aux_data.render_scale - size / 2 + cam_aux_data.bar_size; diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 294e7b3..9604543 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -15,8 +15,8 @@ #include "api/Rigidbody.h" #include "api/Transform.h" #include "api/Vector2.h" -#include "util/OptionalRef.h" #include "util/AbsoluutPosition.h" +#include "util/OptionalRef.h" #include "Collider.h" #include "CollisionSystem.h" @@ -139,9 +139,11 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - - vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); - vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); + + vec2 collider_pos1 + = AbsoluutPosition::get_position(data1.transform, collider1.offset); + vec2 collider_pos2 + = AbsoluutPosition::get_position(data2.transform, collider2.offset); resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -151,8 +153,10 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); - vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); + vec2 collider_pos1 + = AbsoluutPosition::get_position(data1.transform, collider1.offset); + vec2 collider_pos2 + = AbsoluutPosition::get_position(data2.transform, collider2.offset); resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2, collider_pos1); break; @@ -162,8 +166,10 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const CircleCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); - vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); + vec2 collider_pos1 + = AbsoluutPosition::get_position(data1.transform, collider1.offset); + vec2 collider_pos2 + = AbsoluutPosition::get_position(data2.transform, collider2.offset); resolution = this->get_circle_circle_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -173,8 +179,10 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal = std::get>(data1.collider); const BoxCollider & collider2 = std::get>(data2.collider); - vec2 collider_pos1 = AbsoluutPosition::get_position(data1.transform,collider1.offset); - vec2 collider_pos2 = AbsoluutPosition::get_position(data2.transform,collider2.offset); + vec2 collider_pos1 + = AbsoluutPosition::get_position(data1.transform, collider1.offset); + vec2 collider_pos2 + = AbsoluutPosition::get_position(data2.transform, collider2.offset); resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; @@ -297,58 +305,67 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co void CollisionSystem::determine_collision_handler(CollisionInfo & info) { // Inverted collision info - CollisionInfo inverted = { - .this_collider = info.other_collider, - .this_transform = info.other_transform, - .this_rigidbody = info.other_rigidbody, - .this_metadata = info.other_metadata, - .other_collider = info.this_collider, - .other_transform = info.this_transform, - .other_rigidbody = info.this_rigidbody, - .other_metadata = info.this_metadata, - .resolution = -info.resolution, - .resolution_direction = info.resolution_direction, - }; + CollisionInfo inverted = { + .this_collider = info.other_collider, + .this_transform = info.other_transform, + .this_rigidbody = info.other_rigidbody, + .this_metadata = info.other_metadata, + .other_collider = info.this_collider, + .other_transform = info.this_transform, + .other_rigidbody = info.this_rigidbody, + .other_metadata = info.this_metadata, + .resolution = -info.resolution, + .resolution_direction = info.resolution_direction, + }; // If both objects are static skip handle call collision script - if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return; + if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC + && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) + return; // First body is not dynamic - if(info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) - { - bool static_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; - bool kinematic_collision = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC && info.this_rigidbody.data.kinematic_collision; - - - if(static_collision || kinematic_collision){ + if (info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) { + bool static_collision + = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC + && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; + bool kinematic_collision + = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC + && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC + && info.this_rigidbody.data.kinematic_collision; + + if (static_collision || kinematic_collision) { // Static collision this->static_collision_handler(inverted); }; // Call scripts - this->call_collision_events(inverted,info); + this->call_collision_events(inverted, info); return; } // Second body is not dynamic - if(info.other_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) - { - bool static_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC; - bool kinematic_collision = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC && info.other_rigidbody.data.kinematic_collision; - if(static_collision || kinematic_collision) this->static_collision_handler(info); - this->call_collision_events(info,inverted); + if (info.other_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) { + bool static_collision + = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC; + bool kinematic_collision + = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC + && info.other_rigidbody.data.kinematic_collision; + if (static_collision || kinematic_collision) this->static_collision_handler(info); + this->call_collision_events(info, inverted); return; } //dynamic this->dynamic_collision_handler(info); - this->call_collision_events(info,inverted); + this->call_collision_events(info, inverted); } -void CollisionSystem::call_collision_events(CollisionInfo & info,CollisionInfo & info_inverted){ +void CollisionSystem::call_collision_events(CollisionInfo & info, + CollisionInfo & info_inverted) { CollisionEvent data(info); CollisionEvent data_inverted(info_inverted); EventManager & emgr = this->mediator.event_manager; emgr.trigger_event(data, info.this_collider.game_object_id); - emgr.trigger_event(data_inverted, info_inverted.this_collider.game_object_id); + emgr.trigger_event(data_inverted, + info_inverted.this_collider.game_object_id); } void CollisionSystem::static_collision_handler(CollisionInfo & info) { @@ -400,9 +417,9 @@ void CollisionSystem::static_collision_handler(CollisionInfo & info) { } } -void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){ - info.this_transform.position += info.resolution/2; - info.other_transform.position += -(info.resolution/2); +void CollisionSystem::dynamic_collision_handler(CollisionInfo & info) { + info.this_transform.position += info.resolution / 2; + info.other_transform.position += -(info.resolution / 2); switch (info.resolution_direction) { case Direction::BOTH: @@ -410,8 +427,7 @@ void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){ info.this_rigidbody.data.linear_velocity = -info.this_rigidbody.data.linear_velocity * info.this_rigidbody.data.elastisity_coefficient; - } - else { + } else { info.this_rigidbody.data.linear_velocity = {0, 0}; } @@ -419,8 +435,7 @@ void CollisionSystem::dynamic_collision_handler(CollisionInfo & info){ info.other_rigidbody.data.linear_velocity = -info.other_rigidbody.data.linear_velocity * info.other_rigidbody.data.elastisity_coefficient; - } - else { + } else { info.other_rigidbody.data.linear_velocity = {0, 0}; } break; @@ -602,8 +617,8 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxC const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1,box1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2,box2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1, box1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2, box2.offset); // Scale dimensions vec2 scaled_box1 = box1.dimensions * transform1.scale; @@ -629,8 +644,8 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1,box1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2,circle2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1, box1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2, circle2.offset); // Scale dimensions vec2 scaled_box = box1.dimensions * transform1.scale; @@ -662,8 +677,8 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 const Rigidbody & rigidbody1, const Rigidbody & rigidbody2) const { // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1,circle1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2,circle2.offset); + vec2 final_position1 = AbsoluutPosition::get_position(transform1, circle1.offset); + vec2 final_position2 = AbsoluutPosition::get_position(transform2, circle2.offset); // Scale dimensions float scaled_circle1 = circle1.radius * transform1.scale; @@ -679,5 +694,3 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1 // Check if the distance between the centers is less than or equal to the sum of the radii return distance_squared < radius_sum * radius_sum; } - - diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index b802426..23752e1 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -188,7 +188,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void call_collision_events(CollisionInfo & info,CollisionInfo & info_inverted); + void call_collision_events(CollisionInfo & info, CollisionInfo & info_inverted); /** * \brief Handles collisions involving static objects. diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index fb6cfd7..56f1dfd 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -48,7 +48,7 @@ void ParticleSystem::update() { void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & transform) { constexpr float DEG_TO_RAD = M_PI / 180.0; - + vec2 initial_position = AbsoluutPosition::get_position(transform, emitter.data.offset); float random_angle = this->generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index fcb52c3..c0717fc 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -106,7 +106,7 @@ void RenderSystem::render_normal(const Sprite & sprite, const Transform & tm) { SDLContext & ctx = this->mediator.sdl_context; ResourceManager & resource_manager = this->mediator.resource_manager; const Texture & res = resource_manager.get(sprite.source); - vec2 pos = AbsoluutPosition::get_position(tm,sprite.data.position_offset); + vec2 pos = AbsoluutPosition::get_position(tm, sprite.data.position_offset); ctx.draw(SDLContext::RenderContext{ .sprite = sprite, .texture = res, diff --git a/src/crepe/util/AbsoluutPosition.cpp b/src/crepe/util/AbsoluutPosition.cpp index 8be625e..296cc09 100644 --- a/src/crepe/util/AbsoluutPosition.cpp +++ b/src/crepe/util/AbsoluutPosition.cpp @@ -2,7 +2,7 @@ using namespace crepe; -vec2 AbsoluutPosition::get_position(const Transform & transform,const vec2 & offset) { +vec2 AbsoluutPosition::get_position(const Transform & transform, const vec2 & offset) { // Get the rotation in radians float radians1 = transform.rotation * (M_PI / 180.0); @@ -18,4 +18,3 @@ vec2 AbsoluutPosition::get_position(const Transform & transform,const vec2 & off // Final positions considering scaling and rotation return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); } - diff --git a/src/crepe/util/AbsoluutPosition.h b/src/crepe/util/AbsoluutPosition.h index 4441f90..30a7f93 100644 --- a/src/crepe/util/AbsoluutPosition.h +++ b/src/crepe/util/AbsoluutPosition.h @@ -1,17 +1,14 @@ #pragma once - #include "api/Transform.h" #include "types.h" namespace crepe { - class AbsoluutPosition { public: - static vec2 get_position(const Transform & transform,const vec2 & offset); - + static vec2 get_position(const Transform & transform, const vec2 & offset); }; } // namespace crepe diff --git a/src/example/game.cpp b/src/example/game.cpp index b30166e..01a509f 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -238,7 +238,7 @@ public: .sorting_in_layer = 2, .order_in_layer = 2, .size = {20, 20}, - .position_offset = {0,-10}, + .position_offset = {0, -10}, }); //add circle with cirlcecollider deactiveated diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp index 43bf77d..3cb7f33 100644 --- a/src/test/CollisionTest.cpp +++ b/src/test/CollisionTest.cpp @@ -290,9 +290,8 @@ TEST_F(CollisionTest, collision_box_box_static_both) { EXPECT_EQ(ev.info.resolution.y, 10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; - script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { - collision_happend = true; - }; + script_object2_ref->test_fn + = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; }; EXPECT_FALSE(collision_happend); Transform & tf = this->mgr.get_components_by_id(1).front().get(); tf.position = {50, 30}; diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp index 1585061..16736b8 100644 --- a/src/test/Profiling.cpp +++ b/src/test/Profiling.cpp @@ -219,19 +219,19 @@ TEST_F(DISABLED_ProfilingTest, Profiling_3) { .order_in_layer = 1, .size = {.y = 500}, }); - auto & test = gameobject.add_component(test_sprite,ParticleEmitter::Data{ - .max_particles = 10, - .emission_rate = 100, - .end_lifespan = 100000, - .boundary{ - .width = 1000, - .height = 1000, - .offset = vec2{0, 0}, - .reset_on_exit = false, - }, - - } - ); + auto & test = gameobject.add_component( + test_sprite, ParticleEmitter::Data{ + .max_particles = 10, + .emission_rate = 100, + .end_lifespan = 100000, + .boundary{ + .width = 1000, + .height = 1000, + .offset = vec2{0, 0}, + .reset_on_exit = false, + }, + + }); } render_sys.update(); this->game_object_count++; -- cgit v1.2.3 From 3855044ad97a41ca71b0d3ea2240f4eee93cc86f Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 18 Dec 2024 21:13:55 +0100 Subject: updating collision system --- src/crepe/api/Rigidbody.h | 26 +- src/crepe/system/CollisionSystem.cpp | 745 +++++++++++++++++------------------ src/crepe/system/CollisionSystem.h | 115 +++--- src/crepe/system/ParticleSystem.cpp | 4 +- src/crepe/system/RenderSystem.cpp | 4 +- src/crepe/util/AbsolutePosition.cpp | 20 + src/crepe/util/AbsolutePosition.h | 14 + src/crepe/util/AbsoluutPosition.cpp | 20 - src/crepe/util/AbsoluutPosition.h | 14 - src/crepe/util/CMakeLists.txt | 4 +- src/test/CMakeLists.txt | 46 +-- src/test/CollisionTest.cpp | 69 +--- src/test/Profiling.cpp | 2 +- 13 files changed, 514 insertions(+), 569 deletions(-) create mode 100644 src/crepe/util/AbsolutePosition.cpp create mode 100644 src/crepe/util/AbsolutePosition.h delete mode 100644 src/crepe/util/AbsoluutPosition.cpp delete mode 100644 src/crepe/util/AbsoluutPosition.h (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index 0f6be21..df97763 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -2,6 +2,7 @@ #include #include +#include #include "../Component.h" @@ -122,7 +123,7 @@ public: */ float elastisity_coefficient = 0.0; - //! Enable collision handeling in collision system + //! Enable static collision handeling for object colliding with kinematic object in collision system bool kinematic_collision = true; /** @@ -130,9 +131,30 @@ public: * * The `collision_layers` specifies the layers that the GameObject will collide with. * Each element represents a layer ID, and the GameObject will only detect - * collisions with other GameObjects that belong to these layers. + * collisions with other GameObjects that belong to that `collision_layer`. */ std::set collision_layers = {0}; + + //! the collision layer of the object. + int collision_layer = 0; + + /** + * \brief Defines the collision layers of a GameObject. + * + * The `collision_names` specifies where the GameObject will collide with. + * Each element represents a name. + */ + std::set collision_names; + + /** + * \brief Defines the collision layers of a GameObject. + * + * The `collision_tags` specifies where the GameObject will collide with. + * Each element represents a tag. + */ + std::set collision_tags; + + }; public: diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 9604543..8bb8a91 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -15,14 +16,23 @@ #include "api/Rigidbody.h" #include "api/Transform.h" #include "api/Vector2.h" -#include "util/AbsoluutPosition.h" +#include "util/AbsolutePosition.h" #include "util/OptionalRef.h" -#include "Collider.h" #include "CollisionSystem.h" #include "types.h" using namespace crepe; +using enum Rigidbody::BodyType; + +CollisionSystem::CollisionInfo CollisionSystem::CollisionInfo::operator-() const { + return { + .self = this->other, + .other = this->self, + .resolution = -this->resolution, + .resolution_direction = this->resolution_direction, + }; +} void CollisionSystem::update() { std::vector all_colliders; @@ -34,6 +44,7 @@ void CollisionSystem::update() { if (!rigidbody.active) continue; id = rigidbody.game_object_id; Transform & transform = mgr.get_components_by_id(id).front().get(); + Metadata & metadata = mgr.get_components_by_id(id).front().get(); // Check if the boxcollider is active and has the same id as the rigidbody. RefVector boxcolliders = mgr.get_components_by_type(); for (BoxCollider & boxcollider : boxcolliders) { @@ -41,8 +52,8 @@ void CollisionSystem::update() { if (!boxcollider.active) continue; all_colliders.push_back({.id = id, .collider = collider_variant{boxcollider}, - .transform = transform, - .rigidbody = rigidbody}); + .info = {transform,rigidbody, metadata} + }); } // Check if the circlecollider is active and has the same id as the rigidbody. RefVector circlecolliders @@ -52,160 +63,299 @@ void CollisionSystem::update() { if (!circlecollider.active) continue; all_colliders.push_back({.id = id, .collider = collider_variant{circlecollider}, - .transform = transform, - .rigidbody = rigidbody}); + .info = {transform,rigidbody, metadata} + }); } } - // Check between all colliders if there is a collision + // Check between all colliders if there is a collision (collision handling) std::vector> collided = this->gather_collisions(all_colliders); // For both objects call the collision handler for (auto & collision_pair : collided) { - this->collision_handler_request(collision_pair.first, collision_pair.second); - // this->collision_handler_request(collision_pair.second, collision_pair.first); + // Determine type + CollisionInternalType type = this->get_collider_type(collision_pair.first.collider, collision_pair.second.collider); + // Determine resolution + std::pair resolution_data = this->get_collision_resolution(collision_pair.first, collision_pair.second, type); + // Convert internal struct to external struct + CollisionInfo info = this->get_collision_info(collision_pair.first, collision_pair.second,type,resolution_data.first,resolution_data.second); + // Determine if and/or what collison handler is needed. + this->determine_collision_handler(info); } } -void CollisionSystem::collision_handler_request(CollisionInternal & this_data, - CollisionInternal & other_data) { +// Below is for collision detection +std::vector> +CollisionSystem::gather_collisions(const std::vector & colliders) const { + + // TODO: + // If no colliders skip + // Check if colliders has rigidbody if not skip + + // TODO: + // If amount is higer than lets say 16 for now use quadtree otwerwise skip + // Quadtree code + // Quadtree is placed over the input vector + + // Return data of collided colliders which are variants + std::vector> collisions_ret; + //using visit to visit the variant to access the active and id. + for (size_t i = 0; i < colliders.size(); ++i) { + for (size_t j = i + 1; j < colliders.size(); ++j) { + if (colliders[i].id == colliders[j].id) continue; + if (!should_collide(colliders[i], colliders[j])) continue; + CollisionInternalType type = get_collider_type(colliders[i].collider, colliders[j].collider); + if (!get_collision(colliders[i],colliders[j],type)) continue; + collisions_ret.emplace_back(colliders[i], colliders[j]); + } + } + return collisions_ret; +} + + +bool CollisionSystem::should_collide(const CollisionInternal & self, const CollisionInternal & other) const{ + + const Rigidbody::Data & self_rigidbody = self.info.rigidbody.data; + const Rigidbody::Data & other_rigidbody = other.info.rigidbody.data; + const Metadata & self_metadata = self.info.metadata; + const Metadata & other_metadata = other.info.metadata; + + // Check collision layers + if(self_rigidbody.collision_layers.contains(other_rigidbody.collision_layer)) return true; + if(other_rigidbody.collision_layers.contains(self_rigidbody.collision_layer)) return true; + + // Check names + if(self_rigidbody.collision_names.contains(other_metadata.name)) return true; + if(other_rigidbody.collision_names.contains(self_metadata.name)) return true; + + // Check tags + if(self_rigidbody.collision_tags.contains(other_metadata.tag)) return true; + if(other_rigidbody.collision_tags.contains(self_metadata.tag)) return true; + + return false; +} + + +CollisionSystem::CollisionInternalType +CollisionSystem::get_collider_type(const collider_variant & collider1, + const collider_variant & collider2) const { + if (std::holds_alternative>(collider1)) { + if (std::holds_alternative>(collider2)) { + return CollisionInternalType::CIRCLE_CIRCLE; + } else { + return CollisionInternalType::CIRCLE_BOX; + } + } else { + if (std::holds_alternative>(collider2)) { + return CollisionInternalType::BOX_CIRCLE; + } else { + return CollisionInternalType::BOX_BOX; + } + } +} + +bool CollisionSystem::get_collision(const CollisionInternal & self,const CollisionInternal & other,const CollisionInternalType & type) const { + const Transform & self_transform = self.info.transform; + const Transform & other_transform = other.info.transform; + const Rigidbody & self_rigidbody = self.info.rigidbody; + const Rigidbody & other_rigidbody = other.info.rigidbody; + const collider_variant & self_collider = self.collider; + const collider_variant & other_collider = other.collider; - CollisionInternalType type - = this->get_collider_type(this_data.collider, other_data.collider); - std::pair resolution_data - = this->collision_handler(this_data, other_data, type); - ComponentManager & mgr = this->mediator.component_manager; - OptionalRef this_metadata - = mgr.get_components_by_id(this_data.id).front().get(); - OptionalRef other_metadata - = mgr.get_components_by_id(other_data.id).front().get(); - OptionalRef this_collider; - OptionalRef other_collider; switch (type) { - case CollisionInternalType::BOX_BOX: { - this_collider = std::get>(this_data.collider); - other_collider - = std::get>(other_data.collider); - break; + case CollisionInternalType::BOX_BOX: { + const BoxCollider & box_collider1 = std::get>(self_collider); + const BoxCollider & box_collider2 = std::get>(other_collider); + return this->get_box_box_collision(box_collider1, box_collider2, + self_transform, other_transform, + self_rigidbody, other_rigidbody); } case CollisionInternalType::BOX_CIRCLE: { - this_collider = std::get>(this_data.collider); - other_collider - = std::get>(other_data.collider); - break; + const BoxCollider & box_collider = std::get>(self_collider); + const CircleCollider & circle_collider = std::get>(other_collider); + return this->get_box_circle_collision(box_collider, circle_collider, + self_transform, other_transform, + self_rigidbody, other_rigidbody); } - case CollisionInternalType::CIRCLE_BOX: { - this_collider - = std::get>(this_data.collider); - other_collider - = std::get>(other_data.collider); - break; + case CollisionInternalType::CIRCLE_CIRCLE: { + const CircleCollider & circle_collider1 = std::get>(self_collider); + const CircleCollider & circle_collider2 = std::get>(other_collider); + return this->get_circle_circle_collision(circle_collider1, circle_collider2, + self_transform, other_transform, + self_rigidbody, other_rigidbody); } - case CollisionInternalType::CIRCLE_CIRCLE: { - this_collider - = std::get>(this_data.collider); - other_collider - = std::get>(other_data.collider); - break; + case CollisionInternalType::CIRCLE_BOX: { + const CircleCollider & circle_collider = std::get>(self_collider); + const BoxCollider & box_collider = std::get>(other_collider); + return this->get_box_circle_collision(box_collider, circle_collider, + other_transform, self_transform, + other_rigidbody, self_rigidbody); } + case CollisionInternalType::NONE: + break; } + return false; +} - // collision info - crepe::CollisionSystem::CollisionInfo collision_info{ - .this_collider = this_collider, - .this_transform = this_data.transform, - .this_rigidbody = this_data.rigidbody, - .this_metadata = this_metadata, - .other_collider = other_collider, - .other_transform = other_data.transform, - .other_rigidbody = other_data.rigidbody, - .other_metadata = other_metadata, - .resolution = resolution_data.first, - .resolution_direction = resolution_data.second, - }; +bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2, + const Transform & transform1, + const Transform & transform2, + const Rigidbody & rigidbody1, + const Rigidbody & rigidbody2) const { + // Get current positions of colliders + vec2 final_position1 = AbsolutePosition::get_position(transform1, box1.offset); + vec2 final_position2 = AbsolutePosition::get_position(transform2, box2.offset); - // Determine if static needs to be called - this->determine_collision_handler(collision_info); + // Scale dimensions + vec2 scaled_box1 = box1.dimensions * transform1.scale; + vec2 scaled_box2 = box2.dimensions * transform2.scale; + + // Calculate half-extents (half width and half height) + float half_width1 = scaled_box1.x / 2.0; + float half_height1 = scaled_box1.y / 2.0; + float half_width2 = scaled_box2.x / 2.0; + float half_height2 = scaled_box2.y / 2.0; + + // Check if the boxes overlap along the X and Y axes + return (final_position1.x + half_width1 > final_position2.x - half_width2 + && final_position1.x - half_width1 < final_position2.x + half_width2 + && final_position1.y + half_height1 > final_position2.y - half_height2 + && final_position1.y - half_height1 < final_position2.y + half_height2); +} + +bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, + const CircleCollider & circle2, + const Transform & transform1, + const Transform & transform2, + const Rigidbody & rigidbody1, + const Rigidbody & rigidbody2) const { + // Get current positions of colliders + vec2 final_position1 = AbsolutePosition::get_position(transform1, box1.offset); + vec2 final_position2 = AbsolutePosition::get_position(transform2, circle2.offset); + + // Scale dimensions + vec2 scaled_box = box1.dimensions * transform1.scale; + float scaled_circle = circle2.radius * transform2.scale; + + // Calculate box half-extents + float half_width = scaled_box.x / 2.0; + float half_height = scaled_box.y / 2.0; + + // Find the closest point on the box to the circle's center + float closest_x = std::max(final_position1.x - half_width, + std::min(final_position2.x, final_position1.x + half_width)); + float closest_y = std::max(final_position1.y - half_height, + std::min(final_position2.y, final_position1.y + half_height)); + + // Calculate the distance squared between the circle's center and the closest point on the box + float distance_x = final_position2.x - closest_x; + float distance_y = final_position2.y - closest_y; + float distance_squared = distance_x * distance_x + distance_y * distance_y; + + // Compare distance squared with the square of the circle's radius + return distance_squared < scaled_circle * scaled_circle; +} + +bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1, + const CircleCollider & circle2, + const Transform & transform1, + const Transform & transform2, + const Rigidbody & rigidbody1, + const Rigidbody & rigidbody2) const { + // Get current positions of colliders + vec2 final_position1 = AbsolutePosition::get_position(transform1, circle1.offset); + vec2 final_position2 = AbsolutePosition::get_position(transform2, circle2.offset); + + // Scale dimensions + float scaled_circle1 = circle1.radius * transform1.scale; + float scaled_circle2 = circle2.radius * transform2.scale; + + float distance_x = final_position1.x - final_position2.x; + float distance_y = final_position1.y - final_position2.y; + float distance_squared = distance_x * distance_x + distance_y * distance_y; + + // Calculate the sum of the radii + float radius_sum = scaled_circle1 + scaled_circle2; + + // Check if the distance between the centers is less than or equal to the sum of the radii + return distance_squared < radius_sum * radius_sum; } std::pair -CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal & data2, - CollisionInternalType type) { +CollisionSystem::get_collision_resolution(const CollisionInternal & self, const CollisionInternal & other, + const CollisionInternalType & type) const { vec2 resolution; switch (type) { case CollisionInternalType::BOX_BOX: { - const BoxCollider & collider1 - = std::get>(data1.collider); - const BoxCollider & collider2 - = std::get>(data2.collider); - - vec2 collider_pos1 - = AbsoluutPosition::get_position(data1.transform, collider1.offset); - vec2 collider_pos2 - = AbsoluutPosition::get_position(data2.transform, collider2.offset); - resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, - collider_pos2); + const BoxCollider & collider1 = std::get>(self.collider); + const BoxCollider & collider2 = std::get>(other.collider); + vec2 collider_pos1 = AbsolutePosition::get_position(self.info.transform, collider1.offset); + vec2 collider_pos2 = AbsolutePosition::get_position(other.info.transform, collider2.offset); + resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; } case CollisionInternalType::BOX_CIRCLE: { const BoxCollider & collider1 - = std::get>(data1.collider); + = std::get>(self.collider); const CircleCollider & collider2 - = std::get>(data2.collider); + = std::get>(other.collider); vec2 collider_pos1 - = AbsoluutPosition::get_position(data1.transform, collider1.offset); + = AbsolutePosition::get_position(self.info.transform, collider1.offset); vec2 collider_pos2 - = AbsoluutPosition::get_position(data2.transform, collider2.offset); + = AbsolutePosition::get_position(other.info.transform, collider2.offset); resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2, collider_pos1); break; } case CollisionInternalType::CIRCLE_CIRCLE: { const CircleCollider & collider1 - = std::get>(data1.collider); + = std::get>(self.collider); const CircleCollider & collider2 - = std::get>(data2.collider); + = std::get>(other.collider); vec2 collider_pos1 - = AbsoluutPosition::get_position(data1.transform, collider1.offset); + = AbsolutePosition::get_position(self.info.transform, collider1.offset); vec2 collider_pos2 - = AbsoluutPosition::get_position(data2.transform, collider2.offset); + = AbsolutePosition::get_position(other.info.transform, collider2.offset); resolution = this->get_circle_circle_resolution(collider1, collider2, collider_pos1, collider_pos2); break; } case CollisionInternalType::CIRCLE_BOX: { const CircleCollider & collider1 - = std::get>(data1.collider); + = std::get>(self.collider); const BoxCollider & collider2 - = std::get>(data2.collider); + = std::get>(other.collider); vec2 collider_pos1 - = AbsoluutPosition::get_position(data1.transform, collider1.offset); + = AbsolutePosition::get_position(self.info.transform, collider1.offset); vec2 collider_pos2 - = AbsoluutPosition::get_position(data2.transform, collider2.offset); + = AbsolutePosition::get_position(other.info.transform, collider2.offset); resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1, collider_pos2); break; } + case CollisionInternalType::NONE: + break; } + // Calculate the other value to move back correctly + // If only X or Y has a value determine what is should be to move back. + const Rigidbody::Data & rigidbody = self.info.rigidbody.data; Direction resolution_direction = Direction::NONE; + // If both are not zero a perfect corner has been hit if (resolution.x != 0 && resolution.y != 0) { resolution_direction = Direction::BOTH; + // If x is not zero a horizontal action was latest action. } else if (resolution.x != 0) { resolution_direction = Direction::X_DIRECTION; - //checks if the other velocity has a value and if this object moved - if (data1.rigidbody.data.linear_velocity.x != 0 - && data1.rigidbody.data.linear_velocity.y != 0) - resolution.y = -data1.rigidbody.data.linear_velocity.y - * (resolution.x / data1.rigidbody.data.linear_velocity.x); + // If both are 0 resolution y should not be changed (y_velocity can be 0 by kinematic object movement) + if (rigidbody.linear_velocity.x != 0 && rigidbody.linear_velocity.y != 0) + resolution.y = -rigidbody.linear_velocity.y * (resolution.x / rigidbody.linear_velocity.x); } else if (resolution.y != 0) { resolution_direction = Direction::Y_DIRECTION; - //checks if the other velocity has a value and if this object moved - if (data1.rigidbody.data.linear_velocity.x != 0 - && data1.rigidbody.data.linear_velocity.y != 0) - resolution.x = -data1.rigidbody.data.linear_velocity.x - * (resolution.y / data1.rigidbody.data.linear_velocity.y); + // If both are 0 resolution x should not be changed (x_velocity can be 0 by kinematic object movement) + if (rigidbody.linear_velocity.x != 0 && rigidbody.linear_velocity.y != 0) + resolution.x = -rigidbody.linear_velocity.x * (resolution.y / rigidbody.linear_velocity.y); } return std::make_pair(resolution, resolution_direction); @@ -218,6 +368,9 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1, vec2 resolution; // Default resolution vector vec2 delta = final_position2 - final_position1; + vec2 scaled_box1 = box_collider1.dimensions * transform1.scale; + vec2 scaled_box2 = box_collider2.dimensions * transform2.scale; + // Compute half-dimensions of the boxes float half_width1 = box_collider1.dimensions.x / 2.0; float half_height1 = box_collider1.dimensions.y / 2.0; @@ -303,112 +456,114 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co return resolution; } -void CollisionSystem::determine_collision_handler(CollisionInfo & info) { - // Inverted collision info - CollisionInfo inverted = { - .this_collider = info.other_collider, - .this_transform = info.other_transform, - .this_rigidbody = info.other_rigidbody, - .this_metadata = info.other_metadata, - .other_collider = info.this_collider, - .other_transform = info.this_transform, - .other_rigidbody = info.this_rigidbody, - .other_metadata = info.this_metadata, - .resolution = -info.resolution, - .resolution_direction = info.resolution_direction, +CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const CollisionInternal & in_self, const CollisionInternal & in_other,const CollisionInternalType & type,const vec2 & resolution,const CollisionSystem::Direction & resolution_direction) const{ + + ComponentManager & mgr = this->mediator.component_manager; + + crepe::CollisionSystem::ColliderInfo self { + .transform = in_self.info.transform, + .rigidbody = in_self.info.rigidbody, + .metadata = in_self.info.metadata, + }; + + crepe::CollisionSystem::ColliderInfo other { + .transform = in_other.info.transform, + .rigidbody = in_other.info.rigidbody, + .metadata = in_other.info.metadata, }; + + struct CollisionInfo collision_info{ + .self = self, + .other = other, + .resolution = resolution, + .resolution_direction = resolution_direction, + }; + return collision_info; +} + +// Below is for collision handling +void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { + Rigidbody::BodyType self_type = info.self.rigidbody.data.body_type; + Rigidbody::BodyType other_type = info.self.rigidbody.data.body_type; + bool self_kinematic = info.self.rigidbody.data.kinematic_collision; + bool other_kinematic = info.self.rigidbody.data.kinematic_collision; + // Inverted collision info + CollisionInfo inverted = -info; // If both objects are static skip handle call collision script - if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC - && info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) + if (self_type == STATIC + && other_type == STATIC) return; // First body is not dynamic - if (info.this_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) { - bool static_collision - = info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC - && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC; - bool kinematic_collision - = info.this_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC - && info.other_rigidbody.data.body_type == Rigidbody::BodyType::DYNAMIC - && info.this_rigidbody.data.kinematic_collision; - - if (static_collision || kinematic_collision) { - // Static collision - this->static_collision_handler(inverted); - }; + if (self_type != DYNAMIC) { + bool static_collision = self_type == STATIC && other_type == DYNAMIC; + bool kinematic_collision = self_type == KINEMATIC && other_type == DYNAMIC && self_kinematic; + + // Handle collision + if (static_collision || kinematic_collision) this->static_collision_handler(inverted); // Call scripts this->call_collision_events(inverted, info); return; } // Second body is not dynamic - if (info.other_rigidbody.data.body_type != Rigidbody::BodyType::DYNAMIC) { - bool static_collision - = info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC; - bool kinematic_collision - = info.other_rigidbody.data.body_type == Rigidbody::BodyType::KINEMATIC - && info.other_rigidbody.data.kinematic_collision; + if (other_type != DYNAMIC) { + bool static_collision = other_type == STATIC; + bool kinematic_collision = other_type == KINEMATIC && other_kinematic; + // Handle collision if (static_collision || kinematic_collision) this->static_collision_handler(info); + // Call scripts this->call_collision_events(info, inverted); return; } - //dynamic + // Dynamic + // Handle collision this->dynamic_collision_handler(info); + // Call scripts this->call_collision_events(info, inverted); } -void CollisionSystem::call_collision_events(CollisionInfo & info, - CollisionInfo & info_inverted) { - CollisionEvent data(info); - CollisionEvent data_inverted(info_inverted); - EventManager & emgr = this->mediator.event_manager; - emgr.trigger_event(data, info.this_collider.game_object_id); - emgr.trigger_event(data_inverted, - info_inverted.this_collider.game_object_id); -} - -void CollisionSystem::static_collision_handler(CollisionInfo & info) { +void CollisionSystem::static_collision_handler(const CollisionInfo & info) { + + vec2 & transform_pos = info.self.transform.position; + float elastisity = info.self.rigidbody.data.elastisity_coefficient; + vec2 & rigidbody_vel = info.self.rigidbody.data.linear_velocity; + // Move object back using calculate move back value - info.this_transform.position += info.resolution; + transform_pos += info.resolution; switch (info.resolution_direction) { case Direction::BOTH: //bounce - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity - = -info.this_rigidbody.data.linear_velocity - * info.this_rigidbody.data.elastisity_coefficient; + if (elastisity > 0) { + rigidbody_vel = -rigidbody_vel * elastisity; } //stop movement else { - info.this_rigidbody.data.linear_velocity = {0, 0}; + rigidbody_vel = {0, 0}; } break; case Direction::Y_DIRECTION: // Bounce - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity.y - = -info.this_rigidbody.data.linear_velocity.y - * info.this_rigidbody.data.elastisity_coefficient; + if (elastisity > 0) { + rigidbody_vel.y = -rigidbody_vel.y * elastisity; } // Stop movement else { - info.this_rigidbody.data.linear_velocity.y = 0; - info.this_transform.position.x -= info.resolution.x; + rigidbody_vel.y = 0; + transform_pos.x -= info.resolution.x; } break; case Direction::X_DIRECTION: // Bounce - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity.x - = -info.this_rigidbody.data.linear_velocity.x - * info.this_rigidbody.data.elastisity_coefficient; + if (elastisity > 0) { + rigidbody_vel.x = -rigidbody_vel.x * elastisity; } // Stop movement else { - info.this_rigidbody.data.linear_velocity.x = 0; - info.this_transform.position.y -= info.resolution.y; + rigidbody_vel.x = 0; + transform_pos.y -= info.resolution.y; } break; case Direction::NONE: @@ -417,72 +572,68 @@ void CollisionSystem::static_collision_handler(CollisionInfo & info) { } } -void CollisionSystem::dynamic_collision_handler(CollisionInfo & info) { - info.this_transform.position += info.resolution / 2; - info.other_transform.position += -(info.resolution / 2); +void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { + + vec2 & self_transform_pos = info.self.transform.position; + vec2 & other_transform_pos = info.other.transform.position; + float self_elastisity = info.self.rigidbody.data.elastisity_coefficient; + float other_elastisity = info.other.rigidbody.data.elastisity_coefficient; + vec2 & self_rigidbody_vel = info.self.rigidbody.data.linear_velocity; + vec2 & other_rigidbody_vel = info.other.rigidbody.data.linear_velocity; + + self_transform_pos += info.resolution / 2; + other_transform_pos += -(info.resolution / 2); switch (info.resolution_direction) { case Direction::BOTH: - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity - = -info.this_rigidbody.data.linear_velocity - * info.this_rigidbody.data.elastisity_coefficient; + if (self_elastisity > 0) { + self_rigidbody_vel = -self_rigidbody_vel * self_elastisity; } else { - info.this_rigidbody.data.linear_velocity = {0, 0}; + self_rigidbody_vel = {0, 0}; } - if (info.other_rigidbody.data.elastisity_coefficient > 0) { - info.other_rigidbody.data.linear_velocity - = -info.other_rigidbody.data.linear_velocity - * info.other_rigidbody.data.elastisity_coefficient; + if (other_elastisity > 0) { + other_rigidbody_vel = -other_rigidbody_vel * other_elastisity; } else { - info.other_rigidbody.data.linear_velocity = {0, 0}; + other_rigidbody_vel = {0, 0}; } break; case Direction::Y_DIRECTION: - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity.y - = -info.this_rigidbody.data.linear_velocity.y - * info.this_rigidbody.data.elastisity_coefficient; + if (self_elastisity > 0) { + self_rigidbody_vel.y = -self_rigidbody_vel.y * self_elastisity; } // Stop movement else { - info.this_rigidbody.data.linear_velocity.y = 0; - info.this_transform.position.x -= info.resolution.x; + self_rigidbody_vel.y = 0; + self_transform_pos.x -= info.resolution.x; } - if (info.other_rigidbody.data.elastisity_coefficient > 0) { - info.other_rigidbody.data.linear_velocity.y - = -info.other_rigidbody.data.linear_velocity.y - * info.other_rigidbody.data.elastisity_coefficient; + if (other_elastisity > 0) { + other_rigidbody_vel.y = -other_rigidbody_vel.y * other_elastisity; } // Stop movement else { - info.other_rigidbody.data.linear_velocity.y = 0; - info.other_transform.position.x -= info.resolution.x; + other_rigidbody_vel.y = 0; + other_transform_pos.x -= info.resolution.x; } break; case Direction::X_DIRECTION: - if (info.this_rigidbody.data.elastisity_coefficient > 0) { - info.this_rigidbody.data.linear_velocity.x - = -info.this_rigidbody.data.linear_velocity.x - * info.this_rigidbody.data.elastisity_coefficient; + if (self_elastisity > 0) { + self_rigidbody_vel.x = -self_rigidbody_vel.x * self_elastisity; } // Stop movement else { - info.this_rigidbody.data.linear_velocity.x = 0; - info.this_transform.position.y -= info.resolution.y; + self_rigidbody_vel.x = 0; + self_transform_pos.y -= info.resolution.y; } - if (info.other_rigidbody.data.elastisity_coefficient > 0) { - info.other_rigidbody.data.linear_velocity.x - = -info.other_rigidbody.data.linear_velocity.x - * info.other_rigidbody.data.elastisity_coefficient; + if (other_elastisity > 0) { + other_rigidbody_vel.x = -other_rigidbody_vel.x * other_elastisity; } // Stop movement else { - info.other_rigidbody.data.linear_velocity.x = 0; - info.other_transform.position.y -= info.resolution.y; + other_rigidbody_vel.x = 0; + other_transform_pos.y -= info.resolution.y; } break; case Direction::NONE: @@ -491,206 +642,16 @@ void CollisionSystem::dynamic_collision_handler(CollisionInfo & info) { } } -std::vector> -CollisionSystem::gather_collisions(std::vector & colliders) { - - // TODO: - // If no colliders skip - // Check if colliders has rigidbody if not skip - - // TODO: - // If amount is higer than lets say 16 for now use quadtree otwerwise skip - // Quadtree code - // Quadtree is placed over the input vector - - // Return data of collided colliders which are variants - std::vector> collisions_ret; - //using visit to visit the variant to access the active and id. - for (size_t i = 0; i < colliders.size(); ++i) { - for (size_t j = i + 1; j < colliders.size(); ++j) { - if (colliders[i].id == colliders[j].id) continue; - if (!have_common_layer(colliders[i].rigidbody.data.collision_layers, - colliders[j].rigidbody.data.collision_layers)) - continue; - CollisionInternalType type - = get_collider_type(colliders[i].collider, colliders[j].collider); - if (!get_collision( - { - .collider = colliders[i].collider, - .transform = colliders[i].transform, - .rigidbody = colliders[i].rigidbody, - }, - { - .collider = colliders[j].collider, - .transform = colliders[j].transform, - .rigidbody = colliders[j].rigidbody, - }, - type)) - continue; - collisions_ret.emplace_back(colliders[i], colliders[j]); - } - } - - return collisions_ret; -} - -bool CollisionSystem::have_common_layer(const std::set & layers1, - const std::set & layers2) { - - // Check if any number is equal in the layers - for (int num : layers1) { - if (layers2.contains(num)) { - // Common layer found - return true; - break; - } - } - // No common layer found - return false; -} - -CollisionSystem::CollisionInternalType -CollisionSystem::get_collider_type(const collider_variant & collider1, - const collider_variant & collider2) const { - if (std::holds_alternative>(collider1)) { - if (std::holds_alternative>(collider2)) { - return CollisionInternalType::CIRCLE_CIRCLE; - } else { - return CollisionInternalType::CIRCLE_BOX; - } - } else { - if (std::holds_alternative>(collider2)) { - return CollisionInternalType::BOX_CIRCLE; - } else { - return CollisionInternalType::BOX_BOX; - } - } -} - -bool CollisionSystem::get_collision(const CollisionInternal & first_info, - const CollisionInternal & second_info, - CollisionInternalType type) const { - switch (type) { - case CollisionInternalType::BOX_BOX: { - const BoxCollider & box_collider1 - = std::get>(first_info.collider); - const BoxCollider & box_collider2 - = std::get>(second_info.collider); - return this->get_box_box_collision(box_collider1, box_collider2, - first_info.transform, second_info.transform, - second_info.rigidbody, second_info.rigidbody); - } - case CollisionInternalType::BOX_CIRCLE: { - const BoxCollider & box_collider - = std::get>(first_info.collider); - const CircleCollider & circle_collider - = std::get>(second_info.collider); - return this->get_box_circle_collision( - box_collider, circle_collider, first_info.transform, second_info.transform, - second_info.rigidbody, second_info.rigidbody); - } - case CollisionInternalType::CIRCLE_CIRCLE: { - const CircleCollider & circle_collider1 - = std::get>(first_info.collider); - const CircleCollider & circle_collider2 - = std::get>(second_info.collider); - return this->get_circle_circle_collision( - circle_collider1, circle_collider2, first_info.transform, - second_info.transform, second_info.rigidbody, second_info.rigidbody); - } - case CollisionInternalType::CIRCLE_BOX: { - const CircleCollider & circle_collider - = std::get>(first_info.collider); - const BoxCollider & box_collider - = std::get>(second_info.collider); - return this->get_box_circle_collision( - box_collider, circle_collider, first_info.transform, second_info.transform, - second_info.rigidbody, second_info.rigidbody); - } - } - return false; -} - -bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { - // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1, box1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2, box2.offset); - - // Scale dimensions - vec2 scaled_box1 = box1.dimensions * transform1.scale; - vec2 scaled_box2 = box2.dimensions * transform2.scale; - - // Calculate half-extents (half width and half height) - float half_width1 = scaled_box1.x / 2.0; - float half_height1 = scaled_box1.y / 2.0; - float half_width2 = scaled_box2.x / 2.0; - float half_height2 = scaled_box2.y / 2.0; - - // Check if the boxes overlap along the X and Y axes - return (final_position1.x + half_width1 > final_position2.x - half_width2 - && final_position1.x - half_width1 < final_position2.x + half_width2 - && final_position1.y + half_height1 > final_position2.y - half_height2 - && final_position1.y - half_height1 < final_position2.y + half_height2); -} - -bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, - const CircleCollider & circle2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { - // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1, box1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2, circle2.offset); - - // Scale dimensions - vec2 scaled_box = box1.dimensions * transform1.scale; - float scaled_circle = circle2.radius * transform2.scale; - - // Calculate box half-extents - float half_width = scaled_box.x / 2.0; - float half_height = scaled_box.y / 2.0; - - // Find the closest point on the box to the circle's center - float closest_x = std::max(final_position1.x - half_width, - std::min(final_position2.x, final_position1.x + half_width)); - float closest_y = std::max(final_position1.y - half_height, - std::min(final_position2.y, final_position1.y + half_height)); - - // Calculate the distance squared between the circle's center and the closest point on the box - float distance_x = final_position2.x - closest_x; - float distance_y = final_position2.y - closest_y; - float distance_squared = distance_x * distance_x + distance_y * distance_y; - - // Compare distance squared with the square of the circle's radius - return distance_squared < scaled_circle * scaled_circle; +void CollisionSystem::call_collision_events(const CollisionInfo & info, + const CollisionInfo & info_inverted) { + CollisionEvent data(info); + CollisionEvent data_inverted(info_inverted); + EventManager & emgr = this->mediator.event_manager; + emgr.trigger_event(data, info.self.transform.game_object_id); + emgr.trigger_event(data_inverted, + info_inverted.self.transform.game_object_id); } -bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1, - const CircleCollider & circle2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { - // Get current positions of colliders - vec2 final_position1 = AbsoluutPosition::get_position(transform1, circle1.offset); - vec2 final_position2 = AbsoluutPosition::get_position(transform2, circle2.offset); - // Scale dimensions - float scaled_circle1 = circle1.radius * transform1.scale; - float scaled_circle2 = circle2.radius * transform2.scale; - float distance_x = final_position1.x - final_position2.x; - float distance_y = final_position1.y - final_position2.y; - float distance_squared = distance_x * distance_x + distance_y * distance_y; - // Calculate the sum of the radii - float radius_sum = scaled_circle1 + scaled_circle2; - - // Check if the distance between the centers is less than or equal to the sum of the radii - return distance_squared < radius_sum * radius_sum; -} diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 23752e1..01c189e 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -21,6 +21,40 @@ namespace crepe { class CollisionSystem : public System { public: using System::System; +private: + //! Enum representing movement directions during collision resolution. + enum class Direction { + //! No movement required. + NONE, + //! Movement in the X direction. + X_DIRECTION, + //! Movement in the Y direction. + Y_DIRECTION, + //! Movement in both X and Y directions. + BOTH + }; +public: + /** + * \brief Structure representing detailed collision information between two colliders. + * + * Includes information about the colliding objects and the resolution data for handling the collision. + */ + + struct ColliderInfo { + Transform & transform; + Rigidbody & rigidbody; + Metadata & metadata; + }; + + struct CollisionInfo { + ColliderInfo self; + ColliderInfo other; + //! The resolution vector for the collision. + vec2 resolution; + //! The direction of movement for resolving the collision. + Direction resolution_direction = Direction::NONE; + CollisionInfo operator - () const; + }; private: //! A variant type that can hold either a BoxCollider or a CircleCollider. @@ -33,6 +67,7 @@ private: CIRCLE_CIRCLE, BOX_CIRCLE, CIRCLE_BOX, + NONE, }; /** @@ -46,41 +81,7 @@ private: struct CollisionInternal { game_object_id_t id = 0; collider_variant collider; - Transform & transform; - Rigidbody & rigidbody; - }; - - //! Enum representing movement directions during collision resolution. - enum class Direction { - //! No movement required. - NONE, - //! Movement in the X direction. - X_DIRECTION, - //! Movement in the Y direction. - Y_DIRECTION, - //! Movement in both X and Y directions. - BOTH - }; - -public: - /** - * \brief Structure representing detailed collision information between two colliders. - * - * Includes information about the colliding objects and the resolution data for handling the collision. - */ - struct CollisionInfo { - Collider & this_collider; - Transform & this_transform; - Rigidbody & this_rigidbody; - Metadata & this_metadata; - Collider & other_collider; - Transform & other_transform; - Rigidbody & other_rigidbody; - Metadata & other_metadata; - //! The resolution vector for the collision. - vec2 resolution; - //! The direction of movement for resolving the collision. - Direction resolution_direction = Direction::NONE; + ColliderInfo info; }; public: @@ -97,8 +98,7 @@ private: * \param collider2 Second collider variant (BoxCollider or CircleCollider). * \return The combined type of the two colliders. */ - CollisionInternalType get_collider_type(const collider_variant & collider1, - const collider_variant & collider2) const; + CollisionInternalType get_collider_type(const collider_variant & collider1, const collider_variant & collider2) const; private: /** @@ -109,7 +109,7 @@ private: * \param data1 Collision data for the first collider. * \param data2 Collision data for the second collider. */ - void collision_handler_request(CollisionInternal & data1, CollisionInternal & data2); + CollisionInfo get_collision_info(const CollisionInternal & this_data, const CollisionInternal & other_data,const CollisionInternalType & type,const vec2 & resolution,const CollisionSystem::Direction & resolution_direction) const; //done /** * \brief Resolves collision between two colliders and calculates the movement required. @@ -121,9 +121,7 @@ private: * \param type The type of collider pair. * \return A pair containing the resolution vector and direction for the first collider. */ - std::pair collision_handler(CollisionInternal & data1, - CollisionInternal & data2, - CollisionInternalType type); + std::pair get_collision_resolution(const CollisionInternal & data1,const CollisionInternal & data2, const CollisionInternalType & type) const; //done /** * \brief Calculates the resolution vector for two BoxColliders. @@ -179,7 +177,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void determine_collision_handler(CollisionInfo & info); + void determine_collision_handler(const CollisionInfo & info); //done /** * \brief Calls both collision script @@ -188,7 +186,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void call_collision_events(CollisionInfo & info, CollisionInfo & info_inverted); + void call_collision_events(const CollisionInfo & info, const CollisionInfo & info_inverted); /** * \brief Handles collisions involving static objects. @@ -197,7 +195,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void static_collision_handler(CollisionInfo & info); + void static_collision_handler(const CollisionInfo & info); //done /** * \brief Handles collisions involving dynamic objects. @@ -206,7 +204,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void dynamic_collision_handler(CollisionInfo & info); + void dynamic_collision_handler(const CollisionInfo & info); //done private: /** @@ -218,23 +216,22 @@ private: * \return A list of collision pairs with their associated data. */ std::vector> - gather_collisions(std::vector & colliders); + gather_collisions(const std::vector & colliders) const; //done /** - * \brief Checks if two collision layers have at least one common layer. + * \brief Checks if the settings allow collision * - * This function checks if there is any overlapping layer between the two inputs. - * It compares each layer from the first input to see - * if it exists in the second input. If at least one common layer is found, - * the function returns true, indicating that the two colliders share a common - * collision layer. + * This function checks if there is any collison layer where each object is located in. + * After checking the layers it checks the names and at last the tags. + * if in all three sets nothing is found collision can not happen. * - * \param layers1 all collision layers for the first collider. - * \param layers2 all collision layers for the second collider. - * \return Returns true if there is at least one common layer, false otherwise. + * \param this_rigidbody Rigidbody of first object + * \param other_rigidbody Rigidbody of second collider + * \param this_metadata Rigidbody of first object + * \param other_metadata Rigidbody of second object + * \return Returns true if there is at least one comparision found. */ - - bool have_common_layer(const std::set & layers1, const std::set & layers2); + bool should_collide(const CollisionInternal & self, const CollisionInternal & other) const; //done /** * \brief Checks for collision between two colliders. @@ -246,9 +243,7 @@ private: * \param type The type of collider pair. * \return True if a collision is detected, otherwise false. */ - bool get_collision(const CollisionInternal & first_info, - const CollisionInternal & second_info, - CollisionInternalType type) const; + bool get_collision(const CollisionInternal & first_info, const CollisionInternal & second_info, const CollisionInternalType & type) const; /** * \brief Detects collisions between two BoxColliders. diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 56f1dfd..3183fd7 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -7,7 +7,7 @@ #include "../api/Transform.h" #include "../manager/ComponentManager.h" #include "../manager/LoopTimerManager.h" -#include "util/AbsoluutPosition.h" +#include "util/AbsolutePosition.h" #include "ParticleSystem.h" @@ -49,7 +49,7 @@ void ParticleSystem::update() { void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & transform) { constexpr float DEG_TO_RAD = M_PI / 180.0; - vec2 initial_position = AbsoluutPosition::get_position(transform, emitter.data.offset); + vec2 initial_position = AbsolutePosition::get_position(transform, emitter.data.offset); float random_angle = this->generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index c0717fc..7c48d10 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -13,7 +13,7 @@ #include "../facade/Texture.h" #include "../manager/ComponentManager.h" #include "../manager/ResourceManager.h" -#include "util/AbsoluutPosition.h" +#include "util/AbsolutePosition.h" #include "RenderSystem.h" #include "types.h" @@ -106,7 +106,7 @@ void RenderSystem::render_normal(const Sprite & sprite, const Transform & tm) { SDLContext & ctx = this->mediator.sdl_context; ResourceManager & resource_manager = this->mediator.resource_manager; const Texture & res = resource_manager.get(sprite.source); - vec2 pos = AbsoluutPosition::get_position(tm, sprite.data.position_offset); + vec2 pos = AbsolutePosition::get_position(tm, sprite.data.position_offset); ctx.draw(SDLContext::RenderContext{ .sprite = sprite, .texture = res, diff --git a/src/crepe/util/AbsolutePosition.cpp b/src/crepe/util/AbsolutePosition.cpp new file mode 100644 index 0000000..29ade23 --- /dev/null +++ b/src/crepe/util/AbsolutePosition.cpp @@ -0,0 +1,20 @@ +#include "AbsolutePosition.h" + +using namespace crepe; + +vec2 AbsolutePosition::get_position(const Transform & transform, const vec2 & offset) { + // Get the rotation in radians + float radians1 = transform.rotation * (M_PI / 180.0); + + // Calculate total offset with scale + vec2 total_offset = offset * transform.scale; + + // Rotate + float rotated_total_offset_x1 + = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); + float rotated_total_offset_y1 + = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); + + // Final positions considering scaling and rotation + return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); +} diff --git a/src/crepe/util/AbsolutePosition.h b/src/crepe/util/AbsolutePosition.h new file mode 100644 index 0000000..0bc8748 --- /dev/null +++ b/src/crepe/util/AbsolutePosition.h @@ -0,0 +1,14 @@ +#pragma once + +#include "api/Transform.h" + +#include "types.h" + +namespace crepe { + +class AbsolutePosition { +public: + static vec2 get_position(const Transform & transform, const vec2 & offset); +}; + +} // namespace crepe diff --git a/src/crepe/util/AbsoluutPosition.cpp b/src/crepe/util/AbsoluutPosition.cpp deleted file mode 100644 index 296cc09..0000000 --- a/src/crepe/util/AbsoluutPosition.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "AbsoluutPosition.h" - -using namespace crepe; - -vec2 AbsoluutPosition::get_position(const Transform & transform, const vec2 & offset) { - // Get the rotation in radians - float radians1 = transform.rotation * (M_PI / 180.0); - - // Calculate total offset with scale - vec2 total_offset = offset * transform.scale; - - // Rotate - float rotated_total_offset_x1 - = total_offset.x * cos(radians1) - total_offset.y * sin(radians1); - float rotated_total_offset_y1 - = total_offset.x * sin(radians1) + total_offset.y * cos(radians1); - - // Final positions considering scaling and rotation - return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1)); -} diff --git a/src/crepe/util/AbsoluutPosition.h b/src/crepe/util/AbsoluutPosition.h deleted file mode 100644 index 30a7f93..0000000 --- a/src/crepe/util/AbsoluutPosition.h +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include "api/Transform.h" - -#include "types.h" - -namespace crepe { - -class AbsoluutPosition { -public: - static vec2 get_position(const Transform & transform, const vec2 & offset); -}; - -} // namespace crepe diff --git a/src/crepe/util/CMakeLists.txt b/src/crepe/util/CMakeLists.txt index b4b9221..33160a7 100644 --- a/src/crepe/util/CMakeLists.txt +++ b/src/crepe/util/CMakeLists.txt @@ -1,7 +1,7 @@ target_sources(crepe PUBLIC LogColor.cpp Log.cpp - AbsoluutPosition.cpp + AbsolutePosition.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -12,6 +12,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Proxy.hpp OptionalRef.h OptionalRef.hpp - AbsoluutPosition.h + AbsolutePosition.h ) diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index 11b4ca9..61254f1 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -1,27 +1,27 @@ target_sources(test_main PUBLIC main.cpp CollisionTest.cpp - PhysicsTest.cpp - ScriptTest.cpp - ParticleTest.cpp - AudioTest.cpp - AssetTest.cpp - ResourceManagerTest.cpp - OptionalRefTest.cpp - RenderSystemTest.cpp - EventTest.cpp - ECSTest.cpp - SceneManagerTest.cpp - ValueBrokerTest.cpp - DBTest.cpp - Vector2Test.cpp - LoopManagerTest.cpp - LoopTimerTest.cpp - InputTest.cpp - ScriptEventTest.cpp - ScriptSceneTest.cpp - Profiling.cpp - SaveManagerTest.cpp - ScriptSaveManagerTest.cpp - ScriptECSTest.cpp + # PhysicsTest.cpp + # ScriptTest.cpp + # ParticleTest.cpp + # AudioTest.cpp + # AssetTest.cpp + # ResourceManagerTest.cpp + # OptionalRefTest.cpp + # RenderSystemTest.cpp + # EventTest.cpp + # ECSTest.cpp + # SceneManagerTest.cpp + # ValueBrokerTest.cpp + # DBTest.cpp + # Vector2Test.cpp + # LoopManagerTest.cpp + # LoopTimerTest.cpp + # InputTest.cpp + # ScriptEventTest.cpp + # ScriptSceneTest.cpp + # Profiling.cpp + # SaveManagerTest.cpp + # ScriptSaveManagerTest.cpp + # ScriptECSTest.cpp ) diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp index 50e862d..a86f7d3 100644 --- a/src/test/CollisionTest.cpp +++ b/src/test/CollisionTest.cpp @@ -25,6 +25,7 @@ using namespace std::chrono_literals; using namespace crepe; using namespace testing; + class CollisionHandler : public Script { public: int box_id; @@ -112,11 +113,11 @@ TEST_F(CollisionTest, collision_example) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); }; EXPECT_FALSE(collision_happend); collision_sys.update(); @@ -127,14 +128,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 10); EXPECT_EQ(ev.info.resolution.y, 10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, -10); EXPECT_EQ(ev.info.resolution.y, -10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); @@ -150,7 +151,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, -5); EXPECT_EQ(ev.info.resolution.y, 0); EXPECT_EQ(ev.info.resolution_direction, @@ -158,7 +159,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, 5); EXPECT_EQ(ev.info.resolution.y, 0); EXPECT_EQ(ev.info.resolution_direction, @@ -175,7 +176,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 0); EXPECT_EQ(ev.info.resolution.y, -5); EXPECT_EQ(ev.info.resolution_direction, @@ -183,7 +184,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, 0); EXPECT_EQ(ev.info.resolution.y, 5); EXPECT_EQ(ev.info.resolution_direction, @@ -200,14 +201,14 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 10); EXPECT_EQ(ev.info.resolution.y, 10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, -10); EXPECT_EQ(ev.info.resolution.y, -10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); @@ -227,7 +228,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, -5); EXPECT_EQ(ev.info.resolution.y, 5); EXPECT_EQ(ev.info.resolution_direction, @@ -235,7 +236,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, 5); EXPECT_EQ(ev.info.resolution.y, -5); EXPECT_EQ(ev.info.resolution_direction, @@ -256,7 +257,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 5); EXPECT_EQ(ev.info.resolution.y, -5); EXPECT_EQ(ev.info.resolution_direction, @@ -264,7 +265,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) { }; script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 2); + EXPECT_EQ(ev.info.self.transform.game_object_id, 2); EXPECT_EQ(ev.info.resolution.x, -5); EXPECT_EQ(ev.info.resolution.y, 5); EXPECT_EQ(ev.info.resolution_direction, @@ -285,7 +286,7 @@ TEST_F(CollisionTest, collision_box_box_static_both) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 10); EXPECT_EQ(ev.info.resolution.y, 10); EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH); @@ -305,7 +306,7 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, -5); EXPECT_EQ(ev.info.resolution.y, 5); EXPECT_EQ(ev.info.resolution_direction, @@ -330,7 +331,7 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) { bool collision_happend = false; script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) { collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); + EXPECT_EQ(ev.info.self.transform.game_object_id, 1); EXPECT_EQ(ev.info.resolution.x, 5); EXPECT_EQ(ev.info.resolution.y, -5); EXPECT_EQ(ev.info.resolution_direction, @@ -350,37 +351,3 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) { collision_sys.update(); EXPECT_TRUE(collision_happend); } - -TEST_F(CollisionTest, collision_box_box_static_multiple) { //todo check visually - bool collision_happend = false; - float offset_value = 0; - float resolution = 0; - script_object1_ref->test_fn = [&](const CollisionEvent & ev) { - collision_happend = true; - EXPECT_EQ(ev.info.this_collider.game_object_id, 1); - EXPECT_EQ(ev.info.this_collider.offset.x, offset_value); - EXPECT_EQ(ev.info.resolution.x, resolution); - }; - script_object2_ref->test_fn = [&](const CollisionEvent & ev) { - // is static should not be called - //FAIL(); - }; - EXPECT_FALSE(collision_happend); - Transform & tf = this->mgr.get_components_by_id(1).front().get(); - tf.position = {45, 30}; - Rigidbody & rg1 = this->mgr.get_components_by_id(1).front().get(); - rg1.data.linear_velocity = {10, 10}; - Rigidbody & rg2 = this->mgr.get_components_by_id(2).front().get(); - rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC; - BoxCollider & bxc = this->mgr.get_components_by_id(1).front().get(); - bxc.offset = {5, 0}; - this->game_object1.add_component(vec2{-5, 0}, vec2{10, 10}); - offset_value = 5; - resolution = 10; - collision_sys.update(); - offset_value = -5; - resolution = 10; - tf.position = {55, 30}; - collision_sys.update(); - EXPECT_TRUE(collision_happend); -} diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp index 16736b8..0b2669f 100644 --- a/src/test/Profiling.cpp +++ b/src/test/Profiling.cpp @@ -32,7 +32,7 @@ using namespace testing; class TestScript : public Script { bool oncollision(const CollisionEvent & test) { - Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id); + Log::logf("Box {} script on_collision()", test.info.self.transform.game_object_id); return true; } void init() { -- cgit v1.2.3 From eb8c6c7a7202e560f896dcf25541b345109d8fa7 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 18 Dec 2024 22:11:49 +0100 Subject: before merging of resolution and handling --- src/crepe/system/CollisionSystem.cpp | 250 +++++++++++++++++++---------------- src/crepe/system/CollisionSystem.h | 45 +++---- 2 files changed, 155 insertions(+), 140 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 8bb8a91..e4f6cb3 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -107,6 +107,7 @@ CollisionSystem::gather_collisions(const std::vector & collid if (!should_collide(colliders[i], colliders[j])) continue; CollisionInternalType type = get_collider_type(colliders[i].collider, colliders[j].collider); if (!get_collision(colliders[i],colliders[j],type)) continue; + //fet collisions_ret.emplace_back(colliders[i], colliders[j]); } } @@ -156,41 +157,60 @@ CollisionSystem::get_collider_type(const collider_variant & collider1, } bool CollisionSystem::get_collision(const CollisionInternal & self,const CollisionInternal & other,const CollisionInternalType & type) const { - const Transform & self_transform = self.info.transform; - const Transform & other_transform = other.info.transform; - const Rigidbody & self_rigidbody = self.info.rigidbody; - const Rigidbody & other_rigidbody = other.info.rigidbody; - const collider_variant & self_collider = self.collider; - const collider_variant & other_collider = other.collider; switch (type) { case CollisionInternalType::BOX_BOX: { - const BoxCollider & box_collider1 = std::get>(self_collider); - const BoxCollider & box_collider2 = std::get>(other_collider); - return this->get_box_box_collision(box_collider1, box_collider2, - self_transform, other_transform, - self_rigidbody, other_rigidbody); + const BoxColliderInternal BOX1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const BoxColliderInternal BOX2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + + return this->get_box_box_collision(BOX1, BOX2); } case CollisionInternalType::BOX_CIRCLE: { - const BoxCollider & box_collider = std::get>(self_collider); - const CircleCollider & circle_collider = std::get>(other_collider); - return this->get_box_circle_collision(box_collider, circle_collider, - self_transform, other_transform, - self_rigidbody, other_rigidbody); + const BoxColliderInternal BOX1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const CircleColliderInternal CIRCLE2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + return this->get_box_circle_collision(BOX1, CIRCLE2); } case CollisionInternalType::CIRCLE_CIRCLE: { - const CircleCollider & circle_collider1 = std::get>(self_collider); - const CircleCollider & circle_collider2 = std::get>(other_collider); - return this->get_circle_circle_collision(circle_collider1, circle_collider2, - self_transform, other_transform, - self_rigidbody, other_rigidbody); + const CircleColliderInternal CIRCLE1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const CircleColliderInternal CIRCLE2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + return this->get_circle_circle_collision(CIRCLE1,CIRCLE2); } case CollisionInternalType::CIRCLE_BOX: { - const CircleCollider & circle_collider = std::get>(self_collider); - const BoxCollider & box_collider = std::get>(other_collider); - return this->get_box_circle_collision(box_collider, circle_collider, - other_transform, self_transform, - other_rigidbody, self_rigidbody); + const CircleColliderInternal CIRCLE1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const BoxColliderInternal BOX2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + return this->get_box_circle_collision(BOX2, CIRCLE1); } case CollisionInternalType::NONE: break; @@ -198,18 +218,14 @@ bool CollisionSystem::get_collision(const CollisionInternal & self,const Collisi return false; } -bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { +bool CollisionSystem::get_box_box_collision(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(transform1, box1.offset); - vec2 final_position2 = AbsolutePosition::get_position(transform2, box2.offset); + vec2 final_position1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); + vec2 final_position2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); // Scale dimensions - vec2 scaled_box1 = box1.dimensions * transform1.scale; - vec2 scaled_box2 = box2.dimensions * transform2.scale; + vec2 scaled_box1 = box1.collider.dimensions * box1.transform.scale; + vec2 scaled_box2 = box2.collider.dimensions * box2.transform.scale; // Calculate half-extents (half width and half height) float half_width1 = scaled_box1.x / 2.0; @@ -224,19 +240,14 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxC && final_position1.y - half_height1 < final_position2.y + half_height2); } -bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, - const CircleCollider & circle2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { +bool CollisionSystem::get_box_circle_collision(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const { // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(transform1, box1.offset); - vec2 final_position2 = AbsolutePosition::get_position(transform2, circle2.offset); + vec2 final_position1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); + vec2 final_position2 = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); // Scale dimensions - vec2 scaled_box = box1.dimensions * transform1.scale; - float scaled_circle = circle2.radius * transform2.scale; + vec2 scaled_box = box1.collider.dimensions * box1.transform.scale; + float scaled_circle = circle2.collider.radius * circle2.transform.scale; // Calculate box half-extents float half_width = scaled_box.x / 2.0; @@ -257,19 +268,14 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1, return distance_squared < scaled_circle * scaled_circle; } -bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1, - const CircleCollider & circle2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const { +bool CollisionSystem::get_circle_circle_collision(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(transform1, circle1.offset); - vec2 final_position2 = AbsolutePosition::get_position(transform2, circle2.offset); + vec2 final_position1 = AbsolutePosition::get_position(circle1.transform, circle1.collider.offset); + vec2 final_position2 = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); // Scale dimensions - float scaled_circle1 = circle1.radius * transform1.scale; - float scaled_circle2 = circle2.radius * transform2.scale; + float scaled_circle1 = circle1.collider.radius * circle1.transform.scale; + float scaled_circle2 = circle2.collider.radius * circle2.transform.scale; float distance_x = final_position1.x - final_position2.x; float distance_y = final_position1.y - final_position2.y; @@ -286,52 +292,69 @@ std::pair CollisionSystem::get_collision_resolution(const CollisionInternal & self, const CollisionInternal & other, const CollisionInternalType & type) const { vec2 resolution; + // Fet resolution form correct type switch (type) { case CollisionInternalType::BOX_BOX: { - const BoxCollider & collider1 = std::get>(self.collider); - const BoxCollider & collider2 = std::get>(other.collider); - vec2 collider_pos1 = AbsolutePosition::get_position(self.info.transform, collider1.offset); - vec2 collider_pos2 = AbsolutePosition::get_position(other.info.transform, collider2.offset); - resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1, collider_pos2); + + const BoxColliderInternal BOX1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const BoxColliderInternal BOX2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + resolution = this->get_box_box_resolution(BOX1, BOX2); break; } case CollisionInternalType::BOX_CIRCLE: { - const BoxCollider & collider1 - = std::get>(self.collider); - const CircleCollider & collider2 - = std::get>(other.collider); - vec2 collider_pos1 - = AbsolutePosition::get_position(self.info.transform, collider1.offset); - vec2 collider_pos2 - = AbsolutePosition::get_position(other.info.transform, collider2.offset); - resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2, - collider_pos1); + + const BoxColliderInternal BOX1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const CircleColliderInternal CIRCLE1 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + resolution = -this->get_circle_box_resolution(CIRCLE1,BOX1); break; } case CollisionInternalType::CIRCLE_CIRCLE: { - const CircleCollider & collider1 - = std::get>(self.collider); - const CircleCollider & collider2 - = std::get>(other.collider); - vec2 collider_pos1 - = AbsolutePosition::get_position(self.info.transform, collider1.offset); - vec2 collider_pos2 - = AbsolutePosition::get_position(other.info.transform, collider2.offset); - resolution = this->get_circle_circle_resolution(collider1, collider2, - collider_pos1, collider_pos2); + const CircleColliderInternal CIRCLE1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + const CircleColliderInternal CIRCLE2 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + + resolution = this->get_circle_circle_resolution(CIRCLE1, CIRCLE2); break; } case CollisionInternalType::CIRCLE_BOX: { - const CircleCollider & collider1 - = std::get>(self.collider); - const BoxCollider & collider2 - = std::get>(other.collider); - vec2 collider_pos1 - = AbsolutePosition::get_position(self.info.transform, collider1.offset); - vec2 collider_pos2 - = AbsolutePosition::get_position(other.info.transform, collider2.offset); - resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1, - collider_pos2); + + const BoxColliderInternal BOX1 = { + .collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody + }; + const CircleColliderInternal CIRCLE1 = { + .collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody + }; + resolution = -this->get_circle_box_resolution(CIRCLE1,BOX1); + + + resolution = this->get_circle_box_resolution(CIRCLE1, BOX1); break; } case CollisionInternalType::NONE: @@ -361,21 +384,20 @@ CollisionSystem::get_collision_resolution(const CollisionInternal & self, const return std::make_pair(resolution, resolution_direction); } -vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1, - const BoxCollider & box_collider2, - const vec2 & final_position1, - const vec2 & final_position2) const { +vec2 CollisionSystem::get_box_box_resolution(const BoxColliderInternal & self, const BoxColliderInternal & other) const { vec2 resolution; // Default resolution vector - vec2 delta = final_position2 - final_position1; + vec2 self_pos = AbsolutePosition::get_position(self.transform, self.collider.offset); + vec2 other_pos = AbsolutePosition::get_position(other.transform, other.collider.offset); + vec2 delta = other_pos - self_pos; - vec2 scaled_box1 = box_collider1.dimensions * transform1.scale; - vec2 scaled_box2 = box_collider2.dimensions * transform2.scale; + vec2 scaled_box1 = self.collider.dimensions * self.transform.scale; + vec2 scaled_box2 = other.collider.dimensions * other.transform.scale; // Compute half-dimensions of the boxes - float half_width1 = box_collider1.dimensions.x / 2.0; - float half_height1 = box_collider1.dimensions.y / 2.0; - float half_width2 = box_collider2.dimensions.x / 2.0; - float half_height2 = box_collider2.dimensions.y / 2.0; + float half_width1 = self.collider.dimensions.x / 2.0; + float half_height1 = self.collider.dimensions.y / 2.0; + float half_width2 = other.collider.dimensions.x / 2.0; + float half_height2 = other.collider.dimensions.y / 2.0; // Calculate overlaps along X and Y axes float overlap_x = (half_width1 + half_width2) - std::abs(delta.x); @@ -400,17 +422,16 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1, return resolution; } -vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle_collider1, - const CircleCollider & circle_collider2, - const vec2 & final_position1, - const vec2 & final_position2) const { - vec2 delta = final_position2 - final_position1; +vec2 CollisionSystem::get_circle_circle_resolution(const CircleColliderInternal & self, const CircleColliderInternal & other) const { + vec2 self_pos = AbsolutePosition::get_position(self.transform, self.collider.offset); + vec2 other_pos = AbsolutePosition::get_position(other.transform, other.collider.offset); + vec2 delta = other_pos - self_pos; // Compute the distance between the two circle centers float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y); // Compute the combined radii of the two circles - float combined_radius = circle_collider1.radius + circle_collider2.radius; + float combined_radius = self.collider.radius + other.collider.radius; // Compute the penetration depth float penetration_depth = combined_radius - distance; @@ -424,15 +445,14 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle return resolution; } -vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider, - const BoxCollider & box_collider, - const vec2 & circle_position, - const vec2 & box_position) const { - vec2 delta = circle_position - box_position; +vec2 CollisionSystem::get_circle_box_resolution(const CircleColliderInternal & circle, const BoxColliderInternal & box) const { + vec2 self_pos = AbsolutePosition::get_position(box.transform, box.collider.offset); + vec2 other_pos = AbsolutePosition::get_position(circle.transform, circle.collider.offset); + vec2 delta = other_pos - self_pos; // Compute half-dimensions of the box - float half_width = box_collider.dimensions.x / 2.0f; - float half_height = box_collider.dimensions.y / 2.0f; + float half_width = box.collider.dimensions.x / 2.0f; + float half_height = box.collider.dimensions.y / 2.0f; // Clamp circle center to the nearest point on the box vec2 closest_point; @@ -448,7 +468,7 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co vec2 collision_normal = closest_delta / distance; // Compute penetration depth - float penetration_depth = circle_collider.radius - distance; + float penetration_depth = circle.collider.radius - distance; // Compute the resolution vector vec2 resolution = collision_normal * penetration_depth; diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 01c189e..a695e61 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -82,6 +82,20 @@ private: game_object_id_t id = 0; collider_variant collider; ColliderInfo info; + vec2 resolution; + Direction resolution_direction = Direction::NONE; + }; + + struct BoxColliderInternal { + BoxCollider & collider; + Transform & transform; + Rigidbody & rigidbody; + }; + + struct CircleColliderInternal { + CircleCollider & collider; + Transform & transform; + Rigidbody & rigidbody; }; public: @@ -134,9 +148,7 @@ private: * \param position2 The position of the second BoxCollider. * \return The resolution vector for the collision. */ - vec2 get_box_box_resolution(const BoxCollider & box_collider1, - const BoxCollider & box_collider2, const vec2 & position1, - const vec2 & position2) const; + vec2 get_box_box_resolution(const BoxColliderInternal & self, const BoxColliderInternal & other) const; //done /** * \brief Calculates the resolution vector for two CircleCollider. @@ -149,10 +161,7 @@ private: * \param final_position2 The position of the second CircleCollider. * \return The resolution vector for the collision. */ - vec2 get_circle_circle_resolution(const CircleCollider & circle_collider1, - const CircleCollider & circle_collider2, - const vec2 & final_position1, - const vec2 & final_position2) const; + vec2 get_circle_circle_resolution(const CircleColliderInternal & self, const CircleColliderInternal & other) const; //done /** * \brief Calculates the resolution vector for two CircleCollider. @@ -165,10 +174,7 @@ private: * \param box_position The position of the BoxCollider. * \return The resolution vector for the collision. */ - vec2 get_circle_box_resolution(const CircleCollider & circle_collider, - const BoxCollider & box_collider, - const vec2 & circle_position, - const vec2 & box_position) const; + vec2 get_circle_box_resolution(const CircleColliderInternal & circle, const BoxColliderInternal & box) const; //done /** * \brief Determines the appropriate collision handler for a collision. @@ -256,10 +262,7 @@ private: * \param rigidbody2 Rigidbody of the second object. * \return True if a collision is detected, otherwise false. */ - bool get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2, - const Transform & transform1, const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const; + bool get_box_box_collision(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; /** * \brief Check collision for box on circle collider @@ -272,10 +275,7 @@ private: * \param rigidbody2 Rigidbody of the second object. * \return True if a collision is detected, otherwise false. */ - bool get_box_circle_collision(const BoxCollider & box1, const CircleCollider & circle2, - const Transform & transform1, const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const; + bool get_box_circle_collision(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; /** * \brief Check collision for circle on circle collider @@ -290,12 +290,7 @@ private: * * \return status of collision */ - bool get_circle_circle_collision(const CircleCollider & circle1, - const CircleCollider & circle2, - const Transform & transform1, - const Transform & transform2, - const Rigidbody & rigidbody1, - const Rigidbody & rigidbody2) const; + bool get_circle_circle_collision(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const; }; /** -- cgit v1.2.3 From 982e12df210b8eb3daa66ebe6a71dd9e92276cec Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 18 Dec 2024 23:37:30 +0100 Subject: merged detection and resolution functions --- src/crepe/system/CollisionSystem.cpp | 337 +++++++++++++---------------------- src/crepe/system/CollisionSystem.h | 61 +------ src/example/game.cpp | 12 +- 3 files changed, 135 insertions(+), 275 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index e4f6cb3..a9a0523 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -75,11 +75,11 @@ void CollisionSystem::update() { // For both objects call the collision handler for (auto & collision_pair : collided) { // Determine type - CollisionInternalType type = this->get_collider_type(collision_pair.first.collider, collision_pair.second.collider); + //CollisionInternalType type = this->get_collider_type(collision_pair.first.collider, collision_pair.second.collider); // Determine resolution - std::pair resolution_data = this->get_collision_resolution(collision_pair.first, collision_pair.second, type); + //std::pair resolution_data = this->get_collision_resolution(collision_pair.first, collision_pair.second, type); // Convert internal struct to external struct - CollisionInfo info = this->get_collision_info(collision_pair.first, collision_pair.second,type,resolution_data.first,resolution_data.second); + CollisionInfo info = this->get_collision_info(collision_pair.first, collision_pair.second); // Determine if and/or what collison handler is needed. this->determine_collision_handler(info); } @@ -87,7 +87,7 @@ void CollisionSystem::update() { // Below is for collision detection std::vector> -CollisionSystem::gather_collisions(const std::vector & colliders) const { +CollisionSystem::gather_collisions(std::vector & colliders) { // TODO: // If no colliders skip @@ -106,7 +106,7 @@ CollisionSystem::gather_collisions(const std::vector & collid if (colliders[i].id == colliders[j].id) continue; if (!should_collide(colliders[i], colliders[j])) continue; CollisionInternalType type = get_collider_type(colliders[i].collider, colliders[j].collider); - if (!get_collision(colliders[i],colliders[j],type)) continue; + if (!detect_collision(colliders[i],colliders[j],type)) continue; //fet collisions_ret.emplace_back(colliders[i], colliders[j]); } @@ -156,8 +156,8 @@ CollisionSystem::get_collider_type(const collider_variant & collider1, } } -bool CollisionSystem::get_collision(const CollisionInternal & self,const CollisionInternal & other,const CollisionInternalType & type) const { - +bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInternal & other,const CollisionInternalType & type) { + vec2 resolution; switch (type) { case CollisionInternalType::BOX_BOX: { const BoxColliderInternal BOX1 = { @@ -170,8 +170,10 @@ bool CollisionSystem::get_collision(const CollisionInternal & self,const Collisi .transform = other.info.transform, .rigidbody = other.info.rigidbody }; - - return this->get_box_box_collision(BOX1, BOX2); + resolution = this->get_box_box_detection(BOX1, BOX2); + if(resolution == vec2{-1,-1}) return false; + break; + } case CollisionInternalType::BOX_CIRCLE: { const BoxColliderInternal BOX1 = { @@ -184,7 +186,9 @@ bool CollisionSystem::get_collision(const CollisionInternal & self,const Collisi .transform = other.info.transform, .rigidbody = other.info.rigidbody }; - return this->get_box_circle_collision(BOX1, CIRCLE2); + resolution = this->get_box_circle_detection(BOX1, CIRCLE2); + if(resolution == vec2{-1,-1}) return false; + break; } case CollisionInternalType::CIRCLE_CIRCLE: { const CircleColliderInternal CIRCLE1 = { @@ -197,7 +201,9 @@ bool CollisionSystem::get_collision(const CollisionInternal & self,const Collisi .transform = other.info.transform, .rigidbody = other.info.rigidbody }; - return this->get_circle_circle_collision(CIRCLE1,CIRCLE2); + resolution = this->get_circle_circle_detection(CIRCLE1,CIRCLE2); + if(resolution == vec2{-1,-1}) return false; + break; } case CollisionInternalType::CIRCLE_BOX: { const CircleColliderInternal CIRCLE1 = { @@ -210,22 +216,31 @@ bool CollisionSystem::get_collision(const CollisionInternal & self,const Collisi .transform = other.info.transform, .rigidbody = other.info.rigidbody }; - return this->get_box_circle_collision(BOX2, CIRCLE1); + resolution = this->get_box_circle_detection(BOX2, CIRCLE1); + if(resolution == vec2{-1,-1}) return false; + break; } case CollisionInternalType::NONE: break; } - return false; + self.resolution = resolution; + self.resolution_direction = this->resolution_correction(self.resolution, self.info.rigidbody.data); + other.resolution = -self.resolution; + other.resolution_direction = self.resolution_direction; + return true; } -bool CollisionSystem::get_box_box_collision(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { +vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { + vec2 resolution; // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); - vec2 final_position2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); + vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); + vec2 pos2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); // Scale dimensions vec2 scaled_box1 = box1.collider.dimensions * box1.transform.scale; vec2 scaled_box2 = box2.collider.dimensions * box2.transform.scale; + vec2 delta = pos2 - pos1; + // Calculate half-extents (half width and half height) float half_width1 = scaled_box1.x / 2.0; @@ -233,42 +248,77 @@ bool CollisionSystem::get_box_box_collision(const BoxColliderInternal & box1, co float half_width2 = scaled_box2.x / 2.0; float half_height2 = scaled_box2.y / 2.0; - // Check if the boxes overlap along the X and Y axes - return (final_position1.x + half_width1 > final_position2.x - half_width2 - && final_position1.x - half_width1 < final_position2.x + half_width2 - && final_position1.y + half_height1 > final_position2.y - half_height2 - && final_position1.y - half_height1 < final_position2.y + half_height2); + if (pos1.x + half_width1 > pos2.x - half_width2 + && pos1.x - half_width1 < pos2.x + half_width2 + && pos1.y + half_height1 > pos2.y - half_height2 + && pos1.y - half_height1 < pos2.y + half_height2) + { + float overlap_x = (half_width1 + half_width2) - std::abs(delta.x); + float overlap_y = (half_height1 + half_height2) - std::abs(delta.y); + if (overlap_x > 0 && overlap_y > 0) { + // Determine the direction of resolution + if (overlap_x < overlap_y) { + // Resolve along the X-axis (smallest overlap) + resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; + } else if (overlap_y < overlap_x) { + // Resolve along the Y-axis (smallest overlap) + resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; + } else { + // Equal overlap, resolve both directions with preference + resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; + resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; + } + } + return resolution; + } + return vec2{-1,-1}; } -bool CollisionSystem::get_box_circle_collision(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const { - // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); - vec2 final_position2 = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); - - // Scale dimensions - vec2 scaled_box = box1.collider.dimensions * box1.transform.scale; - float scaled_circle = circle2.collider.radius * circle2.transform.scale; - - // Calculate box half-extents - float half_width = scaled_box.x / 2.0; - float half_height = scaled_box.y / 2.0; - - // Find the closest point on the box to the circle's center - float closest_x = std::max(final_position1.x - half_width, - std::min(final_position2.x, final_position1.x + half_width)); - float closest_y = std::max(final_position1.y - half_height, - std::min(final_position2.y, final_position1.y + half_height)); - - // Calculate the distance squared between the circle's center and the closest point on the box - float distance_x = final_position2.x - closest_x; - float distance_y = final_position2.y - closest_y; - float distance_squared = distance_x * distance_x + distance_y * distance_y; - - // Compare distance squared with the square of the circle's radius - return distance_squared < scaled_circle * scaled_circle; +vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, const CircleColliderInternal & circle) const { + /// Get current positions of colliders + vec2 box_pos = AbsolutePosition::get_position(box.transform, box.collider.offset); + vec2 circle_pos = AbsolutePosition::get_position(circle.transform, circle.collider.offset); + + // Scale dimensions + vec2 scaled_box = box.collider.dimensions * box.transform.scale; + float scaled_circle_radius = circle.collider.radius * circle.transform.scale; + + // Calculate box half-extents + float half_width = scaled_box.x / 2.0f; + float half_height = scaled_box.y / 2.0f; + + // Find the closest point on the box to the circle's center + float closest_x = std::max(box_pos.x - half_width, std::min(circle_pos.x, box_pos.x + half_width)); + float closest_y = std::max(box_pos.y - half_height, std::min(circle_pos.y, box_pos.y + half_height)); + + float distance_x = circle_pos.x - closest_x; + float distance_y = circle_pos.y - closest_y; + float distance_squared = distance_x * distance_x + distance_y * distance_y; + if(distance_squared < scaled_circle_radius * scaled_circle_radius){ + vec2 delta = circle_pos - box_pos; + + // Clamp circle center to the nearest point on the box + vec2 closest_point; + closest_point.x = std::clamp(delta.x, -half_width, half_width); + closest_point.y = std::clamp(delta.y, -half_height, half_height); + + // Find the vector from the circle center to the closest point + vec2 closest_delta = delta - closest_point; + + float distance = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y); + vec2 collision_normal = closest_delta / distance; + + // Compute penetration depth + float penetration_depth = scaled_circle_radius - distance; + + // Compute the resolution vector + return vec2{collision_normal * penetration_depth}; + } + // No collision + return vec2{-1,-1}; } -bool CollisionSystem::get_circle_circle_collision(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { +vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { // Get current positions of colliders vec2 final_position1 = AbsolutePosition::get_position(circle1.transform, circle1.collider.offset); vec2 final_position2 = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); @@ -284,86 +334,35 @@ bool CollisionSystem::get_circle_circle_collision(const CircleColliderInternal & // Calculate the sum of the radii float radius_sum = scaled_circle1 + scaled_circle2; - // Check if the distance between the centers is less than or equal to the sum of the radii - return distance_squared < radius_sum * radius_sum; -} + // Check for collision (distance squared must be less than the square of the radius sum) + if (distance_squared < radius_sum * radius_sum) { + vec2 delta = final_position2 - final_position1; -std::pair -CollisionSystem::get_collision_resolution(const CollisionInternal & self, const CollisionInternal & other, - const CollisionInternalType & type) const { - vec2 resolution; - // Fet resolution form correct type - switch (type) { - case CollisionInternalType::BOX_BOX: { + // Compute the distance between the two circle centers + float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y); - const BoxColliderInternal BOX1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - const BoxColliderInternal BOX2 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; - resolution = this->get_box_box_resolution(BOX1, BOX2); - break; - } - case CollisionInternalType::BOX_CIRCLE: { + // Compute the combined radii of the two circles + float combined_radius = scaled_circle1 + scaled_circle2; - const BoxColliderInternal BOX1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - const CircleColliderInternal CIRCLE1 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; - resolution = -this->get_circle_box_resolution(CIRCLE1,BOX1); - break; - } - case CollisionInternalType::CIRCLE_CIRCLE: { - const CircleColliderInternal CIRCLE1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - const CircleColliderInternal CIRCLE2 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; - - resolution = this->get_circle_circle_resolution(CIRCLE1, CIRCLE2); - break; - } - case CollisionInternalType::CIRCLE_BOX: { + // Compute the penetration depth + float penetration_depth = combined_radius - distance; - const BoxColliderInternal BOX1 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; - const CircleColliderInternal CIRCLE1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - resolution = -this->get_circle_box_resolution(CIRCLE1,BOX1); + // Normalize the delta vector to get the collision direction + vec2 collision_normal = delta / distance; - - resolution = this->get_circle_box_resolution(CIRCLE1, BOX1); - break; - } - case CollisionInternalType::NONE: - break; + // Compute the resolution vector + vec2 resolution = -collision_normal * penetration_depth; + + return resolution; } + // No collision + return vec2{-1,-1}; +} + +CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody) { // Calculate the other value to move back correctly // If only X or Y has a value determine what is should be to move back. - const Rigidbody::Data & rigidbody = self.info.rigidbody.data; Direction resolution_direction = Direction::NONE; // If both are not zero a perfect corner has been hit if (resolution.x != 0 && resolution.y != 0) { @@ -381,102 +380,10 @@ CollisionSystem::get_collision_resolution(const CollisionInternal & self, const resolution.x = -rigidbody.linear_velocity.x * (resolution.y / rigidbody.linear_velocity.y); } - return std::make_pair(resolution, resolution_direction); -} - -vec2 CollisionSystem::get_box_box_resolution(const BoxColliderInternal & self, const BoxColliderInternal & other) const { - vec2 resolution; // Default resolution vector - vec2 self_pos = AbsolutePosition::get_position(self.transform, self.collider.offset); - vec2 other_pos = AbsolutePosition::get_position(other.transform, other.collider.offset); - vec2 delta = other_pos - self_pos; - - vec2 scaled_box1 = self.collider.dimensions * self.transform.scale; - vec2 scaled_box2 = other.collider.dimensions * other.transform.scale; - - // Compute half-dimensions of the boxes - float half_width1 = self.collider.dimensions.x / 2.0; - float half_height1 = self.collider.dimensions.y / 2.0; - float half_width2 = other.collider.dimensions.x / 2.0; - float half_height2 = other.collider.dimensions.y / 2.0; - - // Calculate overlaps along X and Y axes - float overlap_x = (half_width1 + half_width2) - std::abs(delta.x); - float overlap_y = (half_height1 + half_height2) - std::abs(delta.y); - - // Check if there is a collision should always be true - if (overlap_x > 0 && overlap_y > 0) { - // Determine the direction of resolution - if (overlap_x < overlap_y) { - // Resolve along the X-axis (smallest overlap) - resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; - } else if (overlap_y < overlap_x) { - // Resolve along the Y-axis (smallest overlap) - resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; - } else { - // Equal overlap, resolve both directions with preference - resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; - resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; - } - } - - return resolution; -} - -vec2 CollisionSystem::get_circle_circle_resolution(const CircleColliderInternal & self, const CircleColliderInternal & other) const { - vec2 self_pos = AbsolutePosition::get_position(self.transform, self.collider.offset); - vec2 other_pos = AbsolutePosition::get_position(other.transform, other.collider.offset); - vec2 delta = other_pos - self_pos; - - // Compute the distance between the two circle centers - float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y); - - // Compute the combined radii of the two circles - float combined_radius = self.collider.radius + other.collider.radius; - - // Compute the penetration depth - float penetration_depth = combined_radius - distance; - - // Normalize the delta vector to get the collision direction - vec2 collision_normal = delta / distance; - - // Compute the resolution vector - vec2 resolution = -collision_normal * penetration_depth; - - return resolution; -} - -vec2 CollisionSystem::get_circle_box_resolution(const CircleColliderInternal & circle, const BoxColliderInternal & box) const { - vec2 self_pos = AbsolutePosition::get_position(box.transform, box.collider.offset); - vec2 other_pos = AbsolutePosition::get_position(circle.transform, circle.collider.offset); - vec2 delta = other_pos - self_pos; - - // Compute half-dimensions of the box - float half_width = box.collider.dimensions.x / 2.0f; - float half_height = box.collider.dimensions.y / 2.0f; - - // Clamp circle center to the nearest point on the box - vec2 closest_point; - closest_point.x = std::clamp(delta.x, -half_width, half_width); - closest_point.y = std::clamp(delta.y, -half_height, half_height); - - // Find the vector from the circle center to the closest point - vec2 closest_delta = delta - closest_point; - - // Normalize the delta to get the collision direction - float distance - = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y); - vec2 collision_normal = closest_delta / distance; - - // Compute penetration depth - float penetration_depth = circle.collider.radius - distance; - - // Compute the resolution vector - vec2 resolution = collision_normal * penetration_depth; - - return resolution; + return resolution_direction; } -CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const CollisionInternal & in_self, const CollisionInternal & in_other,const CollisionInternalType & type,const vec2 & resolution,const CollisionSystem::Direction & resolution_direction) const{ +CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const CollisionInternal & in_self, const CollisionInternal & in_other) const{ ComponentManager & mgr = this->mediator.component_manager; @@ -495,8 +402,8 @@ CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const Collisi struct CollisionInfo collision_info{ .self = self, .other = other, - .resolution = resolution, - .resolution_direction = resolution_direction, + .resolution = in_self.resolution, + .resolution_direction = in_self.resolution_direction, }; return collision_info; } diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index a695e61..7792e50 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -123,58 +123,11 @@ private: * \param data1 Collision data for the first collider. * \param data2 Collision data for the second collider. */ - CollisionInfo get_collision_info(const CollisionInternal & this_data, const CollisionInternal & other_data,const CollisionInternalType & type,const vec2 & resolution,const CollisionSystem::Direction & resolution_direction) const; //done + CollisionInfo get_collision_info(const CollisionInternal & this_data, const CollisionInternal & other_data) const; //done - /** - * \brief Resolves collision between two colliders and calculates the movement required. - * - * Determines the displacement and direction needed to separate colliders based on their types. - * - * \param data1 Collision data for the first collider. - * \param data2 Collision data for the second collider. - * \param type The type of collider pair. - * \return A pair containing the resolution vector and direction for the first collider. - */ - std::pair get_collision_resolution(const CollisionInternal & data1,const CollisionInternal & data2, const CollisionInternalType & type) const; //done - - /** - * \brief Calculates the resolution vector for two BoxColliders. - * - * Computes the displacement required to separate two overlapping BoxColliders. - * - * \param box_collider1 The first BoxCollider. - * \param box_collider2 The second BoxCollider. - * \param position1 The position of the first BoxCollider. - * \param position2 The position of the second BoxCollider. - * \return The resolution vector for the collision. - */ - vec2 get_box_box_resolution(const BoxColliderInternal & self, const BoxColliderInternal & other) const; //done - /** - * \brief Calculates the resolution vector for two CircleCollider. - * - * Computes the displacement required to separate two overlapping CircleCollider. - * - * \param circle_collider1 The first CircleCollider. - * \param circle_collider2 The second CircleCollider. - * \param final_position1 The position of the first CircleCollider. - * \param final_position2 The position of the second CircleCollider. - * \return The resolution vector for the collision. - */ - vec2 get_circle_circle_resolution(const CircleColliderInternal & self, const CircleColliderInternal & other) const; //done + Direction resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody); - /** - * \brief Calculates the resolution vector for two CircleCollider. - * - * Computes the displacement required to separate two overlapping CircleCollider. - * - * \param circle_collider The first CircleCollider. - * \param box_collider The second CircleCollider. - * \param circle_position The position of the CircleCollider. - * \param box_position The position of the BoxCollider. - * \return The resolution vector for the collision. - */ - vec2 get_circle_box_resolution(const CircleColliderInternal & circle, const BoxColliderInternal & box) const; //done /** * \brief Determines the appropriate collision handler for a collision. @@ -222,7 +175,7 @@ private: * \return A list of collision pairs with their associated data. */ std::vector> - gather_collisions(const std::vector & colliders) const; //done + gather_collisions(std::vector & colliders); //done /** * \brief Checks if the settings allow collision @@ -249,7 +202,7 @@ private: * \param type The type of collider pair. * \return True if a collision is detected, otherwise false. */ - bool get_collision(const CollisionInternal & first_info, const CollisionInternal & second_info, const CollisionInternalType & type) const; + bool detect_collision(CollisionInternal & first_info, CollisionInternal & second_info, const CollisionInternalType & type); /** * \brief Detects collisions between two BoxColliders. @@ -262,7 +215,7 @@ private: * \param rigidbody2 Rigidbody of the second object. * \return True if a collision is detected, otherwise false. */ - bool get_box_box_collision(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; + vec2 get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; /** * \brief Check collision for box on circle collider @@ -275,7 +228,7 @@ private: * \param rigidbody2 Rigidbody of the second object. * \return True if a collision is detected, otherwise false. */ - bool get_box_circle_collision(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; + vec2 get_box_circle_detection(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; /** * \brief Check collision for circle on circle collider @@ -290,7 +243,7 @@ private: * * \return status of collision */ - bool get_circle_circle_collision(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const; + vec2 get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const; }; /** diff --git a/src/example/game.cpp b/src/example/game.cpp index a8b3d5d..69bfae2 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -24,7 +24,7 @@ using namespace std; class MyScript1 : public Script { bool flip = false; bool oncollision(const CollisionEvent & test) { - Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id); + Log::logf("Box {} script on_collision()", test.info.self.metadata.game_object_id); return true; } bool keypressed(const KeyPressEvent & test) { @@ -93,7 +93,7 @@ class MyScript1 : public Script { class MyScript2 : public Script { bool flip = false; bool oncollision(const CollisionEvent & test) { - Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id); + Log::logf("Box {} script on_collision()", test.info.self.metadata.game_object_id); return true; } bool keypressed(const KeyPressEvent & test) { @@ -195,7 +195,7 @@ public: GameObject world = new_object( "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); world.add_component(Rigidbody::Data{ - .mass = 0, + .mass = 1, .gravity_scale = 0, .body_type = Rigidbody::BodyType::STATIC, }); @@ -220,11 +220,11 @@ public: }); GameObject game_object1 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 45, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+30}, 0, 1); game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::KINEMATIC, + .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 1}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, @@ -238,7 +238,7 @@ public: .sorting_in_layer = 2, .order_in_layer = 2, .size = {20, 20}, - .position_offset = {0, -10}, + .position_offset = {0, 0}, }); //add circle with cirlcecollider deactiveated -- cgit v1.2.3 From be36b204c6dc597f74541e926f2f2821ab553228 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 18 Dec 2024 23:54:29 +0100 Subject: testing dynamic --- src/crepe/system/CollisionSystem.cpp | 6 +----- src/example/game.cpp | 8 ++++---- 2 files changed, 5 insertions(+), 9 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index a9a0523..75e914d 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -72,12 +72,8 @@ void CollisionSystem::update() { std::vector> collided = this->gather_collisions(all_colliders); - // For both objects call the collision handler + // For the object convert the info and call the collision handler if needed for (auto & collision_pair : collided) { - // Determine type - //CollisionInternalType type = this->get_collider_type(collision_pair.first.collider, collision_pair.second.collider); - // Determine resolution - //std::pair resolution_data = this->get_collision_resolution(collision_pair.first, collision_pair.second, type); // Convert internal struct to external struct CollisionInfo info = this->get_collision_info(collision_pair.first, collision_pair.second); // Determine if and/or what collison handler is needed. diff --git a/src/example/game.cpp b/src/example/game.cpp index 69bfae2..01e55d5 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -206,7 +206,7 @@ public: vec2{world_collider, world_collider}, vec2{0, screen_size_height / 2 + world_collider / 2}); // Bottom world.add_component( - vec2{world_collider, world_collider}, + vec2{world_collider, world_collider},git stauts vec2{0 - (screen_size_width / 2 + world_collider / 2), 0}); // Left world.add_component( vec2{world_collider, world_collider}, @@ -220,12 +220,12 @@ public: }); GameObject game_object1 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+30}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+60}, 0, 1); game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, .body_type = Rigidbody::BodyType::DYNAMIC, - .linear_velocity = {0, 1}, + .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, }); @@ -257,7 +257,7 @@ public: game_object2.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 1, - .body_type = Rigidbody::BodyType::KINEMATIC, + .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, -- cgit v1.2.3 From 5a087d8a01d00a737ae602370c2c3514294da88d Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 08:11:27 +0100 Subject: rotating sprite on particle --- src/crepe/system/RenderSystem.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/crepe') diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index d76a122..1091c3f 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -98,7 +98,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const double & scale) .sprite = sprite, .texture = res, .pos = p.position, - .angle = p.angle, + .angle = p.angle+sprite.data.angle_offset, .scale = scale, }); } -- cgit v1.2.3 From 714edd69d53a6243e9a2b81f62d309c96b71dd8d Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 08:36:17 +0100 Subject: bug fix and doxygen fix --- src/crepe/system/CollisionSystem.cpp | 4 +-- src/crepe/system/CollisionSystem.h | 66 +++++++++++++++++++----------------- src/example/game.cpp | 4 +-- 3 files changed, 38 insertions(+), 36 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 75e914d..719713c 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -407,9 +407,9 @@ CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const Collisi // Below is for collision handling void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { Rigidbody::BodyType self_type = info.self.rigidbody.data.body_type; - Rigidbody::BodyType other_type = info.self.rigidbody.data.body_type; + Rigidbody::BodyType other_type = info.other.rigidbody.data.body_type; bool self_kinematic = info.self.rigidbody.data.kinematic_collision; - bool other_kinematic = info.self.rigidbody.data.kinematic_collision; + bool other_kinematic = info.other.rigidbody.data.kinematic_collision; // Inverted collision info CollisionInfo inverted = -info; // If both objects are static skip handle call collision script diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 7792e50..13ce8f0 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -34,18 +34,19 @@ private: BOTH }; public: - /** - * \brief Structure representing detailed collision information between two colliders. - * - * Includes information about the colliding objects and the resolution data for handling the collision. - */ - + + //! Structure representing components of the collider struct ColliderInfo { Transform & transform; Rigidbody & rigidbody; Metadata & metadata; }; + /** + * \brief Structure representing detailed collision information between two colliders. + * + * Includes information about the colliding objects and the resolution data for handling the collision. + */ struct CollisionInfo { ColliderInfo self; ColliderInfo other; @@ -86,12 +87,14 @@ private: Direction resolution_direction = Direction::NONE; }; + //! Structure of collider with addtitional components struct BoxColliderInternal { BoxCollider & collider; Transform & transform; Rigidbody & rigidbody; }; + //! Structure of collider with addtitional components struct CircleColliderInternal { CircleCollider & collider; Transform & transform; @@ -123,9 +126,19 @@ private: * \param data1 Collision data for the first collider. * \param data2 Collision data for the second collider. */ - CollisionInfo get_collision_info(const CollisionInternal & this_data, const CollisionInternal & other_data) const; //done + CollisionInfo get_collision_info(const CollisionInternal & data1, const CollisionInternal & data2) const; + /** + * \brief Corrects the resolution of the collision + * + * This function corrects the resolution by fixing the x or y if it is empty. + * Besides this with the input of the resolution the direction is saved before correction. + * + * \param resolution resolution vector that needs to be corrected + * \param rigidbody rigidbody data used to correct resolution + * \return Direction of resolution + */ Direction resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody); @@ -136,7 +149,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void determine_collision_handler(const CollisionInfo & info); //done + void determine_collision_handler(const CollisionInfo & info); /** * \brief Calls both collision script @@ -144,6 +157,7 @@ private: * Calls both collision script to let user add additonal handeling or handle full collision. * * \param info Collision information containing data about both colliders. + * \param info_inverted Collision information containing data about both colliders in opposite order. */ void call_collision_events(const CollisionInfo & info, const CollisionInfo & info_inverted); @@ -154,7 +168,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void static_collision_handler(const CollisionInfo & info); //done + void static_collision_handler(const CollisionInfo & info); /** * \brief Handles collisions involving dynamic objects. @@ -163,7 +177,7 @@ private: * * \param info Collision information containing data about both colliders. */ - void dynamic_collision_handler(const CollisionInfo & info); //done + void dynamic_collision_handler(const CollisionInfo & info); private: /** @@ -175,7 +189,7 @@ private: * \return A list of collision pairs with their associated data. */ std::vector> - gather_collisions(std::vector & colliders); //done + gather_collisions(std::vector & colliders); /** * \brief Checks if the settings allow collision @@ -207,39 +221,27 @@ private: /** * \brief Detects collisions between two BoxColliders. * - * \param box1 The first BoxCollider. - * \param box2 The second BoxCollider. - * \param transform1 Transform of the first object. - * \param transform2 Transform of the second object. - * \param rigidbody1 Rigidbody of the first object. - * \param rigidbody2 Rigidbody of the second object. - * \return True if a collision is detected, otherwise false. + * \param box1 Information about the first BoxCollider. + * \param box2 Information about the second BoxCollider. + * \return returns resolution vector if collide otherwise returns {-1,-1} */ vec2 get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; /** * \brief Check collision for box on circle collider * - * \param box1 The BoxCollider - * \param circle2 The CircleCollider - * \param transform1 Transform of the first object. - * \param transform2 Transform of the second object. - * \param rigidbody1 Rigidbody of the first object. - * \param rigidbody2 Rigidbody of the second object. - * \return True if a collision is detected, otherwise false. + * \param box1 Information about the BoxCollider. + * \param circle2 Information about the circleCollider. + * \return returns resolution vector if collide otherwise returns {-1,-1} */ vec2 get_box_circle_detection(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; /** * \brief Check collision for circle on circle collider * - * \param circle1 First CircleCollider - * \param circle2 Second CircleCollider - * \param transform1 Transform of the first object. - * \param transform2 Transform of the second object. - * \param rigidbody1 Rigidbody of the first object. - * \param rigidbody2 Rigidbody of the second object. - * \return True if a collision is detected, otherwise false. + * \param circle1 Information about the first circleCollider. + * \param circle2 Information about the second circleCollider. + * \return returns resolution vector if collide otherwise returns {-1,-1} * * \return status of collision */ diff --git a/src/example/game.cpp b/src/example/game.cpp index 01e55d5..f931878 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -206,7 +206,7 @@ public: vec2{world_collider, world_collider}, vec2{0, screen_size_height / 2 + world_collider / 2}); // Bottom world.add_component( - vec2{world_collider, world_collider},git stauts + vec2{world_collider, world_collider}, vec2{0 - (screen_size_width / 2 + world_collider / 2), 0}); // Left world.add_component( vec2{world_collider, world_collider}, @@ -256,7 +256,7 @@ public: "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); game_object2.add_component(Rigidbody::Data{ .mass = 1, - .gravity_scale = 1, + .gravity_scale = 0, .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, -- cgit v1.2.3 From d355d374f9e3182750b2cfce1036d0cc011d60dd Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 10:47:36 +0100 Subject: fixed bug --- src/crepe/system/CollisionSystem.cpp | 1 + src/example/game.cpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 719713c..6ed640a 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -184,6 +184,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna }; resolution = this->get_box_circle_detection(BOX1, CIRCLE2); if(resolution == vec2{-1,-1}) return false; + resolution = -resolution; break; } case CollisionInternalType::CIRCLE_CIRCLE: { diff --git a/src/example/game.cpp b/src/example/game.cpp index f931878..ce2f351 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -224,7 +224,7 @@ public: game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::DYNAMIC, + .body_type = Rigidbody::BodyType::KINEMATIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, -- cgit v1.2.3 From fe396c458b38ee209dd4c1f3ba4d053bef20f57a Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 12:55:04 +0100 Subject: tested system, added roation to emitter --- src/crepe/system/ParticleSystem.cpp | 2 +- src/crepe/system/RenderSystem.cpp | 2 +- src/example/CMakeLists.txt | 1 + src/example/collisiontest.cpp | 168 ++++++++++++++++++++++++++++++++++++ src/example/game.cpp | 19 ++-- 5 files changed, 183 insertions(+), 9 deletions(-) create mode 100644 src/example/collisiontest.cpp (limited to 'src/crepe') diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 3183fd7..31c1800 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -51,7 +51,7 @@ void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & vec2 initial_position = AbsolutePosition::get_position(transform, emitter.data.offset); float random_angle - = this->generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); + = this->generate_random_angle(emitter.data.min_angle+transform.rotation, emitter.data.max_angle+transform.rotation); float random_speed = this->generate_random_speed(emitter.data.min_speed, emitter.data.max_speed); diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 1091c3f..d76a122 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -98,7 +98,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const double & scale) .sprite = sprite, .texture = res, .pos = p.position, - .angle = p.angle+sprite.data.angle_offset, + .angle = p.angle, .scale = scale, }); } diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt index f62414e..2ee3051 100644 --- a/src/example/CMakeLists.txt +++ b/src/example/CMakeLists.txt @@ -22,3 +22,4 @@ add_example(button) add_example(loadfont) add_example(FontExample) add_example(AITest) +add_example(collisiontest) diff --git a/src/example/collisiontest.cpp b/src/example/collisiontest.cpp new file mode 100644 index 0000000..95999c6 --- /dev/null +++ b/src/example/collisiontest.cpp @@ -0,0 +1,168 @@ +#include "api/CircleCollider.h" +#include "api/ParticleEmitter.h" +#include "api/Scene.h" +#include "manager/ComponentManager.h" +#include "manager/Mediator.h" +#include "types.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace crepe; + +using namespace std; + +class MyScript1 : public Script { + bool flip = false; + bool movement = false; + bool oncollision(const CollisionEvent & test) { + Log::logf("Box {} script on_collision()", test.info.self.metadata.game_object_id); + return true; + } + bool keypressed(const KeyPressEvent & test) { + Log::logf("Box script keypressed()"); + switch (test.key) { + case Keycode::A: { + Rigidbody & tf = this->get_component(); + Transform & tr = this->get_component(); + if(movement) tf.data.linear_velocity.x -= 1; + else tr.position.x -= 1; + break; + } + case Keycode::W: { + Rigidbody & tf = this->get_component(); + Transform & tr = this->get_component(); + if(movement) tf.data.linear_velocity.y -= 1; + else tr.position.y -= 1; + break; + } + case Keycode::S: { + Rigidbody & tf = this->get_component(); + Transform & tr = this->get_component(); + if(movement) tf.data.linear_velocity.y += 1; + else tr.position.y += 1; + break; + } + case Keycode::D: { + Rigidbody & tf = this->get_component(); + Transform & tr = this->get_component(); + if(movement) tf.data.linear_velocity.x += 1; + else tr.position.x += 1; + break; + } + case Keycode::E: { + if (flip) { + flip = false; + this->get_component().active = true; + this->get_components()[0].get().active = true; + this->get_component().active = false; + this->get_components()[1].get().active = false; + } else { + flip = true; + this->get_component().active = false; + this->get_components()[0].get().active = false; + this->get_component().active = true; + this->get_components()[1].get().active = true; + } + + break; + } + case Keycode::Q: { + if(movement){ + movement = false; + Rigidbody & tf = this->get_component(); + tf.data.linear_velocity = {0,0}; + } + else{ + movement = true; + } + + default: + break; + } + return false; + } + + void init() { + Log::logf("init"); + subscribe( + [this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); }); + subscribe( + [this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); }); + } + void update() { + Rigidbody & tf = this->get_component(); + Log::logf("linear_velocity.x {}", tf.data.linear_velocity.x); + Log::logf("linear_velocity.y {}", tf.data.linear_velocity.y); + // tf.data.linear_velocity = {0,0}; + } +}; + + + +class ConcreteScene1 : public Scene { +public: + using Scene::Scene; + + void load_scene() { + + Color color(0, 0, 0, 255); + + float screen_size_width = 320; + float screen_size_height = 240; + float world_collider = 1000; + //define playable world + GameObject world = new_object( + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); + world.add_component( + ivec2{static_cast(screen_size_width), static_cast(screen_size_height)}, + vec2{screen_size_width, screen_size_height}, + Camera::Data{ + .bg_color = Color::WHITE, + .zoom = 1, + }); + + GameObject game_object1 = new_object( + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+60}, 0, 1); + game_object1.add_component(Rigidbody::Data{ + .gravity_scale = 0, + .body_type = Rigidbody::BodyType::KINEMATIC, + .elastisity_coefficient = 1, + }); + // add box with boxcollider + game_object1.add_component(vec2{20, 20}); + game_object1.add_component().set_script(); + + Asset img1{"asset/texture/test_ap43.png"}; + game_object1.add_component(img1, Sprite::Data{ + .size = {20, 20}, + .position_offset = {0, 0}, + }); + + //add circle with cirlcecollider deactiveated + game_object1.add_component(10).active = false; + Asset img2{"asset/texture/circle.png"}; + game_object1.add_component(img2, Sprite::Data{ + .size = {20, 20}, + .position_offset = {0, 0}, }).active = false; + } + + string get_name() const { return "scene1"; } +}; + +int main(int argc, char * argv[]) { + + LoopManager gameloop; + gameloop.add_scene(); + gameloop.start(); + return 0; +}; diff --git a/src/example/game.cpp b/src/example/game.cpp index ce2f351..2660055 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -220,11 +220,11 @@ public: }); GameObject game_object1 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+60}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+20}, 0, 1); game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::KINEMATIC, + .body_type = Rigidbody::BodyType::STATIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, @@ -253,11 +253,11 @@ public: = false; GameObject game_object2 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 90, 1); game_object2.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::DYNAMIC, + .body_type = Rigidbody::BodyType::STATIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, @@ -268,6 +268,9 @@ public: game_object2.add_component(img1, Sprite::Data{ .size = {20, 20}, + .angle_offset = 45, + .scale_offset = 1, + .position_offset = {0,20}, }); //add circle with cirlcecollider deactiveated @@ -280,12 +283,14 @@ public: }) .active = false; - Asset img5{"asset/texture/square.png"}; + Asset img5{"asset/texture/test_ap43.png"}; GameObject particle = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 90, 1); auto & particle_image = particle.add_component(img5, Sprite::Data{ - .size = {5, 5}, + .size = {20, 20}, + .angle_offset = 45, + .scale_offset = 2, }); auto & test = particle.add_component(particle_image, ParticleEmitter::Data{ -- cgit v1.2.3 From 2c4627673f48196e845fc1bcb7b62b3de72c7ab6 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 17:50:12 +0100 Subject: improved doxygen --- src/crepe/api/Rigidbody.h | 31 ++++++++++++++++++--------- src/crepe/system/CollisionSystem.cpp | 17 +++++++-------- src/crepe/system/CollisionSystem.h | 41 +++++++++++++++++++----------------- src/example/game.cpp | 15 +++++++------ 4 files changed, 60 insertions(+), 44 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index df97763..9dbb42b 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -123,26 +123,37 @@ public: */ float elastisity_coefficient = 0.0; - //! Enable static collision handeling for object colliding with kinematic object in collision system - bool kinematic_collision = true; - /** - * \brief Defines the collision layers of a GameObject. + * \brief Enables collision handling for objects colliding with kinematic objects. * - * The `collision_layers` specifies the layers that the GameObject will collide with. - * Each element represents a layer ID, and the GameObject will only detect - * collisions with other GameObjects that belong to that `collision_layer`. + * Enables collision handling for objects colliding with kinematic objects in the collision system. + * If `kinematic_collision` is true, dynamic objects cannot pass through this kinematic object. + * This ensures that kinematic objects delegate collision handling to the collision system. */ + bool kinematic_collision = true; + + /** + * \brief Defines the collision layers a GameObject interacts with. + * + * The `collision_layers` represent the set of layers the GameObject can detect collisions with. + * Each element in this set corresponds to a layer ID. The GameObject will only collide with other + * GameObjects that belong to one these layers. + */ std::set collision_layers = {0}; - //! the collision layer of the object. + /** + * \brief Specifies the collision layer of the GameObject. + * + * The `collision_layer` indicates the single layer that this GameObject belongs to. + * This determines which layers other objects must match to detect collisions with this object. + */ int collision_layer = 0; /** * \brief Defines the collision layers of a GameObject. * * The `collision_names` specifies where the GameObject will collide with. - * Each element represents a name. + * Each element represents a name from the Metadata of the gameobject. */ std::set collision_names; @@ -150,7 +161,7 @@ public: * \brief Defines the collision layers of a GameObject. * * The `collision_tags` specifies where the GameObject will collide with. - * Each element represents a tag. + * Each element represents a tag from the Metadata of the gameobject. */ std::set collision_tags; diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 6ed640a..3da8a50 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -167,7 +167,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .rigidbody = other.info.rigidbody }; resolution = this->get_box_box_detection(BOX1, BOX2); - if(resolution == vec2{-1,-1}) return false; + if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } @@ -183,7 +183,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .rigidbody = other.info.rigidbody }; resolution = this->get_box_circle_detection(BOX1, CIRCLE2); - if(resolution == vec2{-1,-1}) return false; + if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; resolution = -resolution; break; } @@ -199,7 +199,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .rigidbody = other.info.rigidbody }; resolution = this->get_circle_circle_detection(CIRCLE1,CIRCLE2); - if(resolution == vec2{-1,-1}) return false; + if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::CIRCLE_BOX: { @@ -214,7 +214,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .rigidbody = other.info.rigidbody }; resolution = this->get_box_circle_detection(BOX2, CIRCLE1); - if(resolution == vec2{-1,-1}) return false; + if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::NONE: @@ -228,7 +228,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna } vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { - vec2 resolution; + vec2 resolution{std::nanf(""), std::nanf("")}; // Get current positions of colliders vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); vec2 pos2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); @@ -266,9 +266,8 @@ vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, co resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; } } - return resolution; } - return vec2{-1,-1}; + return resolution; } vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, const CircleColliderInternal & circle) const { @@ -312,7 +311,7 @@ vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, return vec2{collision_normal * penetration_depth}; } // No collision - return vec2{-1,-1}; + return vec2{std::nanf(""), std::nanf("")}; } vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { @@ -353,7 +352,7 @@ vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & return resolution; } // No collision - return vec2{-1,-1}; + return vec2{std::nanf(""), std::nanf("")}; } CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody) { diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 13ce8f0..2e9901c 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -31,7 +31,7 @@ private: //! Movement in the Y direction. Y_DIRECTION, //! Movement in both X and Y directions. - BOTH + BOTH, }; public: @@ -87,19 +87,17 @@ private: Direction resolution_direction = Direction::NONE; }; - //! Structure of collider with addtitional components - struct BoxColliderInternal { - BoxCollider & collider; - Transform & transform; - Rigidbody & rigidbody; - }; - - //! Structure of collider with addtitional components - struct CircleColliderInternal { - CircleCollider & collider; - Transform & transform; - Rigidbody & rigidbody; + //! Structure of a collider with additional components + template + struct ColliderInternal { + ColliderType& collider; + Transform& transform; + Rigidbody& rigidbody; }; + //! Predefined BoxColliderInternal. (System is only made for this type) + using BoxColliderInternal = ColliderInternal; + //! Predefined CircleColliderInternal. (System is only made for this type) + using CircleColliderInternal = ColliderInternal; public: //! Updates the collision system by checking for collisions between colliders and handling them. @@ -119,9 +117,11 @@ private: private: /** - * \brief Handles collision resolution between two colliders. + * \brief Converts internal collision data into user-accessible collision information. * - * Processes collision data and adjusts objects to resolve collisions and/or calls the user oncollision script function. + * This function processes collision data from two colliding entities and packages it + * into a structured format that is accessible for further use, + * such as resolving collisions and triggering user-defined collision scripts. * * \param data1 Collision data for the first collider. * \param data2 Collision data for the second collider. @@ -130,14 +130,17 @@ private: /** - * \brief Corrects the resolution of the collision + * \brief Corrects the collision resolution vector and determines its direction. * - * This function corrects the resolution by fixing the x or y if it is empty. - * Besides this with the input of the resolution the direction is saved before correction. + * This function adjusts the provided resolution vector based on the + * rigidbody's linear velocity to ensure consistent collision correction. If the resolution + * vector has only one non-zero component (either x or y), the missing component is computed + * based on the rigidbody's velocity. If both components are non-zero, it indicates a corner + * collision. The function also identifies the direction of the resolution and returns it. * * \param resolution resolution vector that needs to be corrected * \param rigidbody rigidbody data used to correct resolution - * \return Direction of resolution + * \return A Direction indicating the resolution direction */ Direction resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody); diff --git a/src/example/game.cpp b/src/example/game.cpp index 2660055..f757d5f 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -197,7 +197,7 @@ public: world.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::STATIC, + .body_type = Rigidbody::BodyType::DYNAMIC, }); world.add_component( vec2{world_collider, world_collider}, @@ -224,7 +224,7 @@ public: game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, - .body_type = Rigidbody::BodyType::STATIC, + .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, .elastisity_coefficient = 1, @@ -283,20 +283,20 @@ public: }) .active = false; - Asset img5{"asset/texture/test_ap43.png"}; + Asset img5{"asset/texture/square.png"}; GameObject particle = new_object( "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 90, 1); auto & particle_image = particle.add_component(img5, Sprite::Data{ - .size = {20, 20}, + .size = {5, 5}, .angle_offset = 45, - .scale_offset = 2, + .scale_offset = 1, }); auto & test = particle.add_component(particle_image, ParticleEmitter::Data{ .offset = {0, 0}, .max_particles = 256, - .emission_rate = 1, + .emission_rate = 4, .min_speed = 10, .max_speed = 20, .min_angle = -20, @@ -304,6 +304,9 @@ public: .begin_lifespan = 0, .end_lifespan = 5, }); + particle.add_component(Rigidbody::Data{ + .angular_velocity = 20, + }); } string get_name() const { return "scene1"; } -- cgit v1.2.3 From 3a5d4c67dba2edd54a5c888432a8d794d152255e Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 18:30:33 +0100 Subject: improved doxygen comments --- src/crepe/system/CollisionSystem.cpp | 15 +++++------ src/crepe/system/CollisionSystem.h | 51 +++++++++++++++++++++++++++--------- 2 files changed, 45 insertions(+), 21 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 3da8a50..a8e6181 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -250,6 +250,7 @@ vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, co && pos1.y + half_height1 > pos2.y - half_height2 && pos1.y - half_height1 < pos2.y + half_height2) { + resolution = {0,0}; float overlap_x = (half_width1 + half_width2) - std::abs(delta.x); float overlap_y = (half_height1 + half_height2) - std::abs(delta.y); if (overlap_x > 0 && overlap_y > 0) { @@ -404,7 +405,6 @@ CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const Collisi return collision_info; } -// Below is for collision handling void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { Rigidbody::BodyType self_type = info.self.rigidbody.data.body_type; Rigidbody::BodyType other_type = info.other.rigidbody.data.body_type; @@ -425,7 +425,7 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { // Handle collision if (static_collision || kinematic_collision) this->static_collision_handler(inverted); // Call scripts - this->call_collision_events(inverted, info); + this->call_collision_events(inverted); return; } @@ -436,7 +436,7 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { // Handle collision if (static_collision || kinematic_collision) this->static_collision_handler(info); // Call scripts - this->call_collision_events(info, inverted); + this->call_collision_events(info); return; } @@ -444,7 +444,7 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { // Handle collision this->dynamic_collision_handler(info); // Call scripts - this->call_collision_events(info, inverted); + this->call_collision_events(info); } void CollisionSystem::static_collision_handler(const CollisionInfo & info) { @@ -565,14 +565,13 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { } } -void CollisionSystem::call_collision_events(const CollisionInfo & info, - const CollisionInfo & info_inverted) { +void CollisionSystem::call_collision_events(const CollisionInfo & info) { CollisionEvent data(info); - CollisionEvent data_inverted(info_inverted); + CollisionEvent data_inverted(-info); EventManager & emgr = this->mediator.event_manager; emgr.trigger_event(data, info.self.transform.game_object_id); emgr.trigger_event(data_inverted, - info_inverted.self.transform.game_object_id); + -info.self.transform.game_object_id); } diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 2e9901c..30340b5 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -146,9 +146,12 @@ private: /** - * \brief Determines the appropriate collision handler for a collision. + * \brief Determines the appropriate collision handler for a given collision event. * - * Decides the correct resolution process based on the dynamic or static nature of the colliders involved. + * This function identifies the correct collision resolution process based on the body types + * of the colliders involved in the collision. It delegates + * collision handling to specific handlers and calls collision event scripts + * as needed. * * \param info Collision information containing data about both colliders. */ @@ -160,14 +163,20 @@ private: * Calls both collision script to let user add additonal handeling or handle full collision. * * \param info Collision information containing data about both colliders. - * \param info_inverted Collision information containing data about both colliders in opposite order. */ - void call_collision_events(const CollisionInfo & info, const CollisionInfo & info_inverted); + void call_collision_events(const CollisionInfo & info); /** * \brief Handles collisions involving static objects. * - * Resolves collisions by adjusting positions and modifying velocities if bounce is enabled. + * This function resolves collisions between static and dynamic objects by adjusting + * the position of the static object and modifying the velocity of the dynamic object + * if elasticity is enabled. The position of the static object is corrected + * based on the collision resolution, and the dynamic object's velocity is adjusted + * accordingly to reflect the collision response. + * + * The handling includes stopping movement, applying bouncing based on the elasticity + * coefficient, and adjusting the position of the dynamic object if needed. * * \param info Collision information containing data about both colliders. */ @@ -176,7 +185,10 @@ private: /** * \brief Handles collisions involving dynamic objects. * - * Resolves collisions by adjusting positions and modifying velocities if bounce is enabled. + * Resolves collisions between two dynamic objects by adjusting their positions and modifying + * their velocities based on the collision resolution. If elasticity is enabled, + * the velocity of both objects is reversed and scaled by the respective elasticity coefficient. + * The positions of the objects are adjusted based on the collision resolution. * * \param info Collision information containing data about both colliders. */ @@ -186,7 +198,8 @@ private: /** * \brief Checks for collisions between colliders. * - * Identifies collisions and generates pairs of colliding objects for further processing. + * This function checks all active colliders and identifies pairs of colliding objects. + * For each identified collision, the appropriate collision data is returned as pairs for further processing. * * \param colliders A collection of all active colliders. * \return A list of collision pairs with their associated data. @@ -212,7 +225,9 @@ private: /** * \brief Checks for collision between two colliders. * - * Calls the appropriate collision detection function based on the collider types. + * This function determines whether two colliders are colliding based on their types. + * It calls the appropriate collision detection function based on the collider pair type and stores the collision resolution data. + * If a collision is detected, it returns true, otherwise false. * * \param first_info Collision data for the first collider. * \param second_info Collision data for the second collider. @@ -224,29 +239,39 @@ private: /** * \brief Detects collisions between two BoxColliders. * + * This function checks whether two `BoxCollider` are colliding based on their positions and scaled dimensions. + * If a collision is detected, it calculates the overlap along the X and Y axes and returns the resolution vector. + * If no collision is detected, it returns a vector with NaN values. + * \param box1 Information about the first BoxCollider. * \param box2 Information about the second BoxCollider. - * \return returns resolution vector if collide otherwise returns {-1,-1} + * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ vec2 get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; /** * \brief Check collision for box on circle collider * + * This function detects if a collision occurs between a rectangular box and a circular collider. + * If a collision is detected, the function calculates the resolution vector to resolve the collision. + * If no collision is detected, it returns a vector with NaN values + * * \param box1 Information about the BoxCollider. * \param circle2 Information about the circleCollider. - * \return returns resolution vector if collide otherwise returns {-1,-1} + * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ vec2 get_box_circle_detection(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; /** * \brief Check collision for circle on circle collider + * + * This function detects if a collision occurs between two circular colliders. + * If a collision is detected, it calculates the resolution vector to resolve the collision. + * If no collision is detected, it returns a vector with NaN values. * * \param circle1 Information about the first circleCollider. * \param circle2 Information about the second circleCollider. - * \return returns resolution vector if collide otherwise returns {-1,-1} - * - * \return status of collision + * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ vec2 get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const; }; -- cgit v1.2.3 From ac692aa8207fb2dcc059e7761098cd98749154a0 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 18:37:21 +0100 Subject: added some comments --- src/crepe/system/CollisionSystem.cpp | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index a8e6181..c9c5c58 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -156,6 +156,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna vec2 resolution; switch (type) { case CollisionInternalType::BOX_BOX: { + // Box-Box collision detection const BoxColliderInternal BOX1 = { .collider = std::get>(self.collider), .transform = self.info.transform, @@ -166,12 +167,15 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .transform = other.info.transform, .rigidbody = other.info.rigidbody }; + // Get resolution vector from box-box collision detection resolution = this->get_box_box_detection(BOX1, BOX2); + // If no collision (NaN values), return false if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::BOX_CIRCLE: { + // Box-Circle collision detection const BoxColliderInternal BOX1 = { .collider = std::get>(self.collider), .transform = self.info.transform, @@ -182,12 +186,16 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .transform = other.info.transform, .rigidbody = other.info.rigidbody }; + // Get resolution vector from box-circle collision detection resolution = this->get_box_circle_detection(BOX1, CIRCLE2); + // If no collision (NaN values), return false if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + // Invert the resolution vector for proper collision response resolution = -resolution; break; } case CollisionInternalType::CIRCLE_CIRCLE: { + // Circle-Circle collision detection const CircleColliderInternal CIRCLE1 = { .collider = std::get>(self.collider), .transform = self.info.transform, @@ -198,11 +206,14 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .transform = other.info.transform, .rigidbody = other.info.rigidbody }; + // Get resolution vector from circle-circle collision detection resolution = this->get_circle_circle_detection(CIRCLE1,CIRCLE2); + // If no collision (NaN values), return false if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::CIRCLE_BOX: { + // Circle-Box collision detection const CircleColliderInternal CIRCLE1 = { .collider = std::get>(self.collider), .transform = self.info.transform, @@ -213,17 +224,26 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna .transform = other.info.transform, .rigidbody = other.info.rigidbody }; + // Get resolution vector from box-circle collision detection (order swapped) resolution = this->get_box_circle_detection(BOX2, CIRCLE1); + // If no collision (NaN values), return false if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::NONE: - break; + // No collision detection needed if the type is NONE + return false; + break; } + // Store the calculated resolution vector for the 'self' collider self.resolution = resolution; + // Calculate the resolution direction based on the rigidbody data self.resolution_direction = this->resolution_correction(self.resolution, self.info.rigidbody.data); + // For the 'other' collider, the resolution is the opposite direction of 'self' other.resolution = -self.resolution; other.resolution_direction = self.resolution_direction; + + // Return true if a collision was detected and resolution was calculated return true; } -- cgit v1.2.3 From dd035ffa17f4573f06316e0ecb83b426f5ed8285 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 18:58:01 +0100 Subject: updated coments and reverted test cmake --- src/crepe/api/Rigidbody.h | 2 +- src/crepe/system/CollisionSystem.cpp | 46 +++++++++++++++++------------------- src/crepe/system/CollisionSystem.h | 6 ++--- src/example/collisiontest.cpp | 5 ++-- src/example/game.cpp | 4 ++-- src/test/CMakeLists.txt | 46 ++++++++++++++++++------------------ src/test/CollisionTest.cpp | 4 ++-- 7 files changed, 55 insertions(+), 58 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index 9dbb42b..28c376b 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -121,7 +121,7 @@ public: * above 0.0. * */ - float elastisity_coefficient = 0.0; + float elasticity_coefficient = 0.0; /** * \brief Enables collision handling for objects colliding with kinematic objects. diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index c9c5c58..00b56a4 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -242,7 +242,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna // For the 'other' collider, the resolution is the opposite direction of 'self' other.resolution = -self.resolution; other.resolution_direction = self.resolution_direction; - + // Return true if a collision was detected and resolution was calculated return true; } @@ -402,8 +402,6 @@ CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolut CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const CollisionInternal & in_self, const CollisionInternal & in_other) const{ - ComponentManager & mgr = this->mediator.component_manager; - crepe::CollisionSystem::ColliderInfo self { .transform = in_self.info.transform, .rigidbody = in_self.info.rigidbody, @@ -470,7 +468,7 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { void CollisionSystem::static_collision_handler(const CollisionInfo & info) { vec2 & transform_pos = info.self.transform.position; - float elastisity = info.self.rigidbody.data.elastisity_coefficient; + float elasticity = info.self.rigidbody.data.elasticity_coefficient; vec2 & rigidbody_vel = info.self.rigidbody.data.linear_velocity; // Move object back using calculate move back value @@ -479,8 +477,8 @@ void CollisionSystem::static_collision_handler(const CollisionInfo & info) { switch (info.resolution_direction) { case Direction::BOTH: //bounce - if (elastisity > 0) { - rigidbody_vel = -rigidbody_vel * elastisity; + if (elasticity > 0) { + rigidbody_vel = -rigidbody_vel * elasticity; } //stop movement else { @@ -489,8 +487,8 @@ void CollisionSystem::static_collision_handler(const CollisionInfo & info) { break; case Direction::Y_DIRECTION: // Bounce - if (elastisity > 0) { - rigidbody_vel.y = -rigidbody_vel.y * elastisity; + if (elasticity > 0) { + rigidbody_vel.y = -rigidbody_vel.y * elasticity; } // Stop movement else { @@ -500,8 +498,8 @@ void CollisionSystem::static_collision_handler(const CollisionInfo & info) { break; case Direction::X_DIRECTION: // Bounce - if (elastisity > 0) { - rigidbody_vel.x = -rigidbody_vel.x * elastisity; + if (elasticity > 0) { + rigidbody_vel.x = -rigidbody_vel.x * elasticity; } // Stop movement else { @@ -519,8 +517,8 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { vec2 & self_transform_pos = info.self.transform.position; vec2 & other_transform_pos = info.other.transform.position; - float self_elastisity = info.self.rigidbody.data.elastisity_coefficient; - float other_elastisity = info.other.rigidbody.data.elastisity_coefficient; + float self_elasticity = info.self.rigidbody.data.elasticity_coefficient; + float other_elasticity = info.other.rigidbody.data.elasticity_coefficient; vec2 & self_rigidbody_vel = info.self.rigidbody.data.linear_velocity; vec2 & other_rigidbody_vel = info.other.rigidbody.data.linear_velocity; @@ -529,21 +527,21 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { switch (info.resolution_direction) { case Direction::BOTH: - if (self_elastisity > 0) { - self_rigidbody_vel = -self_rigidbody_vel * self_elastisity; + if (self_elasticity > 0) { + self_rigidbody_vel = -self_rigidbody_vel * self_elasticity; } else { self_rigidbody_vel = {0, 0}; } - if (other_elastisity > 0) { - other_rigidbody_vel = -other_rigidbody_vel * other_elastisity; + if (other_elasticity > 0) { + other_rigidbody_vel = -other_rigidbody_vel * other_elasticity; } else { other_rigidbody_vel = {0, 0}; } break; case Direction::Y_DIRECTION: - if (self_elastisity > 0) { - self_rigidbody_vel.y = -self_rigidbody_vel.y * self_elastisity; + if (self_elasticity > 0) { + self_rigidbody_vel.y = -self_rigidbody_vel.y * self_elasticity; } // Stop movement else { @@ -551,8 +549,8 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { self_transform_pos.x -= info.resolution.x; } - if (other_elastisity > 0) { - other_rigidbody_vel.y = -other_rigidbody_vel.y * other_elastisity; + if (other_elasticity > 0) { + other_rigidbody_vel.y = -other_rigidbody_vel.y * other_elasticity; } // Stop movement else { @@ -561,8 +559,8 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { } break; case Direction::X_DIRECTION: - if (self_elastisity > 0) { - self_rigidbody_vel.x = -self_rigidbody_vel.x * self_elastisity; + if (self_elasticity > 0) { + self_rigidbody_vel.x = -self_rigidbody_vel.x * self_elasticity; } // Stop movement else { @@ -570,8 +568,8 @@ void CollisionSystem::dynamic_collision_handler(const CollisionInfo & info) { self_transform_pos.y -= info.resolution.y; } - if (other_elastisity > 0) { - other_rigidbody_vel.x = -other_rigidbody_vel.x * other_elastisity; + if (other_elasticity > 0) { + other_rigidbody_vel.x = -other_rigidbody_vel.x * other_elasticity; } // Stop movement else { diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index 30340b5..b7808f1 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -74,7 +74,7 @@ private: /** * \brief A structure to store the collision data of a single collider. * - * This structure all components and id that are for needed within this system when calculating or handeling collisions. + * This structure all components and id that are for needed within this system when calculating or handling collisions. * The transform and rigidbody are mostly needed for location and rotation. * In rigidbody additional info is written about what the body of the object is, * and how it should respond on a collision. @@ -160,7 +160,7 @@ private: /** * \brief Calls both collision script * - * Calls both collision script to let user add additonal handeling or handle full collision. + * Calls both collision script to let user add additonal handling or handle full collision. * * \param info Collision information containing data about both colliders. */ @@ -218,7 +218,7 @@ private: * \param other_rigidbody Rigidbody of second collider * \param this_metadata Rigidbody of first object * \param other_metadata Rigidbody of second object - * \return Returns true if there is at least one comparision found. + * \return Returns true if there is at least one comparison found. */ bool should_collide(const CollisionInternal & self, const CollisionInternal & other) const; //done diff --git a/src/example/collisiontest.cpp b/src/example/collisiontest.cpp index 95999c6..b0cb92e 100644 --- a/src/example/collisiontest.cpp +++ b/src/example/collisiontest.cpp @@ -75,8 +75,7 @@ class MyScript1 : public Script { } break; - } - case Keycode::Q: { + }case Keycode::Q: { if(movement){ movement = false; Rigidbody & tf = this->get_component(); @@ -136,7 +135,7 @@ public: game_object1.add_component(Rigidbody::Data{ .gravity_scale = 0, .body_type = Rigidbody::BodyType::KINEMATIC, - .elastisity_coefficient = 1, + .elasticity_coefficient = 1, }); // add box with boxcollider game_object1.add_component(vec2{20, 20}); diff --git a/src/example/game.cpp b/src/example/game.cpp index f757d5f..f5b6f4f 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -227,7 +227,7 @@ public: .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, - .elastisity_coefficient = 1, + .elasticity_coefficient = 1, }); // add box with boxcollider game_object1.add_component(vec2{20, 20}); @@ -260,7 +260,7 @@ public: .body_type = Rigidbody::BodyType::STATIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, - .elastisity_coefficient = 1, + .elasticity_coefficient = 1, }); // add box with boxcollider game_object2.add_component(vec2{20, 20}); diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index 61254f1..11b4ca9 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -1,27 +1,27 @@ target_sources(test_main PUBLIC main.cpp CollisionTest.cpp - # PhysicsTest.cpp - # ScriptTest.cpp - # ParticleTest.cpp - # AudioTest.cpp - # AssetTest.cpp - # ResourceManagerTest.cpp - # OptionalRefTest.cpp - # RenderSystemTest.cpp - # EventTest.cpp - # ECSTest.cpp - # SceneManagerTest.cpp - # ValueBrokerTest.cpp - # DBTest.cpp - # Vector2Test.cpp - # LoopManagerTest.cpp - # LoopTimerTest.cpp - # InputTest.cpp - # ScriptEventTest.cpp - # ScriptSceneTest.cpp - # Profiling.cpp - # SaveManagerTest.cpp - # ScriptSaveManagerTest.cpp - # ScriptECSTest.cpp + PhysicsTest.cpp + ScriptTest.cpp + ParticleTest.cpp + AudioTest.cpp + AssetTest.cpp + ResourceManagerTest.cpp + OptionalRefTest.cpp + RenderSystemTest.cpp + EventTest.cpp + ECSTest.cpp + SceneManagerTest.cpp + ValueBrokerTest.cpp + DBTest.cpp + Vector2Test.cpp + LoopManagerTest.cpp + LoopTimerTest.cpp + InputTest.cpp + ScriptEventTest.cpp + ScriptSceneTest.cpp + Profiling.cpp + SaveManagerTest.cpp + ScriptSaveManagerTest.cpp + ScriptECSTest.cpp ) diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp index a86f7d3..89dfadb 100644 --- a/src/test/CollisionTest.cpp +++ b/src/test/CollisionTest.cpp @@ -80,7 +80,7 @@ public: .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, - .elastisity_coefficient = 1, + .elasticity_coefficient = 1, .collision_layers = {0}, }); game_object1.add_component(vec2{10, 10}, vec2{0, 0}); @@ -95,7 +95,7 @@ public: .body_type = Rigidbody::BodyType::DYNAMIC, .linear_velocity = {0, 0}, .constraints = {0, 0, 0}, - .elastisity_coefficient = 1, + .elasticity_coefficient = 1, .collision_layers = {0}, }); game_object2.add_component(vec2{10, 10}, vec2{0, 0}); -- cgit v1.2.3 From 655fcc23f2ced807738feffe8b85683eaf97624f Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 19:07:07 +0100 Subject: added doxygen --- src/crepe/util/AbsolutePosition.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src/crepe') diff --git a/src/crepe/util/AbsolutePosition.h b/src/crepe/util/AbsolutePosition.h index 0bc8748..857c1ac 100644 --- a/src/crepe/util/AbsolutePosition.h +++ b/src/crepe/util/AbsolutePosition.h @@ -6,8 +6,23 @@ namespace crepe { +/** + * \brief A class for calculating the absolute position of an object. + * + * This class provides a utility function to get the position of an object in the world space, + * taking into account the transform and any additional offset. + */ class AbsolutePosition { public: + /** + * \brief Get the absolute position of an object. + * + * This function calculates the absolute position by combining the transform position with an optional offset. + * + * \param transform The transform of the object, which contains its position, rotation, and scale. + * \param offset The offset to apply to the object's position (in local space). + * \return The absolute position of the object as a 2D vector. + */ static vec2 get_position(const Transform & transform, const vec2 & offset); }; -- cgit v1.2.3 From 8cd4b07e866d33589a7218367a5639b602c40c67 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 19:45:17 +0100 Subject: make format --- src/crepe/api/Rigidbody.h | 2 - src/crepe/facade/SDLContext.cpp | 8 +- src/crepe/system/CollisionSystem.cpp | 335 +++++++++++++++++------------------ src/crepe/system/CollisionSystem.h | 42 +++-- src/crepe/system/ParticleSystem.cpp | 3 +- src/crepe/system/RenderSystem.cpp | 2 +- src/example/game.cpp | 4 +- src/test/CollisionTest.cpp | 1 - 8 files changed, 198 insertions(+), 199 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index 28c376b..b63d941 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -164,8 +164,6 @@ public: * Each element represents a tag from the Metadata of the gameobject. */ std::set collision_tags; - - }; public: diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index ca45b79..164d35e 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -229,10 +229,10 @@ void SDLContext::draw_text(const RenderText & data) { = {tmp_font_texture, [](SDL_Texture * texture) { SDL_DestroyTexture(texture); }}; vec2 size = text.dimensions * cam_aux_data.render_scale * data.transform.scale; - vec2 screen_pos = (absoluut_pos - cam_aux_data.cam_pos - + (cam_aux_data.zoomed_viewport) / 2) - * cam_aux_data.render_scale - - size / 2 + cam_aux_data.bar_size; + vec2 screen_pos + = (absoluut_pos - cam_aux_data.cam_pos + (cam_aux_data.zoomed_viewport) / 2) + * cam_aux_data.render_scale + - size / 2 + cam_aux_data.bar_size; SDL_FRect dstrect{ .x = screen_pos.x, diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 00b56a4..f0f1fa8 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -26,12 +26,12 @@ using namespace crepe; using enum Rigidbody::BodyType; CollisionSystem::CollisionInfo CollisionSystem::CollisionInfo::operator-() const { - return { - .self = this->other, + return { + .self = this->other, .other = this->self, .resolution = -this->resolution, .resolution_direction = this->resolution_direction, - }; + }; } void CollisionSystem::update() { @@ -52,8 +52,7 @@ void CollisionSystem::update() { if (!boxcollider.active) continue; all_colliders.push_back({.id = id, .collider = collider_variant{boxcollider}, - .info = {transform,rigidbody, metadata} - }); + .info = {transform, rigidbody, metadata}}); } // Check if the circlecollider is active and has the same id as the rigidbody. RefVector circlecolliders @@ -63,8 +62,7 @@ void CollisionSystem::update() { if (!circlecollider.active) continue; all_colliders.push_back({.id = id, .collider = collider_variant{circlecollider}, - .info = {transform,rigidbody, metadata} - }); + .info = {transform, rigidbody, metadata}}); } } @@ -75,13 +73,14 @@ void CollisionSystem::update() { // For the object convert the info and call the collision handler if needed for (auto & collision_pair : collided) { // Convert internal struct to external struct - CollisionInfo info = this->get_collision_info(collision_pair.first, collision_pair.second); + CollisionInfo info + = this->get_collision_info(collision_pair.first, collision_pair.second); // Determine if and/or what collison handler is needed. this->determine_collision_handler(info); } } -// Below is for collision detection +// Below is for collision detection std::vector> CollisionSystem::gather_collisions(std::vector & colliders) { @@ -101,17 +100,18 @@ CollisionSystem::gather_collisions(std::vector & colliders) { for (size_t j = i + 1; j < colliders.size(); ++j) { if (colliders[i].id == colliders[j].id) continue; if (!should_collide(colliders[i], colliders[j])) continue; - CollisionInternalType type = get_collider_type(colliders[i].collider, colliders[j].collider); - if (!detect_collision(colliders[i],colliders[j],type)) continue; - //fet - collisions_ret.emplace_back(colliders[i], colliders[j]); + CollisionInternalType type + = get_collider_type(colliders[i].collider, colliders[j].collider); + if (!detect_collision(colliders[i], colliders[j], type)) continue; + //fet + collisions_ret.emplace_back(colliders[i], colliders[j]); } } return collisions_ret; } - -bool CollisionSystem::should_collide(const CollisionInternal & self, const CollisionInternal & other) const{ +bool CollisionSystem::should_collide(const CollisionInternal & self, + const CollisionInternal & other) const { const Rigidbody::Data & self_rigidbody = self.info.rigidbody.data; const Rigidbody::Data & other_rigidbody = other.info.rigidbody.data; @@ -119,21 +119,20 @@ bool CollisionSystem::should_collide(const CollisionInternal & self, const Colli const Metadata & other_metadata = other.info.metadata; // Check collision layers - if(self_rigidbody.collision_layers.contains(other_rigidbody.collision_layer)) return true; - if(other_rigidbody.collision_layers.contains(self_rigidbody.collision_layer)) return true; + if (self_rigidbody.collision_layers.contains(other_rigidbody.collision_layer)) return true; + if (other_rigidbody.collision_layers.contains(self_rigidbody.collision_layer)) return true; // Check names - if(self_rigidbody.collision_names.contains(other_metadata.name)) return true; - if(other_rigidbody.collision_names.contains(self_metadata.name)) return true; + if (self_rigidbody.collision_names.contains(other_metadata.name)) return true; + if (other_rigidbody.collision_names.contains(self_metadata.name)) return true; // Check tags - if(self_rigidbody.collision_tags.contains(other_metadata.tag)) return true; - if(other_rigidbody.collision_tags.contains(self_metadata.tag)) return true; + if (self_rigidbody.collision_tags.contains(other_metadata.tag)) return true; + if (other_rigidbody.collision_tags.contains(self_metadata.tag)) return true; return false; } - CollisionSystem::CollisionInternalType CollisionSystem::get_collider_type(const collider_variant & collider1, const collider_variant & collider2) const { @@ -152,93 +151,86 @@ CollisionSystem::get_collider_type(const collider_variant & collider1, } } -bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInternal & other,const CollisionInternalType & type) { +bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionInternal & other, + const CollisionInternalType & type) { vec2 resolution; switch (type) { - case CollisionInternalType::BOX_BOX: { + case CollisionInternalType::BOX_BOX: { // Box-Box collision detection - const BoxColliderInternal BOX1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - const BoxColliderInternal BOX2 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; + const BoxColliderInternal BOX1 + = {.collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody}; + const BoxColliderInternal BOX2 + = {.collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody}; // Get resolution vector from box-box collision detection resolution = this->get_box_box_detection(BOX1, BOX2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if (std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; - } case CollisionInternalType::BOX_CIRCLE: { // Box-Circle collision detection - const BoxColliderInternal BOX1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; + const BoxColliderInternal BOX1 + = {.collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody}; const CircleColliderInternal CIRCLE2 = { .collider = std::get>(other.collider), .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; + .rigidbody = other.info.rigidbody}; // Get resolution vector from box-circle collision detection resolution = this->get_box_circle_detection(BOX1, CIRCLE2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if (std::isnan(resolution.x) && std::isnan(resolution.y)) return false; // Invert the resolution vector for proper collision response resolution = -resolution; break; } - case CollisionInternalType::CIRCLE_CIRCLE: { + case CollisionInternalType::CIRCLE_CIRCLE: { // Circle-Circle collision detection - const CircleColliderInternal CIRCLE1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; + const CircleColliderInternal CIRCLE1 + = {.collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody}; const CircleColliderInternal CIRCLE2 = { .collider = std::get>(other.collider), .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; + .rigidbody = other.info.rigidbody}; // Get resolution vector from circle-circle collision detection - resolution = this->get_circle_circle_detection(CIRCLE1,CIRCLE2); + resolution = this->get_circle_circle_detection(CIRCLE1, CIRCLE2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if (std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } - case CollisionInternalType::CIRCLE_BOX: { + case CollisionInternalType::CIRCLE_BOX: { // Circle-Box collision detection - const CircleColliderInternal CIRCLE1 = { - .collider = std::get>(self.collider), - .transform = self.info.transform, - .rigidbody = self.info.rigidbody - }; - const BoxColliderInternal BOX2 = { - .collider = std::get>(other.collider), - .transform = other.info.transform, - .rigidbody = other.info.rigidbody - }; + const CircleColliderInternal CIRCLE1 + = {.collider = std::get>(self.collider), + .transform = self.info.transform, + .rigidbody = self.info.rigidbody}; + const BoxColliderInternal BOX2 + = {.collider = std::get>(other.collider), + .transform = other.info.transform, + .rigidbody = other.info.rigidbody}; // Get resolution vector from box-circle collision detection (order swapped) resolution = this->get_box_circle_detection(BOX2, CIRCLE1); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if (std::isnan(resolution.x) && std::isnan(resolution.y)) return false; break; } case CollisionInternalType::NONE: - // No collision detection needed if the type is NONE - return false; - break; + // No collision detection needed if the type is NONE + return false; + break; } - // Store the calculated resolution vector for the 'self' collider + // Store the calculated resolution vector for the 'self' collider self.resolution = resolution; // Calculate the resolution direction based on the rigidbody data - self.resolution_direction = this->resolution_correction(self.resolution, self.info.rigidbody.data); + self.resolution_direction + = this->resolution_correction(self.resolution, self.info.rigidbody.data); // For the 'other' collider, the resolution is the opposite direction of 'self' other.resolution = -self.resolution; other.resolution_direction = self.resolution_direction; @@ -247,18 +239,18 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna return true; } -vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { +vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, + const BoxColliderInternal & box2) const { vec2 resolution{std::nanf(""), std::nanf("")}; // Get current positions of colliders - vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); - vec2 pos2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); + vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); + vec2 pos2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); // Scale dimensions vec2 scaled_box1 = box1.collider.dimensions * box1.transform.scale; vec2 scaled_box2 = box2.collider.dimensions * box2.transform.scale; vec2 delta = pos2 - pos1; - // Calculate half-extents (half width and half height) float half_width1 = scaled_box1.x / 2.0; float half_height1 = scaled_box1.y / 2.0; @@ -266,79 +258,85 @@ vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, co float half_height2 = scaled_box2.y / 2.0; if (pos1.x + half_width1 > pos2.x - half_width2 - && pos1.x - half_width1 < pos2.x + half_width2 - && pos1.y + half_height1 > pos2.y - half_height2 - && pos1.y - half_height1 < pos2.y + half_height2) - { - resolution = {0,0}; + && pos1.x - half_width1 < pos2.x + half_width2 + && pos1.y + half_height1 > pos2.y - half_height2 + && pos1.y - half_height1 < pos2.y + half_height2) { + resolution = {0, 0}; float overlap_x = (half_width1 + half_width2) - std::abs(delta.x); float overlap_y = (half_height1 + half_height2) - std::abs(delta.y); if (overlap_x > 0 && overlap_y > 0) { - // Determine the direction of resolution - if (overlap_x < overlap_y) { - // Resolve along the X-axis (smallest overlap) - resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; - } else if (overlap_y < overlap_x) { - // Resolve along the Y-axis (smallest overlap) - resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; - } else { - // Equal overlap, resolve both directions with preference - resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; - resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; + // Determine the direction of resolution + if (overlap_x < overlap_y) { + // Resolve along the X-axis (smallest overlap) + resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; + } else if (overlap_y < overlap_x) { + // Resolve along the Y-axis (smallest overlap) + resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; + } else { + // Equal overlap, resolve both directions with preference + resolution.x = (delta.x > 0) ? -overlap_x : overlap_x; + resolution.y = (delta.y > 0) ? -overlap_y : overlap_y; + } } } - } return resolution; } -vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, const CircleColliderInternal & circle) const { +vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, + const CircleColliderInternal & circle) const { /// Get current positions of colliders - vec2 box_pos = AbsolutePosition::get_position(box.transform, box.collider.offset); - vec2 circle_pos = AbsolutePosition::get_position(circle.transform, circle.collider.offset); - - // Scale dimensions - vec2 scaled_box = box.collider.dimensions * box.transform.scale; - float scaled_circle_radius = circle.collider.radius * circle.transform.scale; - - // Calculate box half-extents - float half_width = scaled_box.x / 2.0f; - float half_height = scaled_box.y / 2.0f; - - // Find the closest point on the box to the circle's center - float closest_x = std::max(box_pos.x - half_width, std::min(circle_pos.x, box_pos.x + half_width)); - float closest_y = std::max(box_pos.y - half_height, std::min(circle_pos.y, box_pos.y + half_height)); - - float distance_x = circle_pos.x - closest_x; - float distance_y = circle_pos.y - closest_y; - float distance_squared = distance_x * distance_x + distance_y * distance_y; - if(distance_squared < scaled_circle_radius * scaled_circle_radius){ - vec2 delta = circle_pos - box_pos; - - // Clamp circle center to the nearest point on the box - vec2 closest_point; - closest_point.x = std::clamp(delta.x, -half_width, half_width); - closest_point.y = std::clamp(delta.y, -half_height, half_height); - - // Find the vector from the circle center to the closest point - vec2 closest_delta = delta - closest_point; - - float distance = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y); - vec2 collision_normal = closest_delta / distance; - - // Compute penetration depth - float penetration_depth = scaled_circle_radius - distance; - - // Compute the resolution vector - return vec2{collision_normal * penetration_depth}; - } - // No collision - return vec2{std::nanf(""), std::nanf("")}; + vec2 box_pos = AbsolutePosition::get_position(box.transform, box.collider.offset); + vec2 circle_pos = AbsolutePosition::get_position(circle.transform, circle.collider.offset); + + // Scale dimensions + vec2 scaled_box = box.collider.dimensions * box.transform.scale; + float scaled_circle_radius = circle.collider.radius * circle.transform.scale; + + // Calculate box half-extents + float half_width = scaled_box.x / 2.0f; + float half_height = scaled_box.y / 2.0f; + + // Find the closest point on the box to the circle's center + float closest_x + = std::max(box_pos.x - half_width, std::min(circle_pos.x, box_pos.x + half_width)); + float closest_y + = std::max(box_pos.y - half_height, std::min(circle_pos.y, box_pos.y + half_height)); + + float distance_x = circle_pos.x - closest_x; + float distance_y = circle_pos.y - closest_y; + float distance_squared = distance_x * distance_x + distance_y * distance_y; + if (distance_squared < scaled_circle_radius * scaled_circle_radius) { + vec2 delta = circle_pos - box_pos; + + // Clamp circle center to the nearest point on the box + vec2 closest_point; + closest_point.x = std::clamp(delta.x, -half_width, half_width); + closest_point.y = std::clamp(delta.y, -half_height, half_height); + + // Find the vector from the circle center to the closest point + vec2 closest_delta = delta - closest_point; + + float distance + = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y); + vec2 collision_normal = closest_delta / distance; + + // Compute penetration depth + float penetration_depth = scaled_circle_radius - distance; + + // Compute the resolution vector + return vec2{collision_normal * penetration_depth}; + } + // No collision + return vec2{std::nanf(""), std::nanf("")}; } -vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { +vec2 CollisionSystem::get_circle_circle_detection( + const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { // Get current positions of colliders - vec2 final_position1 = AbsolutePosition::get_position(circle1.transform, circle1.collider.offset); - vec2 final_position2 = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); + vec2 final_position1 + = AbsolutePosition::get_position(circle1.transform, circle1.collider.offset); + vec2 final_position2 + = AbsolutePosition::get_position(circle2.transform, circle2.collider.offset); // Scale dimensions float scaled_circle1 = circle1.collider.radius * circle1.transform.scale; @@ -376,7 +374,8 @@ vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & return vec2{std::nanf(""), std::nanf("")}; } -CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody) { +CollisionSystem::Direction +CollisionSystem::resolution_correction(vec2 & resolution, const Rigidbody::Data & rigidbody) { // Calculate the other value to move back correctly // If only X or Y has a value determine what is should be to move back. @@ -384,63 +383,64 @@ CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolut // If both are not zero a perfect corner has been hit if (resolution.x != 0 && resolution.y != 0) { resolution_direction = Direction::BOTH; - // If x is not zero a horizontal action was latest action. + // If x is not zero a horizontal action was latest action. } else if (resolution.x != 0) { resolution_direction = Direction::X_DIRECTION; // If both are 0 resolution y should not be changed (y_velocity can be 0 by kinematic object movement) if (rigidbody.linear_velocity.x != 0 && rigidbody.linear_velocity.y != 0) - resolution.y = -rigidbody.linear_velocity.y * (resolution.x / rigidbody.linear_velocity.x); + resolution.y + = -rigidbody.linear_velocity.y * (resolution.x / rigidbody.linear_velocity.x); } else if (resolution.y != 0) { resolution_direction = Direction::Y_DIRECTION; // If both are 0 resolution x should not be changed (x_velocity can be 0 by kinematic object movement) if (rigidbody.linear_velocity.x != 0 && rigidbody.linear_velocity.y != 0) - resolution.x = -rigidbody.linear_velocity.x * (resolution.y / rigidbody.linear_velocity.y); + resolution.x + = -rigidbody.linear_velocity.x * (resolution.y / rigidbody.linear_velocity.y); } return resolution_direction; } -CollisionSystem::CollisionInfo CollisionSystem::get_collision_info(const CollisionInternal & in_self, const CollisionInternal & in_other) const{ +CollisionSystem::CollisionInfo +CollisionSystem::get_collision_info(const CollisionInternal & in_self, + const CollisionInternal & in_other) const { - crepe::CollisionSystem::ColliderInfo self { - .transform = in_self.info.transform, - .rigidbody = in_self.info.rigidbody, - .metadata = in_self.info.metadata, + crepe::CollisionSystem::ColliderInfo self{ + .transform = in_self.info.transform, + .rigidbody = in_self.info.rigidbody, + .metadata = in_self.info.metadata, }; - crepe::CollisionSystem::ColliderInfo other { - .transform = in_other.info.transform, - .rigidbody = in_other.info.rigidbody, - .metadata = in_other.info.metadata, + crepe::CollisionSystem::ColliderInfo other{ + .transform = in_other.info.transform, + .rigidbody = in_other.info.rigidbody, + .metadata = in_other.info.metadata, }; - struct CollisionInfo collision_info{ - .self = self, - .other = other, - .resolution = in_self.resolution, + struct CollisionInfo collision_info { + .self = self, .other = other, .resolution = in_self.resolution, .resolution_direction = in_self.resolution_direction, }; return collision_info; } void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { - Rigidbody::BodyType self_type = info.self.rigidbody.data.body_type; - Rigidbody::BodyType other_type = info.other.rigidbody.data.body_type; + Rigidbody::BodyType self_type = info.self.rigidbody.data.body_type; + Rigidbody::BodyType other_type = info.other.rigidbody.data.body_type; bool self_kinematic = info.self.rigidbody.data.kinematic_collision; bool other_kinematic = info.other.rigidbody.data.kinematic_collision; // Inverted collision info CollisionInfo inverted = -info; // If both objects are static skip handle call collision script - if (self_type == STATIC - && other_type == STATIC) - return; + if (self_type == STATIC && other_type == STATIC) return; // First body is not dynamic if (self_type != DYNAMIC) { bool static_collision = self_type == STATIC && other_type == DYNAMIC; - bool kinematic_collision = self_type == KINEMATIC && other_type == DYNAMIC && self_kinematic; + bool kinematic_collision + = self_type == KINEMATIC && other_type == DYNAMIC && self_kinematic; - // Handle collision + // Handle collision if (static_collision || kinematic_collision) this->static_collision_handler(inverted); // Call scripts this->call_collision_events(inverted); @@ -451,7 +451,7 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { if (other_type != DYNAMIC) { bool static_collision = other_type == STATIC; bool kinematic_collision = other_type == KINEMATIC && other_kinematic; - // Handle collision + // Handle collision if (static_collision || kinematic_collision) this->static_collision_handler(info); // Call scripts this->call_collision_events(info); @@ -459,18 +459,18 @@ void CollisionSystem::determine_collision_handler(const CollisionInfo & info) { } // Dynamic - // Handle collision + // Handle collision this->dynamic_collision_handler(info); // Call scripts this->call_collision_events(info); } void CollisionSystem::static_collision_handler(const CollisionInfo & info) { - + vec2 & transform_pos = info.self.transform.position; float elasticity = info.self.rigidbody.data.elasticity_coefficient; vec2 & rigidbody_vel = info.self.rigidbody.data.linear_velocity; - + // Move object back using calculate move back value transform_pos += info.resolution; @@ -588,10 +588,5 @@ void CollisionSystem::call_collision_events(const CollisionInfo & info) { CollisionEvent data_inverted(-info); EventManager & emgr = this->mediator.event_manager; emgr.trigger_event(data, info.self.transform.game_object_id); - emgr.trigger_event(data_inverted, - -info.self.transform.game_object_id); + emgr.trigger_event(data_inverted, -info.self.transform.game_object_id); } - - - - diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h index b7808f1..7be280a 100644 --- a/src/crepe/system/CollisionSystem.h +++ b/src/crepe/system/CollisionSystem.h @@ -21,6 +21,7 @@ namespace crepe { class CollisionSystem : public System { public: using System::System; + private: //! Enum representing movement directions during collision resolution. enum class Direction { @@ -33,13 +34,13 @@ private: //! Movement in both X and Y directions. BOTH, }; + public: - //! Structure representing components of the collider struct ColliderInfo { - Transform & transform; - Rigidbody & rigidbody; - Metadata & metadata; + Transform & transform; + Rigidbody & rigidbody; + Metadata & metadata; }; /** @@ -54,7 +55,7 @@ public: vec2 resolution; //! The direction of movement for resolving the collision. Direction resolution_direction = Direction::NONE; - CollisionInfo operator - () const; + CollisionInfo operator-() const; }; private: @@ -90,9 +91,9 @@ private: //! Structure of a collider with additional components template struct ColliderInternal { - ColliderType& collider; - Transform& transform; - Rigidbody& rigidbody; + ColliderType & collider; + Transform & transform; + Rigidbody & rigidbody; }; //! Predefined BoxColliderInternal. (System is only made for this type) using BoxColliderInternal = ColliderInternal; @@ -113,7 +114,8 @@ private: * \param collider2 Second collider variant (BoxCollider or CircleCollider). * \return The combined type of the two colliders. */ - CollisionInternalType get_collider_type(const collider_variant & collider1, const collider_variant & collider2) const; + CollisionInternalType get_collider_type(const collider_variant & collider1, + const collider_variant & collider2) const; private: /** @@ -126,8 +128,8 @@ private: * \param data1 Collision data for the first collider. * \param data2 Collision data for the second collider. */ - CollisionInfo get_collision_info(const CollisionInternal & data1, const CollisionInternal & data2) const; - + CollisionInfo get_collision_info(const CollisionInternal & data1, + const CollisionInternal & data2) const; /** * \brief Corrects the collision resolution vector and determines its direction. @@ -142,8 +144,7 @@ private: * \param rigidbody rigidbody data used to correct resolution * \return A Direction indicating the resolution direction */ - Direction resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody); - + Direction resolution_correction(vec2 & resolution, const Rigidbody::Data & rigidbody); /** * \brief Determines the appropriate collision handler for a given collision event. @@ -220,7 +221,8 @@ private: * \param other_metadata Rigidbody of second object * \return Returns true if there is at least one comparison found. */ - bool should_collide(const CollisionInternal & self, const CollisionInternal & other) const; //done + bool should_collide(const CollisionInternal & self, + const CollisionInternal & other) const; //done /** * \brief Checks for collision between two colliders. @@ -234,7 +236,8 @@ private: * \param type The type of collider pair. * \return True if a collision is detected, otherwise false. */ - bool detect_collision(CollisionInternal & first_info, CollisionInternal & second_info, const CollisionInternalType & type); + bool detect_collision(CollisionInternal & first_info, CollisionInternal & second_info, + const CollisionInternalType & type); /** * \brief Detects collisions between two BoxColliders. @@ -247,7 +250,8 @@ private: * \param box2 Information about the second BoxCollider. * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ - vec2 get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const; + vec2 get_box_box_detection(const BoxColliderInternal & box1, + const BoxColliderInternal & box2) const; /** * \brief Check collision for box on circle collider @@ -260,7 +264,8 @@ private: * \param circle2 Information about the circleCollider. * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ - vec2 get_box_circle_detection(const BoxColliderInternal & box1, const CircleColliderInternal & circle2) const; + vec2 get_box_circle_detection(const BoxColliderInternal & box1, + const CircleColliderInternal & circle2) const; /** * \brief Check collision for circle on circle collider @@ -273,7 +278,8 @@ private: * \param circle2 Information about the second circleCollider. * \return If colliding, returns the resolution vector; otherwise, returns {NaN, NaN}. */ - vec2 get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const; + vec2 get_circle_circle_detection(const CircleColliderInternal & circle1, + const CircleColliderInternal & circle2) const; }; /** diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 31c1800..e66c603 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -51,7 +51,8 @@ void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & vec2 initial_position = AbsolutePosition::get_position(transform, emitter.data.offset); float random_angle - = this->generate_random_angle(emitter.data.min_angle+transform.rotation, emitter.data.max_angle+transform.rotation); + = this->generate_random_angle(emitter.data.min_angle + transform.rotation, + emitter.data.max_angle + transform.rotation); float random_speed = this->generate_random_speed(emitter.data.min_speed, emitter.data.max_speed); diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 9d8e683..8c31743 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -16,9 +16,9 @@ #include "../facade/Texture.h" #include "../manager/ComponentManager.h" #include "../manager/ResourceManager.h" -#include "util/AbsolutePosition.h" #include "api/Text.h" #include "facade/Font.h" +#include "util/AbsolutePosition.h" #include "RenderSystem.h" #include "types.h" diff --git a/src/example/game.cpp b/src/example/game.cpp index 76ea8c2..fb7fb63 100644 --- a/src/example/game.cpp +++ b/src/example/game.cpp @@ -220,7 +220,7 @@ public: }); GameObject game_object1 = new_object( - "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2+20}, 0, 1); + "Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2 + 20}, 0, 1); game_object1.add_component(Rigidbody::Data{ .mass = 1, .gravity_scale = 0, @@ -270,7 +270,7 @@ public: .size = {20, 20}, .angle_offset = 45, .scale_offset = 1, - .position_offset = {0,20}, + .position_offset = {0, 20}, }); //add circle with cirlcecollider deactiveated diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp index 8f566df..11916eb 100644 --- a/src/test/CollisionTest.cpp +++ b/src/test/CollisionTest.cpp @@ -25,7 +25,6 @@ using namespace std::chrono_literals; using namespace crepe; using namespace testing; - class CollisionHandler : public Script { public: int box_id; -- cgit v1.2.3 From d2c8a2bf07275f5458c576990b8742a710b15013 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 20:16:30 +0100 Subject: is_nan fix --- src/crepe/api/Vector2.h | 3 +++ src/crepe/api/Vector2.hpp | 5 +++++ src/crepe/system/CollisionSystem.cpp | 14 +++++++------- 3 files changed, 15 insertions(+), 7 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h index bf9d124..52e1bb6 100644 --- a/src/crepe/api/Vector2.h +++ b/src/crepe/api/Vector2.h @@ -90,6 +90,9 @@ struct Vector2 { //! Returns the perpendicular vector to this vector. Vector2 perpendicular() const; + + //! Checks if both components of the vector are NaN. + bool is_nan() const; }; } // namespace crepe diff --git a/src/crepe/api/Vector2.hpp b/src/crepe/api/Vector2.hpp index ff53cb0..a470595 100644 --- a/src/crepe/api/Vector2.hpp +++ b/src/crepe/api/Vector2.hpp @@ -163,4 +163,9 @@ Vector2 Vector2::perpendicular() const { return {-y, x}; } +template +bool Vector2::is_nan() const { + return std::isnan(x) && std::isnan(y); +} + } // namespace crepe diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 00b56a4..ceacda2 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -170,7 +170,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna // Get resolution vector from box-box collision detection resolution = this->get_box_box_detection(BOX1, BOX2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if(resolution.is_nan()) return false; break; } @@ -189,7 +189,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna // Get resolution vector from box-circle collision detection resolution = this->get_box_circle_detection(BOX1, CIRCLE2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if(resolution.is_nan()) return false; // Invert the resolution vector for proper collision response resolution = -resolution; break; @@ -209,7 +209,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna // Get resolution vector from circle-circle collision detection resolution = this->get_circle_circle_detection(CIRCLE1,CIRCLE2); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if(resolution.is_nan()) return false; break; } case CollisionInternalType::CIRCLE_BOX: { @@ -227,7 +227,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna // Get resolution vector from box-circle collision detection (order swapped) resolution = this->get_box_circle_detection(BOX2, CIRCLE1); // If no collision (NaN values), return false - if(std::isnan(resolution.x) && std::isnan(resolution.y)) return false; + if(resolution.is_nan()) return false; break; } case CollisionInternalType::NONE: @@ -248,7 +248,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self,CollisionInterna } vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { - vec2 resolution{std::nanf(""), std::nanf("")}; + vec2 resolution{NAN, NAN}; // Get current positions of colliders vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); vec2 pos2 = AbsolutePosition::get_position(box2.transform, box2.collider.offset); @@ -332,7 +332,7 @@ vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, return vec2{collision_normal * penetration_depth}; } // No collision - return vec2{std::nanf(""), std::nanf("")}; + return vec2{NAN, NAN};; } vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & circle1, const CircleColliderInternal & circle2) const { @@ -373,7 +373,7 @@ vec2 CollisionSystem::get_circle_circle_detection(const CircleColliderInternal & return resolution; } // No collision - return vec2{std::nanf(""), std::nanf("")}; + return vec2{NAN, NAN};; } CollisionSystem::Direction CollisionSystem::resolution_correction(vec2 & resolution,const Rigidbody::Data & rigidbody) { -- cgit v1.2.3 From 34d36c27549d54592051083aea6675dbaa9bb1fa Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 20:20:29 +0100 Subject: nan test fix --- src/crepe/system/CollisionSystem.cpp | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 0b9ea61..0bceac7 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -319,11 +319,14 @@ vec2 CollisionSystem::get_box_circle_detection(const BoxColliderInternal & box, = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y); vec2 collision_normal = closest_delta / distance; - // Compute the resolution vector - return vec2{collision_normal * penetration_depth}; - } - // No collision - return vec2{NAN, NAN};; + // Compute penetration depth + float penetration_depth = scaled_circle_radius - distance; + + // Compute the resolution vector + return vec2{collision_normal * penetration_depth}; + } + // No collision + return vec2{NAN, NAN}; } vec2 CollisionSystem::get_circle_circle_detection( -- cgit v1.2.3 From 3894948275e10b6a0e3614ba0da90b9ea8d6cd4e Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Thu, 19 Dec 2024 20:27:39 +0100 Subject: make format --- src/crepe/api/Vector2.hpp | 2 +- src/crepe/system/CollisionSystem.cpp | 14 ++++++++------ 2 files changed, 9 insertions(+), 7 deletions(-) (limited to 'src/crepe') diff --git a/src/crepe/api/Vector2.hpp b/src/crepe/api/Vector2.hpp index a470595..e195760 100644 --- a/src/crepe/api/Vector2.hpp +++ b/src/crepe/api/Vector2.hpp @@ -165,7 +165,7 @@ Vector2 Vector2::perpendicular() const { template bool Vector2::is_nan() const { - return std::isnan(x) && std::isnan(y); + return std::isnan(x) && std::isnan(y); } } // namespace crepe diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp index 0bceac7..e4396b9 100644 --- a/src/crepe/system/CollisionSystem.cpp +++ b/src/crepe/system/CollisionSystem.cpp @@ -168,7 +168,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionIntern // Get resolution vector from box-box collision detection resolution = this->get_box_box_detection(BOX1, BOX2); // If no collision (NaN values), return false - if(resolution.is_nan()) return false; + if (resolution.is_nan()) return false; break; } case CollisionInternalType::BOX_CIRCLE: { @@ -184,7 +184,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionIntern // Get resolution vector from box-circle collision detection resolution = this->get_box_circle_detection(BOX1, CIRCLE2); // If no collision (NaN values), return false - if(resolution.is_nan()) return false; + if (resolution.is_nan()) return false; // Invert the resolution vector for proper collision response resolution = -resolution; break; @@ -202,7 +202,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionIntern // Get resolution vector from circle-circle collision detection resolution = this->get_circle_circle_detection(CIRCLE1, CIRCLE2); // If no collision (NaN values), return false - if(resolution.is_nan()) return false; + if (resolution.is_nan()) return false; break; } case CollisionInternalType::CIRCLE_BOX: { @@ -218,7 +218,7 @@ bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionIntern // Get resolution vector from box-circle collision detection (order swapped) resolution = this->get_box_circle_detection(BOX2, CIRCLE1); // If no collision (NaN values), return false - if(resolution.is_nan()) return false; + if (resolution.is_nan()) return false; break; } case CollisionInternalType::NONE: @@ -239,7 +239,8 @@ bool CollisionSystem::detect_collision(CollisionInternal & self, CollisionIntern return true; } -vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, const BoxColliderInternal & box2) const { +vec2 CollisionSystem::get_box_box_detection(const BoxColliderInternal & box1, + const BoxColliderInternal & box2) const { vec2 resolution{NAN, NAN}; // Get current positions of colliders vec2 pos1 = AbsolutePosition::get_position(box1.transform, box1.collider.offset); @@ -370,7 +371,8 @@ vec2 CollisionSystem::get_circle_circle_detection( return resolution; } // No collision - return vec2{NAN, NAN};; + return vec2{NAN, NAN}; + ; } CollisionSystem::Direction -- cgit v1.2.3