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

Initialize variables in servers/physics

This commit is contained in:
qarmin 2021-09-14 11:01:49 +02:00 committed by Rafał Mikrut
parent 7b21b1bb60
commit 91257c3900
53 changed files with 362 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
servers/physics_2d/area_2d_sw.cpp
View File

@ -299,17 +299,6 @@ Area2DSW::Area2DSW() :
monitor_query_list(this),
moved_list(this) {
_set_static(true); //areas are not active by default
space_override_mode = PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED;
gravity = 9.80665;
gravity_vector = Vector2(0, -1);
gravity_is_point = false;
gravity_distance_scale = 0;
point_attenuation = 1;
angular_damp = 1.0;
linear_damp = 0.1;
priority = 0;
monitorable = false;
}
Area2DSW::~Area2DSW() {

27
servers/physics_2d/area_2d_sw.h
View File

@ -40,16 +40,16 @@ class Body2DSW;
class Constraint2DSW;
class Area2DSW : public CollisionObject2DSW {
PhysicsServer2D::AreaSpaceOverrideMode space_override_mode;
real_t gravity;
Vector2 gravity_vector;
bool gravity_is_point;
real_t gravity_distance_scale;
real_t point_attenuation;
real_t linear_damp;
real_t angular_damp;
int priority;
bool monitorable;
PhysicsServer2D::AreaSpaceOverrideMode space_override_mode = PhysicsServer2D::AREA_SPACE_OVERRIDE_DISABLED;
real_t gravity = 9.80665;
Vector2 gravity_vector = Vector2(0, -1);
bool gravity_is_point = false;
real_t gravity_distance_scale = 0.0;
real_t point_attenuation = 1.0;
real_t linear_damp = 0.1;
real_t angular_damp = 1.0;
int priority = 0;
bool monitorable = false;
ObjectID monitor_callback_id;
StringName monitor_callback_method;
@ -63,8 +63,8 @@ class Area2DSW : public CollisionObject2DSW {
struct BodyKey {
RID rid;
ObjectID instance_id;
uint32_t body_shape;
uint32_t area_shape;
uint32_t body_shape = 0;
uint32_t area_shape = 0;
_FORCE_INLINE_ bool operator<(const BodyKey &p_key) const {
if (rid == p_key.rid) {
@ -84,10 +84,9 @@ class Area2DSW : public CollisionObject2DSW {
};
struct BodyState {
int state;
int state = 0;
_FORCE_INLINE_ void inc() { state++; }
_FORCE_INLINE_ void dec() { state--; }
_FORCE_INLINE_ BodyState() { state = 0; }
};
Map<BodyKey, BodyState> monitored_bodies;

10
servers/physics_2d/body_2d_sw.h
View File

@ -96,8 +96,8 @@ class Body2DSW : public CollisionObject2DSW {
List<Pair<Constraint2DSW *, int>> constraint_list;
struct AreaCMP {
Area2DSW *area;
int refCount;
Area2DSW *area = nullptr;
int refCount = 0;
_FORCE_INLINE_ bool operator==(const AreaCMP &p_cmp) const { return area->get_self() == p_cmp.area->get_self(); }
_FORCE_INLINE_ bool operator<(const AreaCMP &p_cmp) const { return area->get_priority() < p_cmp.area->get_priority(); }
_FORCE_INLINE_ AreaCMP() {}
@ -112,10 +112,10 @@ class Body2DSW : public CollisionObject2DSW {
struct Contact {
Vector2 local_pos;
Vector2 local_normal;
real_t depth;
int local_shape;
real_t depth = 0.0;
int local_shape = 0;
Vector2 collider_pos;
int collider_shape;
int collider_shape = 0;
ObjectID collider_instance_id;
RID collider;
Vector2 collider_velocity_at_pos;

18
servers/physics_2d/body_pair_2d_sw.h
View File

@ -59,17 +59,17 @@ class BodyPair2DSW : public Constraint2DSW {
Vector2 position;
Vector2 normal;
Vector2 local_A, local_B;
real_t acc_normal_impulse; // accumulated normal impulse (Pn)
real_t acc_tangent_impulse; // accumulated tangent impulse (Pt)
real_t acc_bias_impulse; // accumulated normal impulse for position bias (Pnb)
real_t mass_normal, mass_tangent;
real_t bias;
real_t acc_normal_impulse = 0.0; // accumulated normal impulse (Pn)
real_t acc_tangent_impulse = 0.0; // accumulated tangent impulse (Pt)
real_t acc_bias_impulse = 0.0; // accumulated normal impulse for position bias (Pnb)
real_t mass_normal, mass_tangent = 0.0;
real_t bias = 0.0;
real_t depth;
bool active;
real_t depth = 0.0;
bool active = false;
Vector2 rA, rB;
bool reused;
real_t bounce;
bool reused = false;
real_t bounce = 0.0;
};
Vector2 offset_B; //use local A coordinates to avoid numerical issues on collision detection

3
servers/physics_2d/broad_phase_2d_bvh.cpp
View File

@ -110,7 +110,4 @@ BroadPhase2DSW *BroadPhase2DBVH::_create() {
BroadPhase2DBVH::BroadPhase2DBVH() {
bvh.set_pair_callback(_pair_callback, this);
bvh.set_unpair_callback(_unpair_callback, this);
pair_callback = nullptr;
pair_userdata = nullptr;
unpair_userdata = nullptr;
}

8
servers/physics_2d/broad_phase_2d_bvh.h
View File

@ -42,10 +42,10 @@ class BroadPhase2DBVH : public BroadPhase2DSW {
static void *_pair_callback(void *, uint32_t, CollisionObject2DSW *, int, uint32_t, CollisionObject2DSW *, int);
static void _unpair_callback(void *, uint32_t, CollisionObject2DSW *, int, uint32_t, CollisionObject2DSW *, int, void *);
PairCallback pair_callback;
void *pair_userdata;
UnpairCallback unpair_callback;
void *unpair_userdata;
PairCallback pair_callback = nullptr;
void *pair_userdata = nullptr;
UnpairCallback unpair_callback = nullptr;
void *unpair_userdata = nullptr;
public:
// 0 is an invalid ID

5
servers/physics_2d/collision_object_2d_sw.cpp
View File

@ -244,10 +244,5 @@ void CollisionObject2DSW::_shape_changed() {
CollisionObject2DSW::CollisionObject2DSW(Type p_type) :
pending_shape_update_list(this) {
_static = true;
type = p_type;
space = nullptr;
collision_mask = 1;
collision_layer = 1;
pickable = true;
}

25
servers/physics_2d/collision_object_2d_sw.h
View File

@ -50,32 +50,27 @@ private:
RID self;
ObjectID instance_id;
ObjectID canvas_instance_id;
bool pickable;
bool pickable = true;
struct Shape {
Transform2D xform;
Transform2D xform_inv;
BroadPhase2DSW::ID bpid;
BroadPhase2DSW::ID bpid = 0;
Rect2 aabb_cache; //for rayqueries
Shape2DSW *shape;
Shape2DSW *shape = nullptr;
Variant metadata;
bool disabled;
bool one_way_collision;
real_t one_way_collision_margin;
Shape() {
disabled = false;
one_way_collision = false;
one_way_collision_margin = 0;
}
bool disabled = false;
bool one_way_collision = false;
real_t one_way_collision_margin = 0.0;
};
Vector<Shape> shapes;
Space2DSW *space;
Space2DSW *space = nullptr;
Transform2D transform;
Transform2D inv_transform;
uint32_t collision_mask;
uint32_t collision_layer;
bool _static;
uint32_t collision_mask = 1;
uint32_t collision_layer = 1;
bool _static = true;
SelfList<CollisionObject2DSW> pending_shape_update_list;

48
servers/physics_2d/collision_solver_2d_sat.cpp
View File

@ -34,11 +34,11 @@
struct _CollectorCallback2D {
CollisionSolver2DSW::CallbackResult callback;
void *userdata;
bool swap;
bool collided;
void *userdata = nullptr;
bool swap = false;
bool collided = false;
Vector2 normal;
Vector2 *sep_axis;
Vector2 *sep_axis = nullptr;
_FORCE_INLINE_ void call(const Vector2 &p_point_A, const Vector2 &p_point_B) {
/*
@ -75,9 +75,9 @@ _FORCE_INLINE_ static void _generate_contacts_point_edge(const Vector2 *p_points
}
struct _generate_contacts_Pair {
bool a;
int idx;
real_t d;
bool a = false;
int idx = 0;
real_t d = 0.0;
_FORCE_INLINE_ bool operator<(const _generate_contacts_Pair &l) const { return d < l.d; }
};
@ -146,10 +146,10 @@ static void _generate_contacts_from_supports(const Vector2 *p_points_A, int p_po
}
};
int pointcount_B;
int pointcount_A;
const Vector2 *points_A;
const Vector2 *points_B;
int pointcount_B = 0;
int pointcount_A = 0;
const Vector2 *points_A = nullptr;
const Vector2 *points_B = nullptr;
if (p_point_count_A > p_point_count_B) {
//swap
@ -177,18 +177,20 @@ static void _generate_contacts_from_supports(const Vector2 *p_points_A, int p_po
template <class ShapeA, class ShapeB, bool castA = false, bool castB = false, bool withMargin = false>
class SeparatorAxisTest2D {
const ShapeA *shape_A;
const ShapeB *shape_B;
const Transform2D *transform_A;
const Transform2D *transform_B;
real_t best_depth;
const ShapeA *shape_A = nullptr;
const ShapeB *shape_B = nullptr;
const Transform2D *transform_A = nullptr;
const Transform2D *transform_B = nullptr;
real_t best_depth = 1e15;
Vector2 best_axis;
int best_axis_count;
int best_axis_index;
#ifdef DEBUG_ENABLED
int best_axis_count = 0;
int best_axis_index = -1;
#endif
Vector2 motion_A;
Vector2 motion_B;
real_t margin_A;
real_t margin_B;
real_t margin_A = 0.0;
real_t margin_B = 0.0;
_CollectorCallback2D *callback;
public:
@ -364,19 +366,13 @@ public:
_FORCE_INLINE_ SeparatorAxisTest2D(const ShapeA *p_shape_A, const Transform2D &p_transform_a, const ShapeB *p_shape_B, const Transform2D &p_transform_b, _CollectorCallback2D *p_collector, const Vector2 &p_motion_A = Vector2(), const Vector2 &p_motion_B = Vector2(), real_t p_margin_A = 0, real_t p_margin_B = 0) {
margin_A = p_margin_A;
margin_B = p_margin_B;
best_depth = 1e15;
shape_A = p_shape_A;
shape_B = p_shape_B;
transform_A = &p_transform_a;
transform_B = &p_transform_b;
motion_A = p_motion_A;
motion_B = p_motion_B;
callback = p_collector;
#ifdef DEBUG_ENABLED
best_axis_count = 0;
best_axis_index = -1;
#endif
}
};

22
servers/physics_2d/collision_solver_2d_sw.cpp
View File

@ -133,20 +133,20 @@ bool CollisionSolver2DSW::solve_separation_ray(const Shape2DSW *p_shape_A, const
}
struct _ConcaveCollisionInfo2D {
const Transform2D *transform_A;
const Shape2DSW *shape_A;
const Transform2D *transform_B;
const Transform2D *transform_A = nullptr;
const Shape2DSW *shape_A = nullptr;
const Transform2D *transform_B = nullptr;
Vector2 motion_A;
Vector2 motion_B;
real_t margin_A;
real_t margin_B;
real_t margin_A = 0.0;
real_t margin_B = 0.0;
CollisionSolver2DSW::CallbackResult result_callback;
void *userdata;
bool swap_result;
bool collided;
int aabb_tests;
int collisions;
Vector2 *sep_axis;
void *userdata = nullptr;
bool swap_result = false;
bool collided = false;
int aabb_tests = 0;
int collisions = 0;
Vector2 *sep_axis = nullptr;
};
bool CollisionSolver2DSW::concave_callback(void *p_userdata, Shape2DSW *p_convex) {

6
servers/physics_2d/constraint_2d_sw.h
View File

@ -36,8 +36,8 @@
class Constraint2DSW {
Body2DSW **_body_ptr;
int _body_count;
uint64_t island_step;
bool disabled_collisions_between_bodies;
uint64_t island_step = 0;
bool disabled_collisions_between_bodies = true;
RID self;
@ -45,8 +45,6 @@ protected:
Constraint2DSW(Body2DSW **p_body_ptr = nullptr, int p_body_count = 0) {
_body_ptr = p_body_ptr;
_body_count = p_body_count;
island_step = 0;
disabled_collisions_between_bodies = true;
}
public:

6
servers/physics_2d/joints_2d_sw.cpp
View File

@ -64,7 +64,7 @@ void Joint2DSW::copy_settings_from(Joint2DSW *p_joint) {
}
static inline real_t k_scalar(Body2DSW *a, Body2DSW *b, const Vector2 &rA, const Vector2 &rB, const Vector2 &n) {
real_t value = 0;
real_t value = 0.0;
{
value += a->get_inv_mass();
@ -213,8 +213,6 @@ PinJoint2DSW::PinJoint2DSW(const Vector2 &p_pos, Body2DSW *p_body_a, Body2DSW *p
anchor_A = p_body_a->get_inv_transform().xform(p_pos);
anchor_B = p_body_b ? p_body_b->get_inv_transform().xform(p_pos) : p_pos;
softness = 0;
p_body_a->add_constraint(this, 0);
if (p_body_b) {
p_body_b->add_constraint(this, 1);
@ -482,8 +480,6 @@ DampedSpringJoint2DSW::DampedSpringJoint2DSW(const Vector2 &p_anchor_a, const Ve
anchor_B = B->get_inv_transform().xform(p_anchor_b);
rest_length = p_anchor_a.distance_to(p_anchor_b);
stiffness = 20;
damping = 1.5;
A->add_constraint(this, 0);
B->add_constraint(this, 1);

37
servers/physics_2d/joints_2d_sw.h
View File

@ -35,9 +35,9 @@
#include "constraint_2d_sw.h"
class Joint2DSW : public Constraint2DSW {
real_t max_force;
real_t bias;
real_t max_bias;
real_t bias = 0;
real_t max_bias = 3.40282e+38;
real_t max_force = 3.40282e+38;
protected:
bool dynamic_A = false;
@ -61,10 +61,7 @@ public:
virtual PhysicsServer2D::JointType get_type() const { return PhysicsServer2D::JOINT_TYPE_MAX; }
Joint2DSW(Body2DSW **p_body_ptr = nullptr, int p_body_count = 0) :
Constraint2DSW(p_body_ptr, p_body_count) {
bias = 0;
max_force = max_bias = 3.40282e+38;
};
Constraint2DSW(p_body_ptr, p_body_count) {}
virtual ~Joint2DSW() {
for (int i = 0; i < get_body_count(); i++) {
@ -83,7 +80,7 @@ class PinJoint2DSW : public Joint2DSW {
Body2DSW *B;
};
Body2DSW *_arr[2];
Body2DSW *_arr[2] = { nullptr, nullptr };
};
Transform2D M;
@ -92,7 +89,7 @@ class PinJoint2DSW : public Joint2DSW {
Vector2 anchor_B;
Vector2 bias;
Vector2 P;
real_t softness;
real_t softness = 0.0;
public:
virtual PhysicsServer2D::JointType get_type() const override { return PhysicsServer2D::JOINT_TYPE_PIN; }
@ -114,7 +111,7 @@ class GrooveJoint2DSW : public Joint2DSW {
Body2DSW *B;
};
Body2DSW *_arr[2];
Body2DSW *_arr[2] = { nullptr, nullptr };
};
Vector2 A_groove_1;
@ -123,13 +120,13 @@ class GrooveJoint2DSW : public Joint2DSW {
Vector2 B_anchor;
Vector2 jn_acc;
Vector2 gbias;
real_t jn_max;
real_t clamp;
real_t jn_max = 0.0;
real_t clamp = 0.0;
Vector2 xf_normal;
Vector2 rA, rB;
Vector2 k1, k2;
bool correct;
bool correct = false;
public:
virtual PhysicsServer2D::JointType get_type() const override { return PhysicsServer2D::JOINT_TYPE_GROOVE; }
@ -148,22 +145,22 @@ class DampedSpringJoint2DSW : public Joint2DSW {
Body2DSW *B;
};
Body2DSW *_arr[2];
Body2DSW *_arr[2] = { nullptr, nullptr };
};
Vector2 anchor_A;
Vector2 anchor_B;
real_t rest_length;
real_t damping;
real_t stiffness;
real_t rest_length = 0.0;
real_t damping = 1.5;
real_t stiffness = 20.0;
Vector2 rA, rB;
Vector2 n;
Vector2 j;
real_t n_mass;
real_t target_vrn;
real_t v_coef;
real_t n_mass = 0.0;
real_t target_vrn = 0.0;
real_t v_coef = 0.0;
public:
virtual PhysicsServer2D::JointType get_type() const override { return PhysicsServer2D::JOINT_TYPE_DAMPED_SPRING; }

5
servers/physics_2d/physics_server_2d_sw.cpp
View File

@ -1357,10 +1357,5 @@ PhysicsServer2DSW::PhysicsServer2DSW(bool p_using_threads) {
singletonsw = this;
BroadPhase2DSW::create_func = BroadPhase2DBVH::_create;
active = true;
island_count = 0;
active_objects = 0;
collision_pairs = 0;
using_threads = p_using_threads;
flushing_queries = false;
};

30
servers/physics_2d/physics_server_2d_sw.h
View File

@ -43,19 +43,19 @@ class PhysicsServer2DSW : public PhysicsServer2D {
friend class PhysicsDirectSpaceState2DSW;
friend class PhysicsDirectBodyState2DSW;
bool active;
int iterations;
bool doing_sync;
bool active = true;
int iterations = 0;
bool doing_sync = false;
int island_count;
int active_objects;
int collision_pairs;
int island_count = 0;
int active_objects = 0;
int collision_pairs = 0;
bool using_threads;
bool using_threads = false;
bool flushing_queries;
bool flushing_queries = false;
Step2DSW *stepper;
Step2DSW *stepper = nullptr;
Set<const Space2DSW *> active_spaces;
mutable RID_PtrOwner<Shape2DSW, true> shape_owner;
@ -76,12 +76,12 @@ class PhysicsServer2DSW : public PhysicsServer2D {
public:
struct CollCbkData {
Vector2 valid_dir;
real_t valid_depth;
int max;
int amount;
int passed;
int invalid_by_dir;
Vector2 *ptr;
real_t valid_depth = 0.0;
int max = 0;
int amount = 0;
int passed = 0;
int invalid_by_dir = 0;
Vector2 *ptr = nullptr;
};
virtual RID world_margin_shape_create() override;

2
servers/physics_2d/physics_server_2d_wrap_mt.cpp
View File

@ -119,7 +119,6 @@ PhysicsServer2DWrapMT::PhysicsServer2DWrapMT(PhysicsServer2D *p_contained, bool
command_queue(p_create_thread) {
physics_2d_server = p_contained;
create_thread = p_create_thread;
step_pending = 0;
pool_max_size = GLOBAL_GET("memory/limits/multithreaded_server/rid_pool_prealloc");
@ -130,7 +129,6 @@ PhysicsServer2DWrapMT::PhysicsServer2DWrapMT(PhysicsServer2D *p_contained, bool
}
main_thread = Thread::get_caller_id();
first_frame = true;
}
PhysicsServer2DWrapMT::~PhysicsServer2DWrapMT() {

8
servers/physics_2d/physics_server_2d_wrap_mt.h
View File

@ -56,19 +56,19 @@ class PhysicsServer2DWrapMT : public PhysicsServer2D {
SafeFlag exit;
Thread thread;
SafeFlag step_thread_up;
bool create_thread;
bool create_thread = false;
Semaphore step_sem;
int step_pending;
int step_pending = 0;
void thread_step(real_t p_delta);
void thread_flush();
void thread_exit();
bool first_frame;
bool first_frame = true;
Mutex alloc_mutex;
int pool_max_size;
int pool_max_size = 0;
public:
#define ServerName PhysicsServer2D

10
servers/physics_2d/shape_2d_sw.cpp
View File

@ -75,11 +75,6 @@ const Map<ShapeOwner2DSW *, int> &Shape2DSW::get_owners() const {
return owners;
}
Shape2DSW::Shape2DSW() {
custom_bias = 0;
configured = false;
}
Shape2DSW::~Shape2DSW() {
ERR_FAIL_COND(owners.size());
}
@ -652,11 +647,6 @@ Variant ConvexPolygonShape2DSW::get_data() const {
return dvr;
}
ConvexPolygonShape2DSW::ConvexPolygonShape2DSW() {
points = nullptr;
point_count = 0;
}
ConvexPolygonShape2DSW::~ConvexPolygonShape2DSW() {
if (points) {
memdelete_arr(points);

29
servers/physics_2d/shape_2d_sw.h
View File

@ -47,8 +47,8 @@ public:
class Shape2DSW {
RID self;
Rect2 aabb;
bool configured;
real_t custom_bias;
bool configured = false;
real_t custom_bias = 0.0;
Map<ShapeOwner2DSW *, int> owners;
@ -121,8 +121,7 @@ public:
}
}
}
Shape2DSW();
Shape2DSW() {}
virtual ~Shape2DSW();
};
@ -144,7 +143,7 @@ public:
class WorldMarginShape2DSW : public Shape2DSW {
Vector2 normal;
real_t d;
real_t d = 0.0;
public:
_FORCE_INLINE_ Vector2 get_normal() const { return normal; }
@ -180,8 +179,8 @@ public:
};
class SeparationRayShape2DSW : public Shape2DSW {
real_t length;
bool slide_on_slope;
real_t length = 0.0;
bool slide_on_slope = false;
public:
_FORCE_INLINE_ real_t get_length() const { return length; }
@ -366,8 +365,8 @@ public:
};
class CapsuleShape2DSW : public Shape2DSW {
real_t radius;
real_t height;
real_t radius = 0.0;
real_t height = 0.0;
public:
_FORCE_INLINE_ const real_t &get_radius() const { return radius; }
@ -412,8 +411,8 @@ class ConvexPolygonShape2DSW : public Shape2DSW {
Vector2 normal; //normal to next segment
};
Point *points;
int point_count;
Point *points = nullptr;
int point_count = 0;
public:
_FORCE_INLINE_ int get_point_count() const { return point_count; }
@ -458,7 +457,7 @@ public:
DEFAULT_PROJECT_RANGE_CAST
ConvexPolygonShape2DSW();
ConvexPolygonShape2DSW() {}
~ConvexPolygonShape2DSW();
};
@ -474,7 +473,7 @@ public:
class ConcavePolygonShape2DSW : public ConcaveShape2DSW {
struct Segment {
int points[2];
int points[2] = {};
};
Vector<Segment> segments;
@ -482,11 +481,11 @@ class ConcavePolygonShape2DSW : public ConcaveShape2DSW {
struct BVH {
Rect2 aabb;
int left, right;
int left = 0, right = 0;
};
Vector<BVH> bvh;
int bvh_depth;
int bvh_depth = 0;
struct BVH_CompareX {
_FORCE_INLINE_ bool operator()(const BVH &a, const BVH &b) const {

40
servers/physics_2d/space_2d_sw.cpp
View File

@ -383,18 +383,18 @@ bool PhysicsDirectSpaceState2DSW::collide_shape(RID p_shape, const Transform2D &
}
struct _RestCallbackData2D {
const CollisionObject2DSW *object;
const CollisionObject2DSW *best_object;
int local_shape;
int best_local_shape;
int shape;
int best_shape;
const CollisionObject2DSW *object = nullptr;
const CollisionObject2DSW *best_object = nullptr;
int local_shape = 0;
int best_local_shape = 0;
int shape = 0;
int best_shape = 0;
Vector2 best_contact;
Vector2 best_normal;
real_t best_len;
real_t best_len = 0.0;
Vector2 valid_dir;
real_t valid_depth;
real_t min_allowed_depth;
real_t valid_depth = 0.0;
real_t min_allowed_depth = 0.0;
};
static void _rest_cbk_result(const Vector2 &p_point_A, const Vector2 &p_point_B, void *p_userdata) {
@ -492,10 +492,6 @@ bool PhysicsDirectSpaceState2DSW::rest_info(RID p_shape, const Transform2D &p_sh
return true;
}
PhysicsDirectSpaceState2DSW::PhysicsDirectSpaceState2DSW() {
space = nullptr;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
int Space2DSW::_cull_aabb_for_body(Body2DSW *p_body, const Rect2 &p_aabb) {
@ -1190,19 +1186,6 @@ PhysicsDirectSpaceState2DSW *Space2DSW::get_direct_state() {
}
Space2DSW::Space2DSW() {
collision_pairs = 0;
active_objects = 0;
island_count = 0;
contact_debug_count = 0;
locked = false;
contact_recycle_radius = 1.0;
contact_max_separation = 1.5;
contact_max_allowed_penetration = 0.3;
test_motion_min_contact_depth = 0.005;
constraint_bias = 0.2;
body_linear_velocity_sleep_threshold = GLOBAL_DEF("physics/2d/sleep_threshold_linear", 2.0);
body_angular_velocity_sleep_threshold = GLOBAL_DEF("physics/2d/sleep_threshold_angular", Math::deg2rad(8.0));
body_time_to_sleep = GLOBAL_DEF("physics/2d/time_before_sleep", 0.5);
@ -1211,14 +1194,9 @@ Space2DSW::Space2DSW() {
broadphase = BroadPhase2DSW::create_func();
broadphase->set_pair_callback(_broadphase_pair, this);
broadphase->set_unpair_callback(_broadphase_unpair, this);
area = nullptr;
direct_access = memnew(PhysicsDirectSpaceState2DSW);
direct_access->space = this;
for (int i = 0; i < ELAPSED_TIME_MAX; i++) {
elapsed_time[i] = 0;
}
}
Space2DSW::~Space2DSW() {

42
servers/physics_2d/space_2d_sw.h
View File

@ -47,7 +47,7 @@ class PhysicsDirectSpaceState2DSW : public PhysicsDirectSpaceState2D {
int _intersect_point_impl(const Vector2 &p_point, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, bool p_pick_point, bool p_filter_by_canvas = false, ObjectID p_canvas_instance_id = ObjectID());
public:
Space2DSW *space;
Space2DSW *space = nullptr;
virtual int intersect_point(const Vector2 &p_point, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = UINT32_MAX, bool p_collide_with_bodies = true, bool p_collide_with_areas = false, bool p_pick_point = false) override;
virtual int intersect_point_on_canvas(const Vector2 &p_point, ObjectID p_canvas_instance_id, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = UINT32_MAX, bool p_collide_with_bodies = true, bool p_collide_with_areas = false, bool p_pick_point = false) override;
@ -57,7 +57,7 @@ public:
virtual bool collide_shape(RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, real_t p_margin, Vector2 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = UINT32_MAX, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
virtual bool rest_info(RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = UINT32_MAX, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
PhysicsDirectSpaceState2DSW();
PhysicsDirectSpaceState2DSW() {}
};
class Space2DSW {
@ -74,14 +74,14 @@ public:
private:
struct ExcludedShapeSW {
Shape2DSW *local_shape;
const CollisionObject2DSW *against_object;
int against_shape_index;
Shape2DSW *local_shape = nullptr;
const CollisionObject2DSW *against_object = nullptr;
int against_shape_index = 0;
};
uint64_t elapsed_time[ELAPSED_TIME_MAX];
uint64_t elapsed_time[ELAPSED_TIME_MAX] = {};
PhysicsDirectSpaceState2DSW *direct_access;
PhysicsDirectSpaceState2DSW *direct_access = nullptr;
RID self;
BroadPhase2DSW *broadphase;
@ -96,13 +96,13 @@ private:
Set<CollisionObject2DSW *> objects;
Area2DSW *area;
Area2DSW *area = nullptr;
real_t contact_recycle_radius;
real_t contact_max_separation;
real_t contact_max_allowed_penetration;
real_t constraint_bias;
real_t test_motion_min_contact_depth;
real_t contact_recycle_radius = 1.0;
real_t contact_max_separation = 1.5;
real_t contact_max_allowed_penetration = 0.3;
real_t constraint_bias = 0.2;
real_t test_motion_min_contact_depth = 0.005;
enum {
INTERSECTION_QUERY_MAX = 2048
@ -111,22 +111,22 @@ private:
CollisionObject2DSW *intersection_query_results[INTERSECTION_QUERY_MAX];
int intersection_query_subindex_results[INTERSECTION_QUERY_MAX];
real_t body_linear_velocity_sleep_threshold;
real_t body_angular_velocity_sleep_threshold;
real_t body_time_to_sleep;
real_t body_linear_velocity_sleep_threshold = 0.0;
real_t body_angular_velocity_sleep_threshold = 0.0;
real_t body_time_to_sleep = 0.0;
bool locked;
bool locked = false;
real_t last_step = 0.001;
int island_count;
int active_objects;
int collision_pairs;
int island_count = 0;
int active_objects = 0;
int collision_pairs = 0;
int _cull_aabb_for_body(Body2DSW *p_body, const Rect2 &p_aabb);
Vector<Vector2> contact_debug;
int contact_debug_count;
int contact_debug_count = 0;
friend class PhysicsDirectSpaceState2DSW;

2
servers/physics_2d/step_2d_sw.cpp
View File

@ -296,8 +296,6 @@ void Step2DSW::step(Space2DSW *p_space, real_t p_delta, int p_iterations) {
}
Step2DSW::Step2DSW() {
_step = 1;
body_islands.reserve(BODY_ISLAND_COUNT_RESERVE);
constraint_islands.reserve(ISLAND_COUNT_RESERVE);
all_constraints.reserve(CONSTRAINT_COUNT_RESERVE);

2
servers/physics_2d/step_2d_sw.h
View File

@ -37,7 +37,7 @@
#include "core/templates/thread_work_pool.h"
class Step2DSW {
uint64_t _step;
uint64_t _step = 1;
int iterations = 0;
real_t delta = 0.0;

10
servers/physics_3d/area_3d_sw.cpp
View File

@ -329,17 +329,7 @@ Area3DSW::Area3DSW() :
monitor_query_list(this),
moved_list(this) {
_set_static(true); //areas are never active
space_override_mode = PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED;
gravity = 9.80665;
gravity_vector = Vector3(0, -1, 0);
gravity_is_point = false;
gravity_distance_scale = 0;
point_attenuation = 1;
angular_damp = 0.1;
linear_damp = 0.1;
priority = 0;
set_ray_pickable(false);
monitorable = false;
}
Area3DSW::~Area3DSW() {

31
servers/physics_3d/area_3d_sw.h
View File

@ -41,20 +41,20 @@ class SoftBody3DSW;
class Constraint3DSW;
class Area3DSW : public CollisionObject3DSW {
PhysicsServer3D::AreaSpaceOverrideMode space_override_mode;
real_t gravity;
Vector3 gravity_vector;
bool gravity_is_point;
real_t gravity_distance_scale;
real_t point_attenuation;
real_t linear_damp;
real_t angular_damp;
PhysicsServer3D::AreaSpaceOverrideMode space_override_mode = PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED;
real_t gravity = 9.80665;
Vector3 gravity_vector = Vector3(0, -1, 0);
bool gravity_is_point = false;
real_t gravity_distance_scale = 0.0;
real_t point_attenuation = 1.0;
real_t linear_damp = 0.1;
real_t angular_damp = 0.1;
real_t wind_force_magnitude = 0.0;
real_t wind_attenuation_factor = 0.0;
Vector3 wind_source;
Vector3 wind_direction;
int priority;
bool monitorable;
int priority = 0;
bool monitorable = false;
ObjectID monitor_callback_id;
StringName monitor_callback_method;
@ -68,8 +68,8 @@ class Area3DSW : public CollisionObject3DSW {
struct BodyKey {
RID rid;
ObjectID instance_id;
uint32_t body_shape;
uint32_t area_shape;
uint32_t body_shape = 0;
uint32_t area_shape = 0;
_FORCE_INLINE_ bool operator<(const BodyKey &p_key) const {
if (rid == p_key.rid) {
@ -90,10 +90,9 @@ class Area3DSW : public CollisionObject3DSW {
};
struct BodyState {
int state;
int state = 0;
_FORCE_INLINE_ void inc() { state++; }
_FORCE_INLINE_ void dec() { state--; }
_FORCE_INLINE_ BodyState() { state = 0; }
};
Map<BodyKey, BodyState> monitored_soft_bodies;
@ -232,8 +231,8 @@ void Area3DSW::remove_area_from_query(Area3DSW *p_area, uint32_t p_area_shape, u
}
struct AreaCMP {
Area3DSW *area;
int refCount;
Area3DSW *area = nullptr;
int refCount = 0;
_FORCE_INLINE_ bool operator==(const AreaCMP &p_cmp) const { return area->get_self() == p_cmp.area->get_self(); }
_FORCE_INLINE_ bool operator<(const AreaCMP &p_cmp) const { return area->get_priority() < p_cmp.area->get_priority(); }
_FORCE_INLINE_ AreaCMP() {}

6
servers/physics_3d/body_3d_sw.h
View File

@ -108,10 +108,10 @@ class Body3DSW : public CollisionObject3DSW {
struct Contact {
Vector3 local_pos;
Vector3 local_normal;
real_t depth;
int local_shape;
real_t depth = 0.0;
int local_shape = 0;
Vector3 collider_pos;
int collider_shape;
int collider_shape = 0;
ObjectID collider_instance_id;
RID collider;
Vector3 collider_velocity_at_pos;

18
servers/physics_3d/body_pair_3d_sw.h
View File

@ -41,18 +41,18 @@ protected:
struct Contact {
Vector3 position;
Vector3 normal;
int index_A, index_B;
int index_A = 0, index_B = 0;
Vector3 local_A, local_B;
real_t acc_normal_impulse; // accumulated normal impulse (Pn)
real_t acc_normal_impulse = 0.0; // accumulated normal impulse (Pn)
Vector3 acc_tangent_impulse; // accumulated tangent impulse (Pt)
real_t acc_bias_impulse; // accumulated normal impulse for position bias (Pnb)
real_t acc_bias_impulse_center_of_mass; // accumulated normal impulse for position bias applied to com
real_t mass_normal;
real_t bias;
real_t bounce;
real_t acc_bias_impulse = 0.0; // accumulated normal impulse for position bias (Pnb)
real_t acc_bias_impulse_center_of_mass = 0.0; // accumulated normal impulse for position bias applied to com
real_t mass_normal = 0.0;
real_t bias = 0.0;
real_t bounce = 0.0;
real_t depth;
bool active;
real_t depth = 0.0;
bool active = false;
Vector3 rA, rB; // Offset in world orientation with respect to center of mass
};

3
servers/physics_3d/broad_phase_3d_bvh.cpp
View File

@ -114,7 +114,4 @@ BroadPhase3DSW *BroadPhase3DBVH::_create() {
BroadPhase3DBVH::BroadPhase3DBVH() {
bvh.set_pair_callback(_pair_callback, this);
bvh.set_unpair_callback(_unpair_callback, this);
pair_callback = nullptr;
pair_userdata = nullptr;
unpair_userdata = nullptr;
}

8
servers/physics_3d/broad_phase_3d_bvh.h
View File

@ -40,10 +40,10 @@ class BroadPhase3DBVH : public BroadPhase3DSW {
static void *_pair_callback(void *, uint32_t, CollisionObject3DSW *, int, uint32_t, CollisionObject3DSW *, int);
static void _unpair_callback(void *, uint32_t, CollisionObject3DSW *, int, uint32_t, CollisionObject3DSW *, int, void *);
PairCallback pair_callback;
void *pair_userdata;
UnpairCallback unpair_callback;
void *unpair_userdata;
PairCallback pair_callback = nullptr;
void *pair_userdata = nullptr;
UnpairCallback unpair_callback = nullptr;
void *unpair_userdata = nullptr;
public:
// 0 is an invalid ID

6
servers/physics_3d/collision_object_3d_sw.cpp
View File

@ -236,11 +236,5 @@ void CollisionObject3DSW::_shape_changed() {
CollisionObject3DSW::CollisionObject3DSW(Type p_type) :
pending_shape_update_list(this) {
_static = true;
type = p_type;
space = nullptr;
collision_layer = 1;
collision_mask = 1;
ray_pickable = true;
}

18
servers/physics_3d/collision_object_3d_sw.h
View File

@ -56,26 +56,24 @@ private:
Type type;
RID self;
ObjectID instance_id;
uint32_t collision_layer;
uint32_t collision_mask;
uint32_t collision_layer = 1;
uint32_t collision_mask = 1;
struct Shape {
Transform3D xform;
Transform3D xform_inv;
BroadPhase3DSW::ID bpid;
AABB aabb_cache; //for rayqueries
real_t area_cache;
Shape3DSW *shape;
bool disabled;
Shape() { disabled = false; }
real_t area_cache = 0.0;
Shape3DSW *shape = nullptr;
bool disabled = false;
};
Vector<Shape> shapes;
Space3DSW *space;
Space3DSW *space = nullptr;
Transform3D transform;
Transform3D inv_transform;
bool _static;
bool _static = true;
SelfList<CollisionObject3DSW> pending_shape_update_list;
@ -102,7 +100,7 @@ protected:
virtual void _shapes_changed() = 0;
void _set_space(Space3DSW *p_space);
bool ray_pickable;
bool ray_pickable = true;
CollisionObject3DSW(Type p_type);

25
servers/physics_3d/collision_solver_3d_sat.cpp
View File

@ -66,11 +66,11 @@
struct _CollectorCallback {
CollisionSolver3DSW::CallbackResult callback;
void *userdata;
bool swap;
bool collided;
void *userdata = nullptr;
bool swap = false;
bool collided = false;
Vector3 normal;
Vector3 *prev_axis;
Vector3 *prev_axis = nullptr;
_FORCE_INLINE_ void call(const Vector3 &p_point_A, const Vector3 &p_point_B) {
if (swap) {
@ -606,15 +606,15 @@ static void _generate_contacts_from_supports(const Vector3 *p_points_A, int p_po
template <class ShapeA, class ShapeB, bool withMargin = false>
class SeparatorAxisTest {
const ShapeA *shape_A;
const ShapeB *shape_B;
const Transform3D *transform_A;
const Transform3D *transform_B;
real_t best_depth;
const ShapeA *shape_A = nullptr;
const ShapeB *shape_B = nullptr;
const Transform3D *transform_A = nullptr;
const Transform3D *transform_B = nullptr;
real_t best_depth = 1e15;
Vector3 best_axis;
_CollectorCallback *callback;
real_t margin_A;
real_t margin_B;
_CollectorCallback *callback = nullptr;
real_t margin_A = 0.0;
real_t margin_B = 0.0;
Vector3 separator_axis;
public:
@ -749,7 +749,6 @@ public:
}
_FORCE_INLINE_ SeparatorAxisTest(const ShapeA *p_shape_A, const Transform3D &p_transform_A, const ShapeB *p_shape_B, const Transform3D &p_transform_B, _CollectorCallback *p_callback, real_t p_margin_A = 0, real_t p_margin_B = 0) {
best_depth = 1e15;
shape_A = p_shape_A;
shape_B = p_shape_B;
transform_A = &p_transform_A;

2
servers/physics_3d/gjk_epa.cpp
View File

@ -96,7 +96,7 @@ struct sResults {
Vector3 witnesses[2];
Vector3 normal;
real_t distance;
real_t distance = 0.0;
};
// Shorthands

12
servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp
View File

@ -92,20 +92,8 @@ ConeTwistJoint3DSW::ConeTwistJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Trans
m_rbAFrame = rbAFrame;
m_rbBFrame = rbBFrame;
m_swingSpan1 = Math_TAU / 8.0;
m_swingSpan2 = Math_TAU / 8.0;
m_twistSpan = Math_TAU;
m_biasFactor = 0.3f;
m_relaxationFactor = 1.0f;
m_angularOnly = false;
m_solveTwistLimit = false;
m_solveSwingLimit = false;
A->add_constraint(this, 0);
B->add_constraint(this, 1);
m_appliedImpulse = 0;
}
bool ConeTwistJoint3DSW::setup(real_t p_timestep) {

38
servers/physics_3d/joints/cone_twist_joint_3d_sw.h
View File

@ -67,39 +67,39 @@ public:
Body3DSW *B;
};
Body3DSW *_arr[2];
Body3DSW *_arr[2] = { nullptr, nullptr };
};
JacobianEntry3DSW m_jac[3]; //3 orthogonal linear constraints
JacobianEntry3DSW m_jac[3] = {}; //3 orthogonal linear constraints
real_t m_appliedImpulse;
real_t m_appliedImpulse = 0.0;
Transform3D m_rbAFrame;
Transform3D m_rbBFrame;
real_t m_limitSoftness;
real_t m_biasFactor;
real_t m_relaxationFactor;
real_t m_limitSoftness = 0.0;
real_t m_biasFactor = 0.3;
real_t m_relaxationFactor = 1.0;
real_t m_swingSpan1;
real_t m_swingSpan2;
real_t m_twistSpan;
real_t m_swingSpan1 = Math_TAU / 8.0;
real_t m_swingSpan2 = 0.0;
real_t m_twistSpan = 0.0;
Vector3 m_swingAxis;
Vector3 m_twistAxis;
real_t m_kSwing;
real_t m_kTwist;
real_t m_kSwing = 0.0;
real_t m_kTwist = 0.0;
real_t m_twistLimitSign;
real_t m_swingCorrection;
real_t m_twistCorrection;
real_t m_twistLimitSign = 0.0;
real_t m_swingCorrection = 0.0;
real_t m_twistCorrection = 0.0;
real_t m_accSwingLimitImpulse;
real_t m_accTwistLimitImpulse;
real_t m_accSwingLimitImpulse = 0.0;
real_t m_accTwistLimitImpulse = 0.0;
bool m_angularOnly;
bool m_solveTwistLimit;
bool m_solveSwingLimit;
bool m_angularOnly = false;
bool m_solveTwistLimit = false;
bool m_solveSwingLimit = false;
public:
virtual PhysicsServer3D::JointType get_type() const override { return PhysicsServer3D::JOINT_TYPE_CONE_TWIST; }

79
servers/physics_3d/joints/generic_6dof_joint_3d_sw.h
View File

@ -65,43 +65,28 @@ class G6DOFRotationalLimitMotor3DSW {
public:
//! limit_parameters
//!@{
real_t m_loLimit; //!< joint limit
real_t m_hiLimit; //!< joint limit
real_t m_targetVelocity; //!< target motor velocity
real_t m_maxMotorForce; //!< max force on motor
real_t m_maxLimitForce; //!< max force on limit
real_t m_damping; //!< Damping.
real_t m_limitSoftness; //! Relaxation factor
real_t m_ERP; //!< Error tolerance factor when joint is at limit
real_t m_bounce; //!< restitution factor
bool m_enableMotor;
bool m_enableLimit;
real_t m_loLimit = -1e30; //!< joint limit
real_t m_hiLimit = 1e30; //!< joint limit
real_t m_targetVelocity = 0.0; //!< target motor velocity
real_t m_maxMotorForce = 0.1; //!< max force on motor
real_t m_maxLimitForce = 300.0; //!< max force on limit
real_t m_damping = 1.0; //!< Damping.
real_t m_limitSoftness = 0.5; //! Relaxation factor
real_t m_ERP = 0.5; //!< Error tolerance factor when joint is at limit
real_t m_bounce = 0.0; //!< restitution factor
bool m_enableMotor = false;
bool m_enableLimit = false;
//!@}
//! temp_variables
//!@{
real_t m_currentLimitError; //!< How much is violated this limit
int m_currentLimit; //!< 0=free, 1=at lo limit, 2=at hi limit
real_t m_accumulatedImpulse;
real_t m_currentLimitError = 0.0; //!< How much is violated this limit
int m_currentLimit = 0; //!< 0=free, 1=at lo limit, 2=at hi limit
real_t m_accumulatedImpulse = 0.0;
//!@}
G6DOFRotationalLimitMotor3DSW() {
m_accumulatedImpulse = 0.f;
m_targetVelocity = 0;
m_maxMotorForce = 0.1f;
m_maxLimitForce = 300.0f;
m_loLimit = -1e30;
m_hiLimit = 1e30;
m_ERP = 0.5f;
m_bounce = 0.0f;
m_damping = 1.0f;
m_limitSoftness = 0.5f;
m_currentLimit = 0;
m_currentLimitError = 0;
m_enableMotor = false;
m_enableLimit = false;
}
G6DOFRotationalLimitMotor3DSW() {}
//! Is limited
bool isLimited() {
@ -125,30 +110,16 @@ public:
class G6DOFTranslationalLimitMotor3DSW {
public:
Vector3 m_lowerLimit; //!< the constraint lower limits
Vector3 m_upperLimit; //!< the constraint upper limits
Vector3 m_accumulatedImpulse;
Vector3 m_lowerLimit = Vector3(0.0, 0.0, 0.0); //!< the constraint lower limits
Vector3 m_upperLimit = Vector3(0.0, 0.0, 0.0); //!< the constraint upper limits
Vector3 m_accumulatedImpulse = Vector3(0.0, 0.0, 0.0);
//! Linear_Limit_parameters
//!@{
Vector3 m_limitSoftness; //!< Softness for linear limit
Vector3 m_damping; //!< Damping for linear limit
Vector3 m_restitution; //! Bounce parameter for linear limit
Vector3 m_limitSoftness = Vector3(0.7, 0.7, 0.7); //!< Softness for linear limit
Vector3 m_damping = Vector3(1.0, 1.0, 1.0); //!< Damping for linear limit
Vector3 m_restitution = Vector3(0.5, 0.5, 0.5); //! Bounce parameter for linear limit
//!@}
bool enable_limit[3];
G6DOFTranslationalLimitMotor3DSW() {
m_lowerLimit = Vector3(0.f, 0.f, 0.f);
m_upperLimit = Vector3(0.f, 0.f, 0.f);
m_accumulatedImpulse = Vector3(0.f, 0.f, 0.f);
m_limitSoftness = Vector3(1, 1, 1) * 0.7f;
m_damping = Vector3(1, 1, 1) * real_t(1.0f);
m_restitution = Vector3(1, 1, 1) * real_t(0.5f);
enable_limit[0] = true;
enable_limit[1] = true;
enable_limit[2] = true;
}
bool enable_limit[3] = { true, true, true };
//! Test limit
/*!
@ -180,7 +151,7 @@ protected:
Body3DSW *B;
};
Body3DSW *_arr[2];
Body3DSW *_arr[2] = { nullptr, nullptr };
};
//! relative_frames
@ -208,7 +179,7 @@ protected:
protected:
//! temporal variables
//!@{
real_t m_timeStep;
real_t m_timeStep = 0.0;
Transform3D m_calculatedTransformA;
Transform3D m_calculatedTransformB;
Vector3 m_calculatedAxisAngleDiff;
@ -216,7 +187,7 @@ protected:
Vector3 m_AnchorPos; // point between pivots of bodies A and B to solve linear axes
bool m_useLinearReferenceFrameA;
bool m_useLinearReferenceFrameA = false;
//!@}

30
servers/physics_3d/joints/hinge_joint_3d_sw.cpp
View File

@ -79,21 +79,6 @@ HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform3D &
m_rbBFrame.basis[1][2] *= real_t(-1.);
m_rbBFrame.basis[2][2] *= real_t(-1.);
//start with free
m_lowerLimit = Math_PI;
m_upperLimit = -Math_PI;
m_useLimit = false;
m_biasFactor = 0.3f;
m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f;
m_solveLimit = false;
tau = 0.3;
m_angularOnly = false;
m_enableAngularMotor = false;
A->add_constraint(this, 0);
B->add_constraint(this, 1);
}
@ -135,21 +120,6 @@ HingeJoint3DSW::HingeJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Vector3 &pivo
rbAxisB1.y, rbAxisB2.y, -axisInB.y,
rbAxisB1.z, rbAxisB2.z, -axisInB.z);
//start with free
m_lowerLimit = Math_PI;
m_upperLimit = -Math_PI;
m_useLimit = false;
m_biasFactor = 0.3f;
m_relaxationFactor = 1.0f;
m_limitSoftness = 0.9f;
m_solveLimit = false;
tau = 0.3;
m_angularOnly = false;
m_enableAngularMotor = false;
A->add_constraint(this, 0);
B->add_constraint(this, 1);
}

36
servers/physics_3d/joints/hinge_joint_3d_sw.h
View File

@ -60,7 +60,7 @@ class HingeJoint3DSW : public Joint3DSW {
Body3DSW *B;
};
Body3DSW *_arr[2];
Body3DSW *_arr[2] = {};
};
JacobianEntry3DSW m_jac[3]; //3 orthogonal linear constraints
@ -69,31 +69,31 @@ class HingeJoint3DSW : public Joint3DSW {
Transform3D m_rbAFrame; // constraint axii. Assumes z is hinge axis.
Transform3D m_rbBFrame;
real_t m_motorTargetVelocity;
real_t m_maxMotorImpulse;
real_t m_motorTargetVelocity = 0.0;
real_t m_maxMotorImpulse = 0.0;
real_t m_limitSoftness;
real_t m_biasFactor;
real_t m_relaxationFactor;
real_t m_limitSoftness = 0.9;
real_t m_biasFactor = 0.3;
real_t m_relaxationFactor = 1.0;
real_t m_lowerLimit;
real_t m_upperLimit;
real_t m_lowerLimit = Math_PI;
real_t m_upperLimit = -Math_PI;
real_t m_kHinge;
real_t m_kHinge = 0.0;
real_t m_limitSign;
real_t m_correction;
real_t m_limitSign = 0.0;
real_t m_correction = 0.0;
real_t m_accLimitImpulse;
real_t m_accLimitImpulse = 0.0;
real_t tau;
real_t tau = 0.3;
bool m_useLimit;
bool m_angularOnly;
bool m_enableAngularMotor;
bool m_solveLimit;
bool m_useLimit = false;
bool m_angularOnly = false;
bool m_enableAngularMotor = false;
bool m_solveLimit = false;
real_t m_appliedImpulse;
real_t m_appliedImpulse = 0.0;
public:
virtual PhysicsServer3D::JointType get_type() const override { return PhysicsServer3D::JOINT_TYPE_HINGE; }

2
servers/physics_3d/joints/jacobian_entry_3d_sw.h
View File

@ -163,7 +163,7 @@ public:
Vector3 m_0MinvJt;
Vector3 m_1MinvJt;
//Optimization: can be stored in the w/last component of one of the vectors
real_t m_Adiag;
real_t m_Adiag = 1.0;
};
#endif // JACOBIAN_ENTRY_SW_H

5
servers/physics_3d/joints/pin_joint_3d_sw.cpp
View File

@ -171,11 +171,6 @@ PinJoint3DSW::PinJoint3DSW(Body3DSW *p_body_a, const Vector3 &p_pos_a, Body3DSW
m_pivotInA = p_pos_a;
m_pivotInB = p_pos_b;
m_tau = 0.3;
m_damping = 1;
m_impulseClamp = 0;
m_appliedImpulse = 0;
A->add_constraint(this, 0);
B->add_constraint(this, 1);
}

12
servers/physics_3d/joints/pin_joint_3d_sw.h
View File

@ -60,15 +60,15 @@ class PinJoint3DSW : public Joint3DSW {
Body3DSW *B;
};
Body3DSW *_arr[2];
Body3DSW *_arr[2] = {};
};
real_t m_tau; //bias
real_t m_damping;
real_t m_impulseClamp;
real_t m_appliedImpulse;
real_t m_tau = 0.3; //bias
real_t m_damping = 1.0;
real_t m_impulseClamp = 0.0;
real_t m_appliedImpulse = 0.0;
JacobianEntry3DSW m_jac[3]; //3 orthogonal linear constraints
JacobianEntry3DSW m_jac[3] = {}; //3 orthogonal linear constraints
Vector3 m_pivotInA;
Vector3 m_pivotInB;

37
servers/physics_3d/joints/slider_joint_3d_sw.cpp
View File

@ -72,41 +72,6 @@ static _FORCE_INLINE_ real_t atan2fast(real_t y, real_t x) {
return (y < 0.0f) ? -angle : angle;
}
void SliderJoint3DSW::initParams() {
m_lowerLinLimit = real_t(1.0);
m_upperLinLimit = real_t(-1.0);
m_lowerAngLimit = real_t(0.);
m_upperAngLimit = real_t(0.);
m_softnessDirLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionDirLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingDirLin = real_t(0.);
m_softnessDirAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionDirAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingDirAng = real_t(0.);
m_softnessOrthoLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionOrthoLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingOrthoLin = SLIDER_CONSTRAINT_DEF_DAMPING;
m_softnessOrthoAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionOrthoAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingOrthoAng = SLIDER_CONSTRAINT_DEF_DAMPING;
m_softnessLimLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionLimLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingLimLin = SLIDER_CONSTRAINT_DEF_DAMPING;
m_softnessLimAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
m_restitutionLimAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
m_dampingLimAng = SLIDER_CONSTRAINT_DEF_DAMPING;
m_poweredLinMotor = false;
m_targetLinMotorVelocity = real_t(0.);
m_maxLinMotorForce = real_t(0.);
m_accumulatedLinMotorImpulse = real_t(0.0);
m_poweredAngMotor = false;
m_targetAngMotorVelocity = real_t(0.);
m_maxAngMotorForce = real_t(0.);
m_accumulatedAngMotorImpulse = real_t(0.0);
} // SliderJointSW::initParams()
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@ -120,8 +85,6 @@ SliderJoint3DSW::SliderJoint3DSW(Body3DSW *rbA, Body3DSW *rbB, const Transform3D
A->add_constraint(this, 0);
B->add_constraint(this, 1);
initParams();
} // SliderJointSW::SliderJointSW()
//-----------------------------------------------------------------------------

83
servers/physics_3d/joints/slider_joint_3d_sw.h
View File

@ -73,53 +73,53 @@ protected:
Body3DSW *B;
};
Body3DSW *_arr[2];
Body3DSW *_arr[2] = { nullptr, nullptr };
};
Transform3D m_frameInA;
Transform3D m_frameInB;
// linear limits
real_t m_lowerLinLimit;
real_t m_upperLinLimit;
real_t m_lowerLinLimit = 1.0;
real_t m_upperLinLimit = -1.0;
// angular limits
real_t m_lowerAngLimit;
real_t m_upperAngLimit;
real_t m_lowerAngLimit = 0.0;
real_t m_upperAngLimit = 0.0;
// softness, restitution and damping for different cases
// DirLin - moving inside linear limits
// LimLin - hitting linear limit
// DirAng - moving inside angular limits
// LimAng - hitting angular limit
// OrthoLin, OrthoAng - against constraint axis
real_t m_softnessDirLin;
real_t m_restitutionDirLin;
real_t m_dampingDirLin;
real_t m_softnessDirAng;
real_t m_restitutionDirAng;
real_t m_dampingDirAng;
real_t m_softnessLimLin;
real_t m_restitutionLimLin;
real_t m_dampingLimLin;
real_t m_softnessLimAng;
real_t m_restitutionLimAng;
real_t m_dampingLimAng;
real_t m_softnessOrthoLin;
real_t m_restitutionOrthoLin;
real_t m_dampingOrthoLin;
real_t m_softnessOrthoAng;
real_t m_restitutionOrthoAng;
real_t m_dampingOrthoAng;
real_t m_softnessDirLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionDirLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingDirLin = 0.0;
real_t m_softnessDirAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionDirAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingDirAng = 0.0;
real_t m_softnessLimLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionLimLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingLimLin = SLIDER_CONSTRAINT_DEF_DAMPING;
real_t m_softnessLimAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionLimAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingLimAng = SLIDER_CONSTRAINT_DEF_DAMPING;
real_t m_softnessOrthoLin = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionOrthoLin = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingOrthoLin = SLIDER_CONSTRAINT_DEF_DAMPING;
real_t m_softnessOrthoAng = SLIDER_CONSTRAINT_DEF_SOFTNESS;
real_t m_restitutionOrthoAng = SLIDER_CONSTRAINT_DEF_RESTITUTION;
real_t m_dampingOrthoAng = SLIDER_CONSTRAINT_DEF_DAMPING;
// for interlal use
bool m_solveLinLim;
bool m_solveAngLim;
bool m_solveLinLim = false;
bool m_solveAngLim = false;
JacobianEntry3DSW m_jacLin[3];
real_t m_jacLinDiagABInv[3];
JacobianEntry3DSW m_jacLin[3] = {};
real_t m_jacLinDiagABInv[3] = {};
JacobianEntry3DSW m_jacAng[3];
JacobianEntry3DSW m_jacAng[3] = {};
real_t m_timeStep;
real_t m_timeStep = 0.0;
Transform3D m_calculatedTransformA;
Transform3D m_calculatedTransformB;
@ -132,23 +132,20 @@ protected:
Vector3 m_relPosA;
Vector3 m_relPosB;
real_t m_linPos;
real_t m_linPos = 0.0;
real_t m_angDepth;
real_t m_kAngle;
real_t m_angDepth = 0.0;
real_t m_kAngle = 0.0;
bool m_poweredLinMotor;
real_t m_targetLinMotorVelocity;
real_t m_maxLinMotorForce;
real_t m_accumulatedLinMotorImpulse;
bool m_poweredLinMotor = false;
real_t m_targetLinMotorVelocity = 0.0;
real_t m_maxLinMotorForce = 0.0;
real_t m_accumulatedLinMotorImpulse = 0.0;
bool m_poweredAngMotor;
real_t m_targetAngMotorVelocity;
real_t m_maxAngMotorForce;
real_t m_accumulatedAngMotorImpulse;
//------------------------
void initParams();
bool m_poweredAngMotor = false;
real_t m_targetAngMotorVelocity = 0.0;
real_t m_maxAngMotorForce = 0.0;
real_t m_accumulatedAngMotorImpulse = 0.0;
public:
// constructors

6
servers/physics_3d/physics_server_3d_sw.cpp
View File

@ -1744,11 +1744,5 @@ PhysicsServer3DSW::PhysicsServer3DSW(bool p_using_threads) {
singletonsw = this;
BroadPhase3DSW::create_func = BroadPhase3DBVH::_create;
island_count = 0;
active_objects = 0;
collision_pairs = 0;
using_threads = p_using_threads;
active = true;
flushing_queries = false;
doing_sync = false;
};

18
servers/physics_3d/physics_server_3d_sw.h
View File

@ -42,18 +42,18 @@ class PhysicsServer3DSW : public PhysicsServer3D {
GDCLASS(PhysicsServer3DSW, PhysicsServer3D);
friend class PhysicsDirectSpaceState3DSW;
bool active;
int iterations;
bool active = true;
int iterations = 0;
int island_count;
int active_objects;
int collision_pairs;
int island_count = 0;
int active_objects = 0;
int collision_pairs = 0;
bool using_threads;
bool doing_sync;
bool flushing_queries;
bool using_threads = false;
bool doing_sync = false;
bool flushing_queries = false;
Step3DSW *stepper;
Step3DSW *stepper = nullptr;
Set<const Space3DSW *> active_spaces;
mutable RID_PtrOwner<Shape3DSW, true> shape_owner;

3
servers/physics_3d/physics_server_3d_wrap_mt.cpp
View File

@ -119,8 +119,6 @@ PhysicsServer3DWrapMT::PhysicsServer3DWrapMT(PhysicsServer3D *p_contained, bool
command_queue(p_create_thread) {
physics_3d_server = p_contained;
create_thread = p_create_thread;
step_pending = 0;
step_thread_up = false;
pool_max_size = GLOBAL_GET("memory/limits/multithreaded_server/rid_pool_prealloc");
@ -131,7 +129,6 @@ PhysicsServer3DWrapMT::PhysicsServer3DWrapMT(PhysicsServer3D *p_contained, bool
}
main_thread = Thread::get_caller_id();
first_frame = true;
}
PhysicsServer3DWrapMT::~PhysicsServer3DWrapMT() {

2
servers/physics_3d/physics_server_3d_wrap_mt.h
View File

@ -58,7 +58,7 @@ class PhysicsServer3DWrapMT : public PhysicsServer3D {
bool create_thread = false;
Semaphore step_sem;
int step_pending;
int step_pending = 0;
void thread_step(real_t p_delta);
void thread_flush();

25
servers/physics_3d/shape_3d_sw.cpp
View File

@ -101,11 +101,6 @@ const Map<ShapeOwner3DSW *, int> &Shape3DSW::get_owners() const {
return owners;
}
Shape3DSW::Shape3DSW() {
custom_bias = 0;
configured = false;
}
Shape3DSW::~Shape3DSW() {
ERR_FAIL_COND(owners.size());
}
@ -244,10 +239,7 @@ Variant SeparationRayShape3DSW::get_data() const {
return d;
}
SeparationRayShape3DSW::SeparationRayShape3DSW() {
length = 1;
slide_on_slope = false;
}
SeparationRayShape3DSW::SeparationRayShape3DSW() {}
/********** SPHERE *************/
@ -311,9 +303,7 @@ Variant SphereShape3DSW::get_data() const {
return radius;
}
SphereShape3DSW::SphereShape3DSW() {
radius = 0;
}
SphereShape3DSW::SphereShape3DSW() {}
/********** BOX *************/
@ -502,8 +492,7 @@ Variant BoxShape3DSW::get_data() const {
return half_extents;
}
BoxShape3DSW::BoxShape3DSW() {
}
BoxShape3DSW::BoxShape3DSW() {}
/********** CAPSULE *************/
@ -668,9 +657,7 @@ Variant CapsuleShape3DSW::get_data() const {
return d;
}
CapsuleShape3DSW::CapsuleShape3DSW() {
height = radius = 0;
}
CapsuleShape3DSW::CapsuleShape3DSW() {}
/********** CYLINDER *************/
@ -848,9 +835,7 @@ Variant CylinderShape3DSW::get_data() const {
return d;
}
CylinderShape3DSW::CylinderShape3DSW() {
height = radius = 0;
}
CylinderShape3DSW::CylinderShape3DSW() {}
/********** CONVEX POLYGON *************/

30
servers/physics_3d/shape_3d_sw.h
View File

@ -48,8 +48,8 @@ public:
class Shape3DSW {
RID self;
AABB aabb;
bool configured;
real_t custom_bias;
bool configured = false;
real_t custom_bias = 0.0;
Map<ShapeOwner3DSW *, int> owners;
@ -95,7 +95,7 @@ public:
bool is_owner(ShapeOwner3DSW *p_owner) const;
const Map<ShapeOwner3DSW *, int> &get_owners() const;
Shape3DSW();
Shape3DSW() {}
virtual ~Shape3DSW();
};
@ -138,8 +138,8 @@ public:
};
class SeparationRayShape3DSW : public Shape3DSW {
real_t length;
bool slide_on_slope;
real_t length = 1.0;
bool slide_on_slope = false;
void _setup(real_t p_length, bool p_slide_on_slope);
@ -166,7 +166,7 @@ public:
};
class SphereShape3DSW : public Shape3DSW {
real_t radius;
real_t radius = 0.0;
void _setup(real_t p_radius);
@ -218,8 +218,8 @@ public:
};
class CapsuleShape3DSW : public Shape3DSW {
real_t height;
real_t radius;
real_t height = 0.0;
real_t radius = 0.0;
void _setup(real_t p_height, real_t p_radius);
@ -247,8 +247,8 @@ public:
};
class CylinderShape3DSW : public Shape3DSW {
real_t height;
real_t radius;
real_t height = 0.0;
real_t radius = 0.0;
void _setup(real_t p_height, real_t p_radius);
@ -308,7 +308,7 @@ struct ConcavePolygonShape3DSW : public ConcaveShape3DSW {
struct Face {
Vector3 normal;
int indices[3];
int indices[3] = {};
};
Vector<Face> faces;
@ -316,10 +316,10 @@ struct ConcavePolygonShape3DSW : public ConcaveShape3DSW {
struct BVH {
AABB aabb;
int left;
int right;
int left = 0;
int right = 0;
int face_index;
int face_index = 0;
};
Vector<BVH> bvh;
@ -469,7 +469,7 @@ struct FaceShape3DSW : public Shape3DSW {
};
struct MotionShape3DSW : public Shape3DSW {
Shape3DSW *shape;
Shape3DSW *shape = nullptr;
Vector3 motion;
virtual PhysicsServer3D::ShapeType get_type() const override { return PhysicsServer3D::SHAPE_CONVEX_POLYGON; }

17
servers/physics_3d/space_3d_sw.cpp
View File

@ -1142,18 +1142,6 @@ PhysicsDirectSpaceState3DSW *Space3DSW::get_direct_state() {
}
Space3DSW::Space3DSW() {
collision_pairs = 0;
active_objects = 0;
island_count = 0;
contact_debug_count = 0;
locked = false;
contact_recycle_radius = 0.01;
contact_max_separation = 0.05;
contact_max_allowed_penetration = 0.01;
test_motion_min_contact_depth = 0.00001;
constraint_bias = 0.01;
body_linear_velocity_sleep_threshold = GLOBAL_DEF("physics/3d/sleep_threshold_linear", 0.1);
body_angular_velocity_sleep_threshold = GLOBAL_DEF("physics/3d/sleep_threshold_angular", Math::deg2rad(8.0));
body_time_to_sleep = GLOBAL_DEF("physics/3d/time_before_sleep", 0.5);
@ -1163,14 +1151,9 @@ Space3DSW::Space3DSW() {
broadphase = BroadPhase3DSW::create_func();
broadphase->set_pair_callback(_broadphase_pair, this);
broadphase->set_unpair_callback(_broadphase_unpair, this);
area = nullptr;
direct_access = memnew(PhysicsDirectSpaceState3DSW);
direct_access->space = this;
for (int i = 0; i < ELAPSED_TIME_MAX; i++) {
elapsed_time[i] = 0;
}
}
Space3DSW::~Space3DSW() {

24
servers/physics_3d/space_3d_sw.h
View File

@ -72,7 +72,7 @@ public:
};
private:
uint64_t elapsed_time[ELAPSED_TIME_MAX];
uint64_t elapsed_time[ELAPSED_TIME_MAX] = {};
PhysicsDirectSpaceState3DSW *direct_access;
RID self;
@ -90,13 +90,13 @@ private:
Set<CollisionObject3DSW *> objects;
Area3DSW *area;
Area3DSW *area = nullptr;
real_t contact_recycle_radius;
real_t contact_max_separation;
real_t contact_max_allowed_penetration;
real_t constraint_bias;
real_t test_motion_min_contact_depth;
real_t contact_recycle_radius = 0.01;
real_t contact_max_separation = 0.05;
real_t contact_max_allowed_penetration = 0.01;
real_t constraint_bias = 0.01;
real_t test_motion_min_contact_depth = 0.00001;
enum {
INTERSECTION_QUERY_MAX = 2048
@ -110,18 +110,18 @@ private:
real_t body_time_to_sleep;
real_t body_angular_velocity_damp_ratio;
bool locked;
bool locked = false;
real_t last_step = 0.001;
int island_count;
int active_objects;
int collision_pairs;
int island_count = 0;
int active_objects = 0;
int collision_pairs = 0;
RID static_global_body;
Vector<Vector3> contact_debug;
int contact_debug_count;
int contact_debug_count = 0;
friend class PhysicsDirectSpaceState3DSW;

2
servers/physics_3d/step_3d_sw.cpp
View File

@ -407,8 +407,6 @@ void Step3DSW::step(Space3DSW *p_space, real_t p_delta, int p_iterations) {
}
Step3DSW::Step3DSW() {
_step = 1;
body_islands.reserve(BODY_ISLAND_COUNT_RESERVE);
constraint_islands.reserve(ISLAND_COUNT_RESERVE);
all_constraints.reserve(CONSTRAINT_COUNT_RESERVE);

2
servers/physics_3d/step_3d_sw.h
View File

@ -37,7 +37,7 @@
#include "core/templates/thread_work_pool.h"
class Step3DSW {
uint64_t _step;
uint64_t _step = 1;
int iterations = 0;
real_t delta = 0.0;