godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added to kinematicbody2d the copy and paste of the API friendler of KinematicBody

This commit is contained in:
Aron de Castro 2017-09-10 13:07:47 -03:00
parent d1cb73b47a
commit 6e0892f223
4 changed files with 172 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
scene/2d/physics_body_2d.cpp
View File

@ -955,35 +955,25 @@ RigidBody2D::~RigidBody2D() {
////////////////////////// //////////////////////////
Dictionary KinematicBody2D::_move(const Vector2 &p_motion) { Ref<KinematicCollision2D> KinematicBody2D::_move(const Vector2 &p_motion) {
Collision col; Collision col;
if (move(p_motion, col)) {
Dictionary d; if (move_and_collide(p_motion, col)) {
d["position"] = col.collision; if (motion_cache.is_null()) {
d["normal"] = col.normal; motion_cache.instance();
d["local_shape"] = col.local_shape; motion_cache->owner = this;
d["travel"] = col.travel;
d["remainder"] = col.remainder;
d["collider_id"] = col.collider;
d["collider_velocity"] = col.collider_vel;
if (col.collider) {
d["collider"] = ObjectDB::get_instance(col.collider);
} else {
d["collider"] = Variant();
} }
d["collider_shape_index"] = col.collider_shape; motion_cache->collision = col;
d["collider_metadata"] = col.collider_metadata;
return d; return motion_cache;
} else {
return Dictionary();
} }
return Ref<KinematicCollision2D>();
} }
bool KinematicBody2D::move(const Vector2 &p_motion, Collision &r_collision) { bool KinematicBody2D::move_and_collide(const Vector2 &p_motion, Collision &r_collision) {
Transform2D gt = get_global_transform(); Transform2D gt = get_global_transform();
Physics2DServer::MotionResult result; Physics2DServer::MotionResult result;
@ -1007,7 +997,7 @@ bool KinematicBody2D::move(const Vector2 &p_motion, Collision &r_collision) {
return colliding; return colliding;
} }
Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction, float p_slope_stop_min_velocity, int p_max_bounces, float p_floor_max_angle) { Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction, float p_slope_stop_min_velocity, int p_max_slides, float p_floor_max_angle) {
Vector2 motion = (floor_velocity + p_linear_velocity) * get_fixed_process_delta_time(); Vector2 motion = (floor_velocity + p_linear_velocity) * get_fixed_process_delta_time();
Vector2 lv = p_linear_velocity; Vector2 lv = p_linear_velocity;
@ -1018,11 +1008,11 @@ Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const
colliders.clear(); colliders.clear();
floor_velocity = Vector2(); floor_velocity = Vector2();
while (p_max_bounces) { while (p_max_slides) {
Collision collision; Collision collision;
bool collided = move(motion, collision); bool collided = move_and_collide(motion, collision);
if (collided) { if (collided) {
@ -1060,7 +1050,7 @@ Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const
break; break;
} }
p_max_bounces--; p_max_slides--;
if (motion == Vector2()) if (motion == Vector2())
break; break;
} }
@ -1103,75 +1093,35 @@ float KinematicBody2D::get_safe_margin() const {
return margin; return margin;
} }
int KinematicBody2D::get_collision_count() const { int KinematicBody2D::get_slide_count() const {
return colliders.size(); return colliders.size();
} }
Vector2 KinematicBody2D::get_collision_position(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Vector2()); KinematicBody2D::Collision KinematicBody2D::get_slide_collision(int p_bounce) const {
ERR_FAIL_INDEX_V(p_bounce, colliders.size(), Collision());
return colliders[p_collision].collision; return colliders[p_bounce];
}
Vector2 KinematicBody2D::get_collision_normal(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Vector2());
return colliders[p_collision].normal;
} }
Vector2 KinematicBody2D::get_collision_travel(int p_collision) const { Ref<KinematicCollision2D> KinematicBody2D::_get_slide_collision(int p_bounce) {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Vector2());
return colliders[p_collision].travel;
}
Vector2 KinematicBody2D::get_collision_remainder(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Vector2());
return colliders[p_collision].remainder;
}
Object *KinematicBody2D::get_collision_local_shape(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), NULL);
uint32_t owner = shape_find_owner(colliders[p_collision].local_shape);
return shape_owner_get_owner(owner);
}
Object *KinematicBody2D::get_collision_collider(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), NULL);
if (colliders[p_collision].collider) { ERR_FAIL_INDEX_V(p_bounce, colliders.size(), Ref<KinematicCollision2D>());
return ObjectDB::get_instance(colliders[p_collision].collider); if (p_bounce >= slide_colliders.size()) {
slide_colliders.resize(p_bounce + 1);
} }
return NULL; if (slide_colliders[p_bounce].is_null()) {
} slide_colliders[p_bounce].instance();
ObjectID KinematicBody2D::get_collision_collider_id(int p_collision) const { slide_colliders[p_bounce]->owner = this;
ERR_FAIL_INDEX_V(p_collision, colliders.size(), 0);
return colliders[p_collision].collider;
}
Object *KinematicBody2D::get_collision_collider_shape(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), NULL);
Object *collider = get_collision_collider(p_collision);
CollisionObject2D *obj2d = Object::cast_to<CollisionObject2D>(collider);
if (obj2d) {
uint32_t owner = shape_find_owner(colliders[p_collision].collider_shape);
return obj2d->shape_owner_get_owner(owner);
} }
return NULL; slide_colliders[p_bounce]->collision = colliders[p_bounce];
} return slide_colliders[p_bounce];
int KinematicBody2D::get_collision_collider_shape_index(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), -1);
return colliders[p_collision].collider_shape;
}
Vector2 KinematicBody2D::get_collision_collider_velocity(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Vector2());
return colliders[p_collision].collider_vel;
}
Variant KinematicBody2D::get_collision_collider_metadata(int p_collision) const {
ERR_FAIL_INDEX_V(p_collision, colliders.size(), Variant());
return colliders[p_collision].collider_metadata;
} }
void KinematicBody2D::_bind_methods() { void KinematicBody2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("move", "rel_vec"), &KinematicBody2D::_move); ClassDB::bind_method(D_METHOD("move_and_collide", "rel_vec"), &KinematicBody2D::_move);
ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "floor_normal", "slope_stop_min_velocity", "max_bounces", "floor_max_angle"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(5), DEFVAL(4), DEFVAL(Math::deg2rad((float)45))); ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "floor_normal", "slope_stop_min_velocity", "max_bounces", "floor_max_angle"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(5), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)));
ClassDB::bind_method(D_METHOD("test_move", "from", "rel_vec"), &KinematicBody2D::test_move); ClassDB::bind_method(D_METHOD("test_move", "from", "rel_vec"), &KinematicBody2D::test_move);
@ -1184,18 +1134,8 @@ void KinematicBody2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_safe_margin", "pixels"), &KinematicBody2D::set_safe_margin); ClassDB::bind_method(D_METHOD("set_safe_margin", "pixels"), &KinematicBody2D::set_safe_margin);
ClassDB::bind_method(D_METHOD("get_safe_margin"), &KinematicBody2D::get_safe_margin); ClassDB::bind_method(D_METHOD("get_safe_margin"), &KinematicBody2D::get_safe_margin);
ClassDB::bind_method(D_METHOD("get_collision_count"), &KinematicBody2D::get_collision_count); ClassDB::bind_method(D_METHOD("get_slide_count"), &KinematicBody2D::get_slide_count);
ClassDB::bind_method(D_METHOD("get_collision_position", "collision"), &KinematicBody2D::get_collision_position); ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &KinematicBody2D::_get_slide_collision);
ClassDB::bind_method(D_METHOD("get_collision_normal", "collision"), &KinematicBody2D::get_collision_normal);
ClassDB::bind_method(D_METHOD("get_collision_travel", "collision"), &KinematicBody2D::get_collision_travel);
ClassDB::bind_method(D_METHOD("get_collision_remainder", "collision"), &KinematicBody2D::get_collision_remainder);
ClassDB::bind_method(D_METHOD("get_collision_local_shape", "collision"), &KinematicBody2D::get_collision_local_shape);
ClassDB::bind_method(D_METHOD("get_collision_collider", "collision"), &KinematicBody2D::get_collision_collider);
ClassDB::bind_method(D_METHOD("get_collision_collider_id", "collision"), &KinematicBody2D::get_collision_collider_id);
ClassDB::bind_method(D_METHOD("get_collision_collider_shape", "collision"), &KinematicBody2D::get_collision_collider_shape);
ClassDB::bind_method(D_METHOD("get_collision_collider_shape_index", "collision"), &KinematicBody2D::get_collision_collider_shape_index);
ClassDB::bind_method(D_METHOD("get_collision_collider_velocity", "collision"), &KinematicBody2D::get_collision_collider_velocity);
ClassDB::bind_method(D_METHOD("get_collision_collider_metadata", "collision"), &KinematicBody2D::get_collision_collider_metadata);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin");
} }
@ -1210,4 +1150,106 @@ KinematicBody2D::KinematicBody2D()
on_wall = false; on_wall = false;
} }
KinematicBody2D::~KinematicBody2D() { KinematicBody2D::~KinematicBody2D() {
if (motion_cache.is_valid()) {
motion_cache->owner = NULL;
}
for (int i = 0; i < slide_colliders.size(); i++) {
if (slide_colliders[i].is_valid()) {
slide_colliders[i]->owner = NULL;
}
}
}
////////////////////////
Vector2 KinematicCollision2D::get_position() const {
return collision.collision;
}
Vector2 KinematicCollision2D::get_normal() const {
return collision.normal;
}
Vector2 KinematicCollision2D::get_travel() const {
return collision.travel;
}
Vector2 KinematicCollision2D::get_remainder() const {
return collision.remainder;
}
Object *KinematicCollision2D::get_local_shape() const {
ERR_FAIL_COND_V(!owner, NULL);
uint32_t ownerid = owner->shape_find_owner(collision.local_shape);
return owner->shape_owner_get_owner(ownerid);
}
Object *KinematicCollision2D::get_collider() const {
if (collision.collider) {
return ObjectDB::get_instance(collision.collider);
}
return NULL;
}
ObjectID KinematicCollision2D::get_collider_id() const {
return collision.collider;
}
Object *KinematicCollision2D::get_collider_shape() const {
Object *collider = get_collider();
if (collider) {
CollisionObject2D *obj2d = Object::cast_to<CollisionObject2D>(collider);
if (obj2d) {
uint32_t ownerid = obj2d->shape_find_owner(collision.collider_shape);
return obj2d->shape_owner_get_owner(ownerid);
}
}
return NULL;
}
int KinematicCollision2D::get_collider_shape_index() const {
return collision.collider_shape;
}
Vector2 KinematicCollision2D::get_collider_velocity() const {
return collision.collider_vel;
}
Variant KinematicCollision2D::get_collider_metadata() const {
return Variant();
}
void KinematicCollision2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_position"), &KinematicCollision2D::get_position);
ClassDB::bind_method(D_METHOD("get_normal"), &KinematicCollision2D::get_normal);
ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision2D::get_travel);
ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision2D::get_remainder);
ClassDB::bind_method(D_METHOD("get_local_shape"), &KinematicCollision2D::get_local_shape);
ClassDB::bind_method(D_METHOD("get_collider"), &KinematicCollision2D::get_collider);
ClassDB::bind_method(D_METHOD("get_collider_id"), &KinematicCollision2D::get_collider_id);
ClassDB::bind_method(D_METHOD("get_collider_shape"), &KinematicCollision2D::get_collider_shape);
ClassDB::bind_method(D_METHOD("get_collider_shape_index"), &KinematicCollision2D::get_collider_shape_index);
ClassDB::bind_method(D_METHOD("get_collider_velocity"), &KinematicCollision2D::get_collider_velocity);
ClassDB::bind_method(D_METHOD("get_collider_metadata"), &KinematicCollision2D::get_collider_metadata);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "", "get_position");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "normal"), "", "get_normal");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "travel"), "", "get_travel");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "remainder"), "", "get_remainder");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "local_shape"), "", "get_local_shape");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "collider"), "", "get_collider");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collider_id"), "", "get_collider_id");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "collider_shape"), "", "get_collider_shape");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collider_shape_index"), "", "get_collider_shape_index");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "collider_velocity"), "", "get_collider_velocity");
ADD_PROPERTY(PropertyInfo(Variant::NIL, "collider_metadata", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT), "", "get_collider_metadata");
}
KinematicCollision2D::KinematicCollision2D() {
collision.collider = 0;
collision.collider_shape = 0;
collision.local_shape = 0;
owner = NULL;
} }

52
scene/2d/physics_body_2d.h
View File

@ -34,6 +34,8 @@
#include "servers/physics_2d_server.h" #include "servers/physics_2d_server.h"
#include "vset.h" #include "vset.h"
class KinematicCollision2D;
class PhysicsBody2D : public CollisionObject2D { class PhysicsBody2D : public CollisionObject2D {
GDCLASS(PhysicsBody2D, CollisionObject2D); GDCLASS(PhysicsBody2D, CollisionObject2D);
@ -288,42 +290,62 @@ private:
bool on_ceiling; bool on_ceiling;
bool on_wall; bool on_wall;
Vector<Collision> colliders; Vector<Collision> colliders;
Vector<Ref<KinematicCollision2D> > slide_colliders;
Ref<KinematicCollision2D> motion_cache;
_FORCE_INLINE_ bool _ignores_mode(Physics2DServer::BodyMode) const; _FORCE_INLINE_ bool _ignores_mode(Physics2DServer::BodyMode) const;
Dictionary _move(const Vector2 &p_motion); Ref<KinematicCollision2D> _move(const Vector2 &p_motion);
Ref<KinematicCollision2D> _get_slide_collision(int p_bounce);
protected: protected:
static void _bind_methods(); static void _bind_methods();
public: public:
bool move(const Vector2 &p_motion, Collision &r_collision); bool move_and_collide(const Vector2 &p_motion, Collision &r_collision);
bool test_move(const Transform2D &p_from, const Vector2 &p_motion); bool test_move(const Transform2D &p_from, const Vector2 &p_motion);
void set_safe_margin(float p_margin); void set_safe_margin(float p_margin);
float get_safe_margin() const; float get_safe_margin() const;
Vector2 move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction = Vector2(0, 0), float p_slope_stop_min_velocity = 5, int p_max_bounces = 4, float p_floor_max_angle = Math::deg2rad((float)45)); Vector2 move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction = Vector2(0, 0), float p_slope_stop_min_velocity = 5, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45));
bool is_on_floor() const; bool is_on_floor() const;
bool is_on_wall() const; bool is_on_wall() const;
bool is_on_ceiling() const; bool is_on_ceiling() const;
Vector2 get_floor_velocity() const; Vector2 get_floor_velocity() const;
int get_collision_count() const; int get_slide_count() const;
Vector2 get_collision_position(int p_collision) const; Collision get_slide_collision(int p_bounce) const;
Vector2 get_collision_normal(int p_collision) const;
Vector2 get_collision_travel(int p_collision) const;
Vector2 get_collision_remainder(int p_collision) const;
Object *get_collision_local_shape(int p_collision) const;
Object *get_collision_collider(int p_collision) const;
ObjectID get_collision_collider_id(int p_collision) const;
Object *get_collision_collider_shape(int p_collision) const;
int get_collision_collider_shape_index(int p_collision) const;
Vector2 get_collision_collider_velocity(int p_collision) const;
Variant get_collision_collider_metadata(int p_collision) const;
KinematicBody2D(); KinematicBody2D();
~KinematicBody2D(); ~KinematicBody2D();
}; };
class KinematicCollision2D : public Reference {
GDCLASS(KinematicCollision2D, Reference);
KinematicBody2D *owner;
friend class KinematicBody2D;
KinematicBody2D::Collision collision;
protected:
static void _bind_methods();
public:
Vector2 get_position() const;
Vector2 get_normal() const;
Vector2 get_travel() const;
Vector2 get_remainder() const;
Object *get_local_shape() const;
Object *get_collider() const;
ObjectID get_collider_id() const;
Object *get_collider_shape() const;
int get_collider_shape_index() const;
Vector2 get_collider_velocity() const;
Variant get_collider_metadata() const;
KinematicCollision2D();
};
#endif // PHYSICS_BODY_2D_H #endif // PHYSICS_BODY_2D_H

2
scene/3d/physics_body.cpp
View File

@ -1061,7 +1061,7 @@ KinematicBody::Collision KinematicBody::get_slide_collision(int p_bounce) const
Ref<KinematicCollision> KinematicBody::_get_slide_collision(int p_bounce) { Ref<KinematicCollision> KinematicBody::_get_slide_collision(int p_bounce) {
ERR_FAIL_INDEX_V(p_bounce, colliders.size(), Ref<KinematicCollision>()); ERR_FAIL_INDEX_V(p_bounce, colliders.size(), Ref<KinematicCollision>());
if (p_bounce > slide_colliders.size()) { if (p_bounce >= slide_colliders.size()) {
slide_colliders.resize(p_bounce + 1); slide_colliders.resize(p_bounce + 1);
} }

1
scene/register_scene_types.cpp
View File

@ -430,6 +430,7 @@ void register_scene_types() {
ClassDB::register_class<StaticBody2D>(); ClassDB::register_class<StaticBody2D>();
ClassDB::register_class<RigidBody2D>(); ClassDB::register_class<RigidBody2D>();
ClassDB::register_class<KinematicBody2D>(); ClassDB::register_class<KinematicBody2D>();
ClassDB::register_class<KinematicCollision2D>();
ClassDB::register_class<Area2D>(); ClassDB::register_class<Area2D>();
ClassDB::register_class<CollisionShape2D>(); ClassDB::register_class<CollisionShape2D>();
ClassDB::register_class<CollisionPolygon2D>(); ClassDB::register_class<CollisionPolygon2D>();