Refactor layer_mask to collision_layer

6 files changed, 42 insertions, 42 deletions

diff --git a/scene/3d/area.cpp b/scene/3d/area.cpp
index 8dae078e5..39a4e926b 100644
--- a/scene/3d/area.cpp
+++ b/scene/3d/area.cpp
@@ -489,15 +489,15 @@ uint32_t Area::get_collision_mask() const {
 
 	return collision_mask;
 }
-void Area::set_layer_mask(uint32_t p_mask) {
+void Area::set_collision_layer(uint32_t p_layer) {
 
-	layer_mask = p_mask;
-	PhysicsServer::get_singleton()->area_set_layer_mask(get_rid(), p_mask);
+	collision_layer = p_layer;
+	PhysicsServer::get_singleton()->area_set_collision_layer(get_rid(), p_layer);
 }
 
-uint32_t Area::get_layer_mask() const {
+uint32_t Area::get_collision_layer() const {
 
-	return layer_mask;
+	return collision_layer;
 }
 
 void Area::set_collision_mask_bit(int p_bit, bool p_value) {
@@ -515,19 +515,19 @@ bool Area::get_collision_mask_bit(int p_bit) const {
 	return get_collision_mask() & (1 << p_bit);
 }
 
-void Area::set_layer_mask_bit(int p_bit, bool p_value) {
+void Area::set_collision_layer_bit(int p_bit, bool p_value) {
 
-	uint32_t mask = get_layer_mask();
+	uint32_t layer = get_collision_layer();
 	if (p_value)
-		mask |= 1 << p_bit;
+		layer |= 1 << p_bit;
 	else
-		mask &= ~(1 << p_bit);
-	set_layer_mask(mask);
+		layer &= ~(1 << p_bit);
+	set_collision_layer(layer);
 }
 
-bool Area::get_layer_mask_bit(int p_bit) const {
+bool Area::get_collision_layer_bit(int p_bit) const {
 
-	return get_layer_mask() & (1 << p_bit);
+	return get_collision_layer() & (1 << p_bit);
 }
 
 void Area::_bind_methods() {
@@ -565,14 +565,14 @@ void Area::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_collision_mask", "collision_mask"), &Area::set_collision_mask);
 	ClassDB::bind_method(D_METHOD("get_collision_mask"), &Area::get_collision_mask);
 
-	ClassDB::bind_method(D_METHOD("set_layer_mask", "layer_mask"), &Area::set_layer_mask);
-	ClassDB::bind_method(D_METHOD("get_layer_mask"), &Area::get_layer_mask);
+	ClassDB::bind_method(D_METHOD("set_collision_layer", "collision_layer"), &Area::set_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_collision_layer"), &Area::get_collision_layer);
 
 	ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &Area::set_collision_mask_bit);
 	ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &Area::get_collision_mask_bit);
 
-	ClassDB::bind_method(D_METHOD("set_layer_mask_bit", "bit", "value"), &Area::set_layer_mask_bit);
-	ClassDB::bind_method(D_METHOD("get_layer_mask_bit", "bit"), &Area::get_layer_mask_bit);
+	ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &Area::set_collision_layer_bit);
+	ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &Area::get_collision_layer_bit);
 
 	ClassDB::bind_method(D_METHOD("set_monitorable", "enable"), &Area::set_monitorable);
 	ClassDB::bind_method(D_METHOD("is_monitorable"), &Area::is_monitorable);
@@ -610,7 +610,7 @@ void Area::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "monitoring"), "set_monitoring", "is_monitoring");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "monitorable"), "set_monitorable", "is_monitorable");
 	ADD_GROUP("Collision", "collision_");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layers", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_layer_mask", "get_layer_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
 }
 
@@ -628,7 +628,7 @@ Area::Area()
 	priority = 0;
 	monitoring = false;
 	collision_mask = 1;
-	layer_mask = 1;
+	collision_layer = 1;
 	set_ray_pickable(false);
 	set_monitoring(true);
 	set_monitorable(true);
diff --git a/scene/3d/area.h b/scene/3d/area.h
index 64bbae923..279a52ee6 100644
--- a/scene/3d/area.h
+++ b/scene/3d/area.h
@@ -55,7 +55,7 @@ private:
 	real_t angular_damp;
 	real_t linear_damp;
 	uint32_t collision_mask;
-	uint32_t layer_mask;
+	uint32_t collision_layer;
 	int priority;
 	bool monitoring;
 	bool monitorable;
@@ -164,14 +164,14 @@ public:
 	void set_collision_mask(uint32_t p_mask);
 	uint32_t get_collision_mask() const;
 
-	void set_layer_mask(uint32_t p_mask);
-	uint32_t get_layer_mask() const;
+	void set_collision_layer(uint32_t p_layer);
+	uint32_t get_collision_layer() const;
 
 	void set_collision_mask_bit(int p_bit, bool p_value);
 	bool get_collision_mask_bit(int p_bit) const;
 
-	void set_layer_mask_bit(int p_bit, bool p_value);
-	bool get_layer_mask_bit(int p_bit) const;
+	void set_collision_layer_bit(int p_bit, bool p_value);
+	bool get_collision_layer_bit(int p_bit) const;
 
 	Array get_overlapping_bodies() const;
 	Array get_overlapping_areas() const; //function for script
diff --git a/scene/3d/physics_body.cpp b/scene/3d/physics_body.cpp
index 98babedf0..3a55a2bc3 100644
--- a/scene/3d/physics_body.cpp
+++ b/scene/3d/physics_body.cpp
@@ -59,15 +59,15 @@ float PhysicsBody::get_inverse_mass() const {
 	return 0;
 }
 
-void PhysicsBody::set_collision_layer(uint32_t p_mask) {
+void PhysicsBody::set_collision_layer(uint32_t p_layer) {
 
-	layer_mask = p_mask;
-	PhysicsServer::get_singleton()->body_set_layer_mask(get_rid(), p_mask);
+	collision_layer = p_layer;
+	PhysicsServer::get_singleton()->body_set_collision_layer(get_rid(), p_layer);
 }
 
 uint32_t PhysicsBody::get_collision_layer() const {
 
-	return layer_mask;
+	return collision_layer;
 }
 
 void PhysicsBody::set_collision_mask(uint32_t p_mask) {
@@ -167,7 +167,7 @@ void PhysicsBody::_bind_methods() {
 PhysicsBody::PhysicsBody(PhysicsServer::BodyMode p_mode)
 	: CollisionObject(PhysicsServer::get_singleton()->body_create(p_mode), false) {
 
-	layer_mask = 1;
+	collision_layer = 1;
 	collision_mask = 1;
 }
 
diff --git a/scene/3d/physics_body.h b/scene/3d/physics_body.h
index d13f84dc1..db4147f8f 100644
--- a/scene/3d/physics_body.h
+++ b/scene/3d/physics_body.h
@@ -38,7 +38,7 @@ class PhysicsBody : public CollisionObject {
 
 	GDCLASS(PhysicsBody, CollisionObject);
 
-	uint32_t layer_mask;
+	uint32_t collision_layer;
 	uint32_t collision_mask;
 
 	void _set_layers(uint32_t p_mask);
@@ -54,7 +54,7 @@ public:
 	virtual Vector3 get_angular_velocity() const;
 	virtual float get_inverse_mass() const;
 
-	void set_collision_layer(uint32_t p_mask);
+	void set_collision_layer(uint32_t p_layer);
 	uint32_t get_collision_layer() const;
 
 	void set_collision_mask(uint32_t p_mask);
diff --git a/scene/3d/ray_cast.cpp b/scene/3d/ray_cast.cpp
index 345afd3ed..67e7fb0e1 100644
--- a/scene/3d/ray_cast.cpp
+++ b/scene/3d/ray_cast.cpp
@@ -46,14 +46,14 @@ Vector3 RayCast::get_cast_to() const {
 	return cast_to;
 }
 
-void RayCast::set_layer_mask(uint32_t p_mask) {
+void RayCast::set_collision_layer(uint32_t p_layer) {
 
-	layer_mask = p_mask;
+	collision_layer = p_layer;
 }
 
-uint32_t RayCast::get_layer_mask() const {
+uint32_t RayCast::get_collision_layer() const {
 
-	return layer_mask;
+	return collision_layer;
 }
 
 void RayCast::set_type_mask(uint32_t p_mask) {
@@ -170,7 +170,7 @@ void RayCast::_update_raycast_state() {
 
 	PhysicsDirectSpaceState::RayResult rr;
 
-	if (dss->intersect_ray(gt.get_origin(), gt.xform(to), rr, exclude, layer_mask, type_mask)) {
+	if (dss->intersect_ray(gt.get_origin(), gt.xform(to), rr, exclude, collision_layer, type_mask)) {
 
 		collided = true;
 		against = rr.collider_id;
@@ -243,15 +243,15 @@ void RayCast::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("clear_exceptions"), &RayCast::clear_exceptions);
 
-	ClassDB::bind_method(D_METHOD("set_layer_mask", "mask"), &RayCast::set_layer_mask);
-	ClassDB::bind_method(D_METHOD("get_layer_mask"), &RayCast::get_layer_mask);
+	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &RayCast::set_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_collision_layer"), &RayCast::get_collision_layer);
 
 	ClassDB::bind_method(D_METHOD("set_type_mask", "mask"), &RayCast::set_type_mask);
 	ClassDB::bind_method(D_METHOD("get_type_mask"), &RayCast::get_type_mask);
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "is_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "cast_to"), "set_cast_to", "get_cast_to");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "layer_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_layer_mask", "get_layer_mask");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "type_mask", PROPERTY_HINT_FLAGS, "Static,Kinematic,Rigid,Character,Area"), "set_type_mask", "get_type_mask");
 }
 
@@ -323,7 +323,7 @@ RayCast::RayCast() {
 	against = 0;
 	collided = false;
 	against_shape = 0;
-	layer_mask = 1;
+	collision_layer = 1;
 	type_mask = PhysicsDirectSpaceState::TYPE_MASK_COLLISION;
 	cast_to = Vector3(0, -1, 0);
 	debug_shape = NULL;
diff --git a/scene/3d/ray_cast.h b/scene/3d/ray_cast.h
index 63a53d724..e9b34c4f7 100644
--- a/scene/3d/ray_cast.h
+++ b/scene/3d/ray_cast.h
@@ -47,7 +47,7 @@ class RayCast : public Spatial {
 
 	Set<RID> exclude;
 
-	uint32_t layer_mask;
+	uint32_t collision_layer;
 	uint32_t type_mask;
 
 	Node *debug_shape;
@@ -69,8 +69,8 @@ public:
 	void set_cast_to(const Vector3 &p_point);
 	Vector3 get_cast_to() const;
 
-	void set_layer_mask(uint32_t p_mask);
-	uint32_t get_layer_mask() const;
+	void set_collision_layer(uint32_t p_layer);
+	uint32_t get_collision_layer() const;
 
 	void set_type_mask(uint32_t p_mask);
 	uint32_t get_type_mask() const;