Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.

10 files changed, 145 insertions, 147 deletions

diff --git a/scene/2d/audio_listener_2d.cpp b/scene/2d/audio_listener_2d.cpp
index f7dd20d7c0..3cc64b2170 100644
--- a/scene/2d/audio_listener_2d.cpp
+++ b/scene/2d/audio_listener_2d.cpp
@@ -103,7 +103,6 @@ bool AudioListener2D::is_current() const {
 	} else {
 		return current;
 	}
-	return false;
 }
 
 void AudioListener2D::_bind_methods() {
diff --git a/scene/2d/collision_object_2d.cpp b/scene/2d/collision_object_2d.cpp
index 23948c2fd3..df75d34e0f 100644
--- a/scene/2d/collision_object_2d.cpp
+++ b/scene/2d/collision_object_2d.cpp
@@ -36,12 +36,12 @@
 void CollisionObject2D::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_ENTER_TREE: {
-			Transform2D global_transform = get_global_transform();
+			Transform2D gl_transform = get_global_transform();
 
 			if (area) {
-				PhysicsServer2D::get_singleton()->area_set_transform(rid, global_transform);
+				PhysicsServer2D::get_singleton()->area_set_transform(rid, gl_transform);
 			} else {
-				PhysicsServer2D::get_singleton()->body_set_state(rid, PhysicsServer2D::BODY_STATE_TRANSFORM, global_transform);
+				PhysicsServer2D::get_singleton()->body_set_state(rid, PhysicsServer2D::BODY_STATE_TRANSFORM, gl_transform);
 			}
 
 			bool disabled = !is_enabled();
@@ -81,12 +81,12 @@ void CollisionObject2D::_notification(int p_what) {
 				return;
 			}
 
-			Transform2D global_transform = get_global_transform();
+			Transform2D gl_transform = get_global_transform();
 
 			if (area) {
-				PhysicsServer2D::get_singleton()->area_set_transform(rid, global_transform);
+				PhysicsServer2D::get_singleton()->area_set_transform(rid, gl_transform);
 			} else {
-				PhysicsServer2D::get_singleton()->body_set_state(rid, PhysicsServer2D::BODY_STATE_TRANSFORM, global_transform);
+				PhysicsServer2D::get_singleton()->body_set_state(rid, PhysicsServer2D::BODY_STATE_TRANSFORM, gl_transform);
 			}
 		} break;
 
@@ -153,13 +153,13 @@ uint32_t CollisionObject2D::get_collision_mask() const {
 void CollisionObject2D::set_collision_layer_value(int p_layer_number, bool p_value) {
 	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
 	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
-	uint32_t collision_layer = get_collision_layer();
+	uint32_t collision_layer_new = get_collision_layer();
 	if (p_value) {
-		collision_layer |= 1 << (p_layer_number - 1);
+		collision_layer_new |= 1 << (p_layer_number - 1);
 	} else {
-		collision_layer &= ~(1 << (p_layer_number - 1));
+		collision_layer_new &= ~(1 << (p_layer_number - 1));
 	}
-	set_collision_layer(collision_layer);
+	set_collision_layer(collision_layer_new);
 }
 
 bool CollisionObject2D::get_collision_layer_value(int p_layer_number) const {
diff --git a/scene/2d/cpu_particles_2d.cpp b/scene/2d/cpu_particles_2d.cpp
index eece90190b..c6296f4732 100644
--- a/scene/2d/cpu_particles_2d.cpp
+++ b/scene/2d/cpu_particles_2d.cpp
@@ -1162,74 +1162,73 @@ void CPUParticles2D::_notification(int p_what) {
 }
 
 void CPUParticles2D::convert_from_particles(Node *p_particles) {
-	GPUParticles2D *particles = Object::cast_to<GPUParticles2D>(p_particles);
-	ERR_FAIL_COND_MSG(!particles, "Only GPUParticles2D nodes can be converted to CPUParticles2D.");
-
-	set_emitting(particles->is_emitting());
-	set_amount(particles->get_amount());
-	set_lifetime(particles->get_lifetime());
-	set_one_shot(particles->get_one_shot());
-	set_pre_process_time(particles->get_pre_process_time());
-	set_explosiveness_ratio(particles->get_explosiveness_ratio());
-	set_randomness_ratio(particles->get_randomness_ratio());
-	set_use_local_coordinates(particles->get_use_local_coordinates());
-	set_fixed_fps(particles->get_fixed_fps());
-	set_fractional_delta(particles->get_fractional_delta());
-	set_speed_scale(particles->get_speed_scale());
-	set_draw_order(DrawOrder(particles->get_draw_order()));
-	set_texture(particles->get_texture());
-
-	Ref<Material> mat = particles->get_material();
+	GPUParticles2D *gpu_particles = Object::cast_to<GPUParticles2D>(p_particles);
+	ERR_FAIL_COND_MSG(!gpu_particles, "Only GPUParticles2D nodes can be converted to CPUParticles2D.");
+
+	set_emitting(gpu_particles->is_emitting());
+	set_amount(gpu_particles->get_amount());
+	set_lifetime(gpu_particles->get_lifetime());
+	set_one_shot(gpu_particles->get_one_shot());
+	set_pre_process_time(gpu_particles->get_pre_process_time());
+	set_explosiveness_ratio(gpu_particles->get_explosiveness_ratio());
+	set_randomness_ratio(gpu_particles->get_randomness_ratio());
+	set_use_local_coordinates(gpu_particles->get_use_local_coordinates());
+	set_fixed_fps(gpu_particles->get_fixed_fps());
+	set_fractional_delta(gpu_particles->get_fractional_delta());
+	set_speed_scale(gpu_particles->get_speed_scale());
+	set_draw_order(DrawOrder(gpu_particles->get_draw_order()));
+	set_texture(gpu_particles->get_texture());
+
+	Ref<Material> mat = gpu_particles->get_material();
 	if (mat.is_valid()) {
 		set_material(mat);
 	}
 
-	Ref<ParticleProcessMaterial> material = particles->get_process_material();
-	if (material.is_null()) {
+	Ref<ParticleProcessMaterial> proc_mat = gpu_particles->get_process_material();
+	if (proc_mat.is_null()) {
 		return;
 	}
 
-	Vector3 dir = material->get_direction();
+	Vector3 dir = proc_mat->get_direction();
 	set_direction(Vector2(dir.x, dir.y));
-	set_spread(material->get_spread());
+	set_spread(proc_mat->get_spread());
 
-	set_color(material->get_color());
+	set_color(proc_mat->get_color());
 
-	Ref<GradientTexture1D> gt = material->get_color_ramp();
+	Ref<GradientTexture1D> gt = proc_mat->get_color_ramp();
 	if (gt.is_valid()) {
 		set_color_ramp(gt->get_gradient());
 	}
 
-	Ref<GradientTexture1D> gti = material->get_color_initial_ramp();
+	Ref<GradientTexture1D> gti = proc_mat->get_color_initial_ramp();
 	if (gti.is_valid()) {
 		set_color_initial_ramp(gti->get_gradient());
 	}
 
-	set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, material->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY));
+	set_particle_flag(PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY, proc_mat->get_particle_flag(ParticleProcessMaterial::PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY));
 
-	set_emission_shape(EmissionShape(material->get_emission_shape()));
-	set_emission_sphere_radius(material->get_emission_sphere_radius());
-	Vector2 rect_extents = Vector2(material->get_emission_box_extents().x, material->get_emission_box_extents().y);
+	set_emission_shape(EmissionShape(proc_mat->get_emission_shape()));
+	set_emission_sphere_radius(proc_mat->get_emission_sphere_radius());
+	Vector2 rect_extents = Vector2(proc_mat->get_emission_box_extents().x, proc_mat->get_emission_box_extents().y);
 	set_emission_rect_extents(rect_extents);
 
-	Ref<CurveXYZTexture> scale3D = material->get_param_texture(ParticleProcessMaterial::PARAM_SCALE);
+	Ref<CurveXYZTexture> scale3D = proc_mat->get_param_texture(ParticleProcessMaterial::PARAM_SCALE);
 	if (scale3D.is_valid()) {
 		split_scale = true;
 		scale_curve_x = scale3D->get_curve_x();
 		scale_curve_y = scale3D->get_curve_y();
 	}
-	Vector2 gravity = Vector2(material->get_gravity().x, material->get_gravity().y);
-	set_gravity(gravity);
-	set_lifetime_randomness(material->get_lifetime_randomness());
+	set_gravity(Vector2(proc_mat->get_gravity().x, proc_mat->get_gravity().y));
+	set_lifetime_randomness(proc_mat->get_lifetime_randomness());
 
 #define CONVERT_PARAM(m_param)                                                                  \
-	set_param_min(m_param, material->get_param_min(ParticleProcessMaterial::m_param));          \
+	set_param_min(m_param, proc_mat->get_param_min(ParticleProcessMaterial::m_param));          \
 	{                                                                                           \
-		Ref<CurveTexture> ctex = material->get_param_texture(ParticleProcessMaterial::m_param); \
+		Ref<CurveTexture> ctex = proc_mat->get_param_texture(ParticleProcessMaterial::m_param); \
 		if (ctex.is_valid())                                                                    \
 			set_param_curve(m_param, ctex->get_curve());                                        \
 	}                                                                                           \
-	set_param_max(m_param, material->get_param_max(ParticleProcessMaterial::m_param));
+	set_param_max(m_param, proc_mat->get_param_max(ParticleProcessMaterial::m_param));
 
 	CONVERT_PARAM(PARAM_INITIAL_LINEAR_VELOCITY);
 	CONVERT_PARAM(PARAM_ANGULAR_VELOCITY);
diff --git a/scene/2d/gpu_particles_2d.cpp b/scene/2d/gpu_particles_2d.cpp
index 18f709f241..9786b01058 100644
--- a/scene/2d/gpu_particles_2d.cpp
+++ b/scene/2d/gpu_particles_2d.cpp
@@ -353,13 +353,13 @@ void GPUParticles2D::_validate_property(PropertyInfo &p_property) const {
 }
 
 void GPUParticles2D::emit_particle(const Transform2D &p_transform2d, const Vector2 &p_velocity2d, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) {
-	Transform3D transform;
-	transform.basis.set_column(0, Vector3(p_transform2d.columns[0].x, p_transform2d.columns[0].y, 0));
-	transform.basis.set_column(1, Vector3(p_transform2d.columns[1].x, p_transform2d.columns[1].y, 0));
-	transform.set_origin(Vector3(p_transform2d.get_origin().x, p_transform2d.get_origin().y, 0));
+	Transform3D emit_transform;
+	emit_transform.basis.set_column(0, Vector3(p_transform2d.columns[0].x, p_transform2d.columns[0].y, 0));
+	emit_transform.basis.set_column(1, Vector3(p_transform2d.columns[1].x, p_transform2d.columns[1].y, 0));
+	emit_transform.set_origin(Vector3(p_transform2d.get_origin().x, p_transform2d.get_origin().y, 0));
 	Vector3 velocity = Vector3(p_velocity2d.x, p_velocity2d.y, 0);
 
-	RS::get_singleton()->particles_emit(particles, transform, velocity, p_color, p_custom, p_emit_flags);
+	RS::get_singleton()->particles_emit(particles, emit_transform, velocity, p_color, p_custom, p_emit_flags);
 }
 
 void GPUParticles2D::_attach_sub_emitter() {
diff --git a/scene/2d/navigation_obstacle_2d.cpp b/scene/2d/navigation_obstacle_2d.cpp
index e46bb79551..cbec4db4c5 100644
--- a/scene/2d/navigation_obstacle_2d.cpp
+++ b/scene/2d/navigation_obstacle_2d.cpp
@@ -153,7 +153,7 @@ void NavigationObstacle2D::reevaluate_agent_radius() {
 real_t NavigationObstacle2D::estimate_agent_radius() const {
 	if (parent_node2d && parent_node2d->is_inside_tree()) {
 		// Estimate the radius of this physics body
-		real_t radius = 0.0;
+		real_t max_radius = 0.0;
 		for (int i(0); i < parent_node2d->get_child_count(); i++) {
 			// For each collision shape
 			CollisionShape2D *cs = Object::cast_to<CollisionShape2D>(parent_node2d->get_child(i));
@@ -167,17 +167,17 @@ real_t NavigationObstacle2D::estimate_agent_radius() const {
 				Size2 s = cs->get_global_scale();
 				r *= MAX(s.x, s.y);
 				// Takes the biggest radius
-				radius = MAX(radius, r);
+				max_radius = MAX(max_radius, r);
 			} else if (cs && !cs->is_inside_tree()) {
 				WARN_PRINT("A CollisionShape2D of the NavigationObstacle2D parent node was not inside the SceneTree when estimating the obstacle radius."
 						   "\nMove the NavigationObstacle2D to a child position below any CollisionShape2D node of the parent node so the CollisionShape2D is already inside the SceneTree.");
 			}
 		}
 		Vector2 s = parent_node2d->get_global_scale();
-		radius *= MAX(s.x, s.y);
+		max_radius *= MAX(s.x, s.y);
 
-		if (radius > 0.0) {
-			return radius;
+		if (max_radius > 0.0) {
+			return max_radius;
 		}
 	}
 	return 1.0; // Never a 0 radius
diff --git a/scene/2d/parallax_background.cpp b/scene/2d/parallax_background.cpp
index f1a28b7852..b7e6eb8ea5 100644
--- a/scene/2d/parallax_background.cpp
+++ b/scene/2d/parallax_background.cpp
@@ -71,29 +71,29 @@ void ParallaxBackground::_update_scroll() {
 		return;
 	}
 
-	Vector2 ofs = base_offset + offset * base_scale;
+	Vector2 scroll_ofs = base_offset + offset * base_scale;
 
 	Size2 vps = get_viewport_size();
 
-	ofs = -ofs;
+	scroll_ofs = -scroll_ofs;
 	if (limit_begin.x < limit_end.x) {
-		if (ofs.x < limit_begin.x) {
-			ofs.x = limit_begin.x;
-		} else if (ofs.x + vps.x > limit_end.x) {
-			ofs.x = limit_end.x - vps.x;
+		if (scroll_ofs.x < limit_begin.x) {
+			scroll_ofs.x = limit_begin.x;
+		} else if (scroll_ofs.x + vps.x > limit_end.x) {
+			scroll_ofs.x = limit_end.x - vps.x;
 		}
 	}
 
 	if (limit_begin.y < limit_end.y) {
-		if (ofs.y < limit_begin.y) {
-			ofs.y = limit_begin.y;
-		} else if (ofs.y + vps.y > limit_end.y) {
-			ofs.y = limit_end.y - vps.y;
+		if (scroll_ofs.y < limit_begin.y) {
+			scroll_ofs.y = limit_begin.y;
+		} else if (scroll_ofs.y + vps.y > limit_end.y) {
+			scroll_ofs.y = limit_end.y - vps.y;
 		}
 	}
-	ofs = -ofs;
+	scroll_ofs = -scroll_ofs;
 
-	final_offset = ofs;
+	final_offset = scroll_ofs;
 
 	for (int i = 0; i < get_child_count(); i++) {
 		ParallaxLayer *l = Object::cast_to<ParallaxLayer>(get_child(i));
@@ -102,9 +102,9 @@ void ParallaxBackground::_update_scroll() {
 		}
 
 		if (ignore_camera_zoom) {
-			l->set_base_offset_and_scale((ofs + screen_offset * (scale - 1)) / scale, 1.0);
+			l->set_base_offset_and_scale((scroll_ofs + screen_offset * (scale - 1)) / scale, 1.0);
 		} else {
-			l->set_base_offset_and_scale(ofs, scale);
+			l->set_base_offset_and_scale(scroll_ofs, scale);
 		}
 	}
 }
diff --git a/scene/2d/parallax_layer.cpp b/scene/2d/parallax_layer.cpp
index 01e4bf19f3..feb1fcd90c 100644
--- a/scene/2d/parallax_layer.cpp
+++ b/scene/2d/parallax_layer.cpp
@@ -37,9 +37,9 @@ void ParallaxLayer::set_motion_scale(const Size2 &p_scale) {
 
 	ParallaxBackground *pb = Object::cast_to<ParallaxBackground>(get_parent());
 	if (pb && is_inside_tree()) {
-		Vector2 ofs = pb->get_final_offset();
-		real_t scale = pb->get_scroll_scale();
-		set_base_offset_and_scale(ofs, scale);
+		Vector2 final_ofs = pb->get_final_offset();
+		real_t scroll_scale = pb->get_scroll_scale();
+		set_base_offset_and_scale(final_ofs, scroll_scale);
 	}
 }
 
@@ -52,9 +52,9 @@ void ParallaxLayer::set_motion_offset(const Size2 &p_offset) {
 
 	ParallaxBackground *pb = Object::cast_to<ParallaxBackground>(get_parent());
 	if (pb && is_inside_tree()) {
-		Vector2 ofs = pb->get_final_offset();
-		real_t scale = pb->get_scroll_scale();
-		set_base_offset_and_scale(ofs, scale);
+		Vector2 final_ofs = pb->get_final_offset();
+		real_t scroll_scale = pb->get_scroll_scale();
+		set_base_offset_and_scale(final_ofs, scroll_scale);
 	}
 }
 
diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index d0e35c2ea2..0f3e6c7529 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -471,28 +471,28 @@ void RigidBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state) {
 		//put the ones to add
 
 		for (int i = 0; i < p_state->get_contact_count(); i++) {
-			RID rid = p_state->get_contact_collider(i);
-			ObjectID obj = p_state->get_contact_collider_id(i);
+			RID col_rid = p_state->get_contact_collider(i);
+			ObjectID col_obj = p_state->get_contact_collider_id(i);
 			int local_shape = p_state->get_contact_local_shape(i);
-			int shape = p_state->get_contact_collider_shape(i);
+			int col_shape = p_state->get_contact_collider_shape(i);
 
-			HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(obj);
+			HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(col_obj);
 			if (!E) {
-				toadd[toadd_count].rid = rid;
+				toadd[toadd_count].rid = col_rid;
 				toadd[toadd_count].local_shape = local_shape;
-				toadd[toadd_count].id = obj;
-				toadd[toadd_count].shape = shape;
+				toadd[toadd_count].id = col_obj;
+				toadd[toadd_count].shape = col_shape;
 				toadd_count++;
 				continue;
 			}
 
-			ShapePair sp(shape, local_shape);
+			ShapePair sp(col_shape, local_shape);
 			int idx = E->value.shapes.find(sp);
 			if (idx == -1) {
-				toadd[toadd_count].rid = rid;
+				toadd[toadd_count].rid = col_rid;
 				toadd[toadd_count].local_shape = local_shape;
-				toadd[toadd_count].id = obj;
-				toadd[toadd_count].shape = shape;
+				toadd[toadd_count].id = col_obj;
+				toadd[toadd_count].shape = col_shape;
 				toadd_count++;
 				continue;
 			}
diff --git a/scene/2d/skeleton_2d.cpp b/scene/2d/skeleton_2d.cpp
index b5759c54f7..dd016d5e92 100644
--- a/scene/2d/skeleton_2d.cpp
+++ b/scene/2d/skeleton_2d.cpp
@@ -146,9 +146,9 @@ void Bone2D::_notification(int p_what) {
 			queue_redraw();
 
 			if (get_parent()) {
-				Bone2D *parent_bone = Object::cast_to<Bone2D>(get_parent());
-				if (parent_bone) {
-					parent_bone->queue_redraw();
+				Bone2D *p_bone = Object::cast_to<Bone2D>(get_parent());
+				if (p_bone) {
+					p_bone->queue_redraw();
 				}
 			}
 #endif // TOOLS_ENABLED
diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index 5acf661425..26627a4fca 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -43,10 +43,10 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 
 	ERR_FAIL_COND_V(is_center_bit(), output);
 
-	Ref<TileSet> tile_set = tile_map->get_tileset();
-	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
+	Ref<TileSet> ts = tile_map->get_tileset();
+	ERR_FAIL_COND_V(!ts.is_valid(), output);
 
-	TileSet::TileShape shape = tile_set->get_tile_shape();
+	TileSet::TileShape shape = ts->get_tile_shape();
 	if (shape == TileSet::TILE_SHAPE_SQUARE) {
 		switch (bit) {
 			case 1:
@@ -87,7 +87,7 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 		}
 	} else {
 		// Half offset shapes.
-		TileSet::TileOffsetAxis offset_axis = tile_set->get_tile_offset_axis();
+		TileSet::TileOffsetAxis offset_axis = ts->get_tile_offset_axis();
 		if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
 			switch (bit) {
 				case 1:
@@ -150,8 +150,8 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, int p_terrain) {
 	tile_map = p_tile_map;
 
-	Ref<TileSet> tile_set = tile_map->get_tileset();
-	ERR_FAIL_COND(!tile_set.is_valid());
+	Ref<TileSet> ts = tile_map->get_tileset();
+	ERR_FAIL_COND(!ts.is_valid());
 
 	bit = 0;
 	base_cell_coords = p_position;
@@ -162,10 +162,10 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 	// The way we build the constraint make it easy to detect conflicting constraints.
 	tile_map = p_tile_map;
 
-	Ref<TileSet> tile_set = tile_map->get_tileset();
-	ERR_FAIL_COND(!tile_set.is_valid());
+	Ref<TileSet> ts = tile_map->get_tileset();
+	ERR_FAIL_COND(!ts.is_valid());
 
-	TileSet::TileShape shape = tile_set->get_tile_shape();
+	TileSet::TileShape shape = ts->get_tile_shape();
 	if (shape == TileSet::TILE_SHAPE_SQUARE) {
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
@@ -244,7 +244,7 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 		}
 	} else {
 		// Half-offset shapes
-		TileSet::TileOffsetAxis offset_axis = tile_set->get_tile_offset_axis();
+		TileSet::TileOffsetAxis offset_axis = ts->get_tile_offset_axis();
 		if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
 			switch (p_bit) {
 				case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
@@ -758,12 +758,12 @@ void TileMap::set_y_sort_enabled(bool p_enable) {
 }
 
 Vector2i TileMap::_coords_to_quadrant_coords(int p_layer, const Vector2i &p_coords) const {
-	int quadrant_size = get_effective_quadrant_size(p_layer);
+	int quad_size = get_effective_quadrant_size(p_layer);
 
 	// Rounding down, instead of simply rounding towards zero (truncating)
 	return Vector2i(
-			p_coords.x > 0 ? p_coords.x / quadrant_size : (p_coords.x - (quadrant_size - 1)) / quadrant_size,
-			p_coords.y > 0 ? p_coords.y / quadrant_size : (p_coords.y - (quadrant_size - 1)) / quadrant_size);
+			p_coords.x > 0 ? p_coords.x / quad_size : (p_coords.x - (quad_size - 1)) / quad_size,
+			p_coords.y > 0 ? p_coords.y / quad_size : (p_coords.y - (quad_size - 1)) / quad_size);
 }
 
 HashMap<Vector2i, TileMapQuadrant>::Iterator TileMap::_create_quadrant(int p_layer, const Vector2i &p_qk) {
@@ -1008,7 +1008,7 @@ void TileMap::_recompute_rect_cache() {
 void TileMap::_rendering_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_ENTER_CANVAS: {
-			bool visible = is_visible_in_tree();
+			bool node_visible = is_visible_in_tree();
 			for (int layer = 0; layer < (int)layers.size(); layer++) {
 				for (KeyValue<Vector2i, TileMapQuadrant> &E_quadrant : layers[layer].quadrant_map) {
 					TileMapQuadrant &q = E_quadrant.value;
@@ -1017,14 +1017,14 @@ void TileMap::_rendering_notification(int p_what) {
 						xform.set_origin(map_to_local(kv.key));
 						RS::get_singleton()->canvas_light_occluder_attach_to_canvas(kv.value, get_canvas());
 						RS::get_singleton()->canvas_light_occluder_set_transform(kv.value, get_global_transform() * xform);
-						RS::get_singleton()->canvas_light_occluder_set_enabled(kv.value, visible);
+						RS::get_singleton()->canvas_light_occluder_set_enabled(kv.value, node_visible);
 					}
 				}
 			}
 		} break;
 
 		case NOTIFICATION_VISIBILITY_CHANGED: {
-			bool visible = is_visible_in_tree();
+			bool node_visible = is_visible_in_tree();
 			for (int layer = 0; layer < (int)layers.size(); layer++) {
 				for (KeyValue<Vector2i, TileMapQuadrant> &E_quadrant : layers[layer].quadrant_map) {
 					TileMapQuadrant &q = E_quadrant.value;
@@ -1034,7 +1034,7 @@ void TileMap::_rendering_notification(int p_what) {
 						Transform2D xform;
 						xform.set_origin(E_cell.key);
 						for (const KeyValue<Vector2i, RID> &kv : q.occluders) {
-							RS::get_singleton()->canvas_light_occluder_set_enabled(kv.value, visible);
+							RS::get_singleton()->canvas_light_occluder_set_enabled(kv.value, node_visible);
 						}
 					}
 				}
@@ -1116,7 +1116,7 @@ void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 	ERR_FAIL_COND(!is_inside_tree());
 	ERR_FAIL_COND(!tile_set.is_valid());
 
-	bool visible = is_visible_in_tree();
+	bool node_visible = is_visible_in_tree();
 
 	SelfList<TileMapQuadrant> *q_list_element = r_dirty_quadrant_list.first();
 	while (q_list_element) {
@@ -1139,18 +1139,18 @@ void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 		// Those allow to group cell per material or z-index.
 		Ref<Material> prev_material;
 		int prev_z_index = 0;
-		RID prev_canvas_item;
+		RID prev_ci;
 
-		Color modulate = get_self_modulate();
-		modulate *= get_layer_modulate(q.layer);
+		Color tile_modulate = get_self_modulate();
+		tile_modulate *= get_layer_modulate(q.layer);
 		if (selected_layer >= 0) {
 			int z1 = get_layer_z_index(q.layer);
 			int z2 = get_layer_z_index(selected_layer);
 			if (z1 < z2 || (z1 == z2 && q.layer < selected_layer)) {
-				modulate = modulate.darkened(0.5);
+				tile_modulate = tile_modulate.darkened(0.5);
 			} else if (z1 > z2 || (z1 == z2 && q.layer > selected_layer)) {
-				modulate = modulate.darkened(0.5);
-				modulate.a *= 0.3;
+				tile_modulate = tile_modulate.darkened(0.5);
+				tile_modulate.a *= 0.3;
 			}
 		}
 
@@ -1177,53 +1177,53 @@ void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 					}
 
 					Ref<Material> mat = tile_data->get_material();
-					int z_index = tile_data->get_z_index();
+					int tile_z_index = tile_data->get_z_index();
 
 					// Quandrant pos.
-					Vector2 position = map_to_local(q.coords * get_effective_quadrant_size(q.layer));
+					Vector2 tile_position = map_to_local(q.coords * get_effective_quadrant_size(q.layer));
 					if (is_y_sort_enabled() && layers[q.layer].y_sort_enabled) {
 						// When Y-sorting, the quandrant size is sure to be 1, we can thus offset the CanvasItem.
-						position.y += layers[q.layer].y_sort_origin + tile_data->get_y_sort_origin();
+						tile_position.y += layers[q.layer].y_sort_origin + tile_data->get_y_sort_origin();
 					}
 
 					// --- CanvasItems ---
 					// Create two canvas items, for rendering and debug.
-					RID canvas_item;
+					RID ci;
 
 					// Check if the material or the z_index changed.
-					if (prev_canvas_item == RID() || prev_material != mat || prev_z_index != z_index) {
+					if (prev_ci == RID() || prev_material != mat || prev_z_index != tile_z_index) {
 						// If so, create a new CanvasItem.
-						canvas_item = rs->canvas_item_create();
+						ci = rs->canvas_item_create();
 						if (mat.is_valid()) {
-							rs->canvas_item_set_material(canvas_item, mat->get_rid());
+							rs->canvas_item_set_material(ci, mat->get_rid());
 						}
-						rs->canvas_item_set_parent(canvas_item, layers[q.layer].canvas_item);
-						rs->canvas_item_set_use_parent_material(canvas_item, get_use_parent_material() || get_material().is_valid());
+						rs->canvas_item_set_parent(ci, layers[q.layer].canvas_item);
+						rs->canvas_item_set_use_parent_material(ci, get_use_parent_material() || get_material().is_valid());
 
 						Transform2D xform;
-						xform.set_origin(position);
-						rs->canvas_item_set_transform(canvas_item, xform);
+						xform.set_origin(tile_position);
+						rs->canvas_item_set_transform(ci, xform);
 
-						rs->canvas_item_set_light_mask(canvas_item, get_light_mask());
-						rs->canvas_item_set_z_as_relative_to_parent(canvas_item, true);
-						rs->canvas_item_set_z_index(canvas_item, z_index);
+						rs->canvas_item_set_light_mask(ci, get_light_mask());
+						rs->canvas_item_set_z_as_relative_to_parent(ci, true);
+						rs->canvas_item_set_z_index(ci, tile_z_index);
 
-						rs->canvas_item_set_default_texture_filter(canvas_item, RS::CanvasItemTextureFilter(get_texture_filter()));
-						rs->canvas_item_set_default_texture_repeat(canvas_item, RS::CanvasItemTextureRepeat(get_texture_repeat()));
+						rs->canvas_item_set_default_texture_filter(ci, RS::CanvasItemTextureFilter(get_texture_filter()));
+						rs->canvas_item_set_default_texture_repeat(ci, RS::CanvasItemTextureRepeat(get_texture_repeat()));
 
-						q.canvas_items.push_back(canvas_item);
+						q.canvas_items.push_back(ci);
 
-						prev_canvas_item = canvas_item;
+						prev_ci = ci;
 						prev_material = mat;
-						prev_z_index = z_index;
+						prev_z_index = tile_z_index;
 
 					} else {
 						// Keep the same canvas_item to draw on.
-						canvas_item = prev_canvas_item;
+						ci = prev_ci;
 					}
 
 					// Drawing the tile in the canvas item.
-					draw_tile(canvas_item, E_cell.key - position, tile_set, c.source_id, c.get_atlas_coords(), c.alternative_tile, -1, modulate, tile_data);
+					draw_tile(ci, E_cell.key - tile_position, tile_set, c.source_id, c.get_atlas_coords(), c.alternative_tile, -1, tile_modulate, tile_data);
 
 					// --- Occluders ---
 					for (int i = 0; i < tile_set->get_occlusion_layers_count(); i++) {
@@ -1231,7 +1231,7 @@ void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 						xform.set_origin(E_cell.key);
 						if (tile_data->get_occluder(i).is_valid()) {
 							RID occluder_id = rs->canvas_light_occluder_create();
-							rs->canvas_light_occluder_set_enabled(occluder_id, visible);
+							rs->canvas_light_occluder_set_enabled(occluder_id, node_visible);
 							rs->canvas_light_occluder_set_transform(occluder_id, get_global_transform() * xform);
 							rs->canvas_light_occluder_set_polygon(occluder_id, tile_data->get_occluder(i)->get_rid());
 							rs->canvas_light_occluder_attach_to_canvas(occluder_id, get_canvas());
@@ -1445,7 +1445,7 @@ void TileMap::_physics_notification(int p_what) {
 #endif
 			if (is_inside_tree() && (!collision_animatable || in_editor)) {
 				// Update the new transform directly if we are not in animatable mode.
-				Transform2D global_transform = get_global_transform();
+				Transform2D gl_transform = get_global_transform();
 				for (int layer = 0; layer < (int)layers.size(); layer++) {
 					for (KeyValue<Vector2i, TileMapQuadrant> &E : layers[layer].quadrant_map) {
 						TileMapQuadrant &q = E.value;
@@ -1453,7 +1453,7 @@ void TileMap::_physics_notification(int p_what) {
 						for (RID body : q.bodies) {
 							Transform2D xform;
 							xform.set_origin(map_to_local(bodies_coords[body]));
-							xform = global_transform * xform;
+							xform = gl_transform * xform;
 							PhysicsServer2D::get_singleton()->body_set_state(body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
 						}
 					}
@@ -1496,9 +1496,9 @@ void TileMap::_physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r
 	ERR_FAIL_COND(!is_inside_tree());
 	ERR_FAIL_COND(!tile_set.is_valid());
 
-	Transform2D global_transform = get_global_transform();
-	last_valid_transform = global_transform;
-	new_transform = global_transform;
+	Transform2D gl_transform = get_global_transform();
+	last_valid_transform = gl_transform;
+	new_transform = gl_transform;
 	PhysicsServer2D *ps = PhysicsServer2D::get_singleton();
 	RID space = get_world_2d()->get_space();
 
@@ -1546,7 +1546,7 @@ void TileMap::_physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r
 
 						Transform2D xform;
 						xform.set_origin(map_to_local(E_cell));
-						xform = global_transform * xform;
+						xform = gl_transform * xform;
 						ps->body_set_state(body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
 
 						ps->body_attach_object_instance_id(body, get_instance_id());
@@ -2819,9 +2819,9 @@ Vector<int> TileMap::_get_tile_data(int p_layer) const {
 
 	// Export tile data to raw format
 	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
-	Vector<int> data;
-	data.resize(tile_map.size() * 3);
-	int *w = data.ptrw();
+	Vector<int> tile_data;
+	tile_data.resize(tile_map.size() * 3);
+	int *w = tile_data.ptrw();
 
 	// Save in highest format
 
@@ -2837,7 +2837,7 @@ Vector<int> TileMap::_get_tile_data(int p_layer) const {
 		idx += 3;
 	}
 
-	return data;
+	return tile_data;
 }
 
 void TileMap::_build_runtime_update_tile_data(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {