Merge pull request #52668 from qarmin/cppcheck_servers_physics

Initialize variables in servers/physics

servers/physics_2d/area_2d_sw.cpp

@@ -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() {

servers/physics_2d/area_2d_sw.h

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

servers/physics_2d/body_2d_sw.h

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

servers/physics_2d/body_pair_2d_sw.h

@@ -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

servers/physics_2d/broad_phase_2d_bvh.cpp

@@ -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;
 }

servers/physics_2d/broad_phase_2d_bvh.h

@@ -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

servers/physics_2d/collision_object_2d_sw.cpp

@@ -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;
 }

servers/physics_2d/collision_object_2d_sw.h

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

servers/physics_2d/collision_solver_2d_sat.cpp

@@ -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
 	}
 };
 

servers/physics_2d/collision_solver_2d_sw.cpp

@@ -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) {

servers/physics_2d/constraint_2d_sw.h

@@ -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:

servers/physics_2d/joints_2d_sw.cpp

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

servers/physics_2d/joints_2d_sw.h

@@ -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; }

servers/physics_2d/physics_server_2d_sw.cpp

@@ -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;
 };

servers/physics_2d/physics_server_2d_sw.h

@@ -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_boundary_shape_create() override;

servers/physics_2d/physics_server_2d_wrap_mt.cpp

@@ -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() {

servers/physics_2d/physics_server_2d_wrap_mt.h

@@ -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

servers/physics_2d/shape_2d_sw.cpp

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

servers/physics_2d/shape_2d_sw.h

@@ -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 WorldBoundaryShape2DSW : 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 {

servers/physics_2d/space_2d_sw.cpp

@@ -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() {

servers/physics_2d/space_2d_sw.h

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

servers/physics_2d/step_2d_sw.cpp

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

servers/physics_2d/step_2d_sw.h

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

servers/physics_3d/area_3d_sw.cpp

@@ -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() {

servers/physics_3d/area_3d_sw.h

@@ -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() {}

servers/physics_3d/body_3d_sw.h

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

servers/physics_3d/body_pair_3d_sw.h

@@ -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 depth;
-		bool active;
+		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 = 0.0;
+		bool active = false;
 		Vector3 rA, rB; // Offset in world orientation with respect to center of mass
 	};
 

servers/physics_3d/broad_phase_3d_bvh.cpp

@@ -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;
 }

servers/physics_3d/broad_phase_3d_bvh.h

@@ -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

servers/physics_3d/collision_object_3d_sw.cpp

@@ -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;
 }

servers/physics_3d/collision_object_3d_sw.h

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

servers/physics_3d/collision_solver_3d_sat.cpp

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

servers/physics_3d/gjk_epa.cpp

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

servers/physics_3d/joints/cone_twist_joint_3d_sw.cpp

@@ -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) {

servers/physics_3d/joints/cone_twist_joint_3d_sw.h

@@ -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; }

servers/physics_3d/joints/generic_6dof_joint_3d_sw.h

@@ -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;
 
 	//!@}
 

servers/physics_3d/joints/hinge_joint_3d_sw.cpp

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

servers/physics_3d/joints/hinge_joint_3d_sw.h

@@ -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; }

servers/physics_3d/joints/jacobian_entry_3d_sw.h

@@ -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

servers/physics_3d/joints/pin_joint_3d_sw.cpp

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

servers/physics_3d/joints/pin_joint_3d_sw.h

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

servers/physics_3d/joints/slider_joint_3d_sw.cpp

@@ -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()
 
 //-----------------------------------------------------------------------------

servers/physics_3d/joints/slider_joint_3d_sw.h

@@ -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

servers/physics_3d/physics_server_3d_sw.cpp

@@ -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;
 };

servers/physics_3d/physics_server_3d_sw.h

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

servers/physics_3d/physics_server_3d_wrap_mt.cpp

@@ -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() {

servers/physics_3d/physics_server_3d_wrap_mt.h

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

servers/physics_3d/shape_3d_sw.cpp

@@ -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 *************/
 

servers/physics_3d/shape_3d_sw.h

@@ -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; }

servers/physics_3d/space_3d_sw.cpp

@@ -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() {

servers/physics_3d/space_3d_sw.h

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

servers/physics_3d/step_3d_sw.cpp

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

servers/physics_3d/step_3d_sw.h

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