1 files changed, 237 insertions, 15 deletions

diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index 4eb798de11..80fa2454ec 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -47,18 +47,77 @@ void CSGShape::set_use_collision(bool p_enable) {
 		PhysicsServer::get_singleton()->body_set_state(root_collision_instance, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
 		PhysicsServer::get_singleton()->body_add_shape(root_collision_instance, root_collision_shape->get_rid());
 		PhysicsServer::get_singleton()->body_set_space(root_collision_instance, get_world()->get_space());
+		PhysicsServer::get_singleton()->body_attach_object_instance_id(root_collision_instance, get_instance_id());
+		set_collision_layer(collision_layer);
+		set_collision_mask(collision_mask);
 		_make_dirty(); //force update
 	} else {
 		PhysicsServer::get_singleton()->free(root_collision_instance);
 		root_collision_instance = RID();
 		root_collision_shape.unref();
 	}
+	_change_notify();
 }
 
 bool CSGShape::is_using_collision() const {
 	return use_collision;
 }
 
+void CSGShape::set_collision_layer(uint32_t p_layer) {
+	collision_layer = p_layer;
+	if (root_collision_instance.is_valid()) {
+		PhysicsServer::get_singleton()->body_set_collision_layer(root_collision_instance, p_layer);
+	}
+}
+
+uint32_t CSGShape::get_collision_layer() const {
+
+	return collision_layer;
+}
+
+void CSGShape::set_collision_mask(uint32_t p_mask) {
+
+	collision_mask = p_mask;
+	if (root_collision_instance.is_valid()) {
+		PhysicsServer::get_singleton()->body_set_collision_mask(root_collision_instance, p_mask);
+	}
+}
+
+uint32_t CSGShape::get_collision_mask() const {
+
+	return collision_mask;
+}
+
+void CSGShape::set_collision_mask_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_collision_mask();
+	if (p_value)
+		mask |= 1 << p_bit;
+	else
+		mask &= ~(1 << p_bit);
+	set_collision_mask(mask);
+}
+
+bool CSGShape::get_collision_mask_bit(int p_bit) const {
+
+	return get_collision_mask() & (1 << p_bit);
+}
+
+void CSGShape::set_collision_layer_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_collision_layer();
+	if (p_value)
+		mask |= 1 << p_bit;
+	else
+		mask &= ~(1 << p_bit);
+	set_collision_layer(mask);
+}
+
+bool CSGShape::get_collision_layer_bit(int p_bit) const {
+
+	return get_collision_layer() & (1 << p_bit);
+}
+
 bool CSGShape::is_root_shape() const {
 
 	return !parent;
@@ -159,6 +218,61 @@ CSGBrush *CSGShape::_get_brush() {
 	return brush;
 }
 
+int CSGShape::mikktGetNumFaces(const SMikkTSpaceContext *pContext) {
+	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
+
+	return surface.vertices.size() / 3;
+}
+
+int CSGShape::mikktGetNumVerticesOfFace(const SMikkTSpaceContext *pContext, const int iFace) {
+	// always 3
+	return 3;
+}
+
+void CSGShape::mikktGetPosition(const SMikkTSpaceContext *pContext, float fvPosOut[], const int iFace, const int iVert) {
+	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
+
+	Vector3 v = surface.verticesw[iFace * 3 + iVert];
+	fvPosOut[0] = v.x;
+	fvPosOut[1] = v.y;
+	fvPosOut[2] = v.z;
+}
+
+void CSGShape::mikktGetNormal(const SMikkTSpaceContext *pContext, float fvNormOut[], const int iFace, const int iVert) {
+	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
+
+	Vector3 n = surface.normalsw[iFace * 3 + iVert];
+	fvNormOut[0] = n.x;
+	fvNormOut[1] = n.y;
+	fvNormOut[2] = n.z;
+}
+
+void CSGShape::mikktGetTexCoord(const SMikkTSpaceContext *pContext, float fvTexcOut[], const int iFace, const int iVert) {
+	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
+
+	Vector2 t = surface.uvsw[iFace * 3 + iVert];
+	fvTexcOut[0] = t.x;
+	fvTexcOut[1] = t.y;
+}
+
+void CSGShape::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
+		const tbool bIsOrientationPreserving, const int iFace, const int iVert) {
+
+	ShapeUpdateSurface &surface = *((ShapeUpdateSurface *)pContext->m_pUserData);
+
+	int i = iFace * 3 + iVert;
+	Vector3 normal = surface.normalsw[i];
+	Vector3 tangent = Vector3(fvTangent[0], fvTangent[1], fvTangent[2]);
+	Vector3 bitangent = Vector3(-fvBiTangent[0], -fvBiTangent[1], -fvBiTangent[2]); // for some reason these are reversed, something with the coordinate system in Godot
+	float d = bitangent.dot(normal.cross(tangent));
+
+	i *= 4;
+	surface.tansw[i++] = tangent.x;
+	surface.tansw[i++] = tangent.y;
+	surface.tansw[i++] = tangent.z;
+	surface.tansw[i++] = d < 0 ? -1 : 1;
+}
+
 void CSGShape::_update_shape() {
 
 	if (parent)
@@ -211,6 +325,9 @@ void CSGShape::_update_shape() {
 		surfaces.write[i].vertices.resize(face_count[i] * 3);
 		surfaces.write[i].normals.resize(face_count[i] * 3);
 		surfaces.write[i].uvs.resize(face_count[i] * 3);
+		if (calculate_tangents) {
+			surfaces.write[i].tans.resize(face_count[i] * 3 * 4);
+		}
 		surfaces.write[i].last_added = 0;
 
 		if (i != surfaces.size() - 1) {
@@ -220,6 +337,9 @@ void CSGShape::_update_shape() {
 		surfaces.write[i].verticesw = surfaces.write[i].vertices.write();
 		surfaces.write[i].normalsw = surfaces.write[i].normals.write();
 		surfaces.write[i].uvsw = surfaces.write[i].uvs.write();
+		if (calculate_tangents) {
+			surfaces.write[i].tansw = surfaces.write[i].tans.write();
+		}
 	}
 
 	//fill arrays
@@ -274,9 +394,19 @@ void CSGShape::_update_shape() {
 					normal = -normal;
 				}
 
-				surfaces[idx].verticesw[last + order[j]] = v;
-				surfaces[idx].uvsw[last + order[j]] = n->faces[i].uvs[j];
-				surfaces[idx].normalsw[last + order[j]] = normal;
+				int k = last + order[j];
+				surfaces[idx].verticesw[k] = v;
+				surfaces[idx].uvsw[k] = n->faces[i].uvs[j];
+				surfaces[idx].normalsw[k] = normal;
+
+				if (calculate_tangents) {
+					// zero out our tangents for now
+					k *= 4;
+					surfaces[idx].tansw[k++] = 0.0;
+					surfaces[idx].tansw[k++] = 0.0;
+					surfaces[idx].tansw[k++] = 0.0;
+					surfaces[idx].tansw[k++] = 0.0;
+				}
 			}
 
 			surfaces.write[idx].last_added += 3;
@@ -287,20 +417,43 @@ void CSGShape::_update_shape() {
 	//create surfaces
 
 	for (int i = 0; i < surfaces.size(); i++) {
+		// calculate tangents for this surface
+		bool have_tangents = calculate_tangents;
+		if (have_tangents) {
+			SMikkTSpaceInterface mkif;
+			mkif.m_getNormal = mikktGetNormal;
+			mkif.m_getNumFaces = mikktGetNumFaces;
+			mkif.m_getNumVerticesOfFace = mikktGetNumVerticesOfFace;
+			mkif.m_getPosition = mikktGetPosition;
+			mkif.m_getTexCoord = mikktGetTexCoord;
+			mkif.m_setTSpace = mikktSetTSpaceDefault;
+			mkif.m_setTSpaceBasic = NULL;
+
+			SMikkTSpaceContext msc;
+			msc.m_pInterface = &mkif;
+			msc.m_pUserData = &surfaces.write[i];
+			have_tangents = genTangSpaceDefault(&msc);
+		}
 
+		// unset write access
 		surfaces.write[i].verticesw = PoolVector<Vector3>::Write();
 		surfaces.write[i].normalsw = PoolVector<Vector3>::Write();
 		surfaces.write[i].uvsw = PoolVector<Vector2>::Write();
+		surfaces.write[i].tansw = PoolVector<float>::Write();
 
 		if (surfaces[i].last_added == 0)
 			continue;
 
+		// and convert to surface array
 		Array array;
 		array.resize(Mesh::ARRAY_MAX);
 
 		array[Mesh::ARRAY_VERTEX] = surfaces[i].vertices;
 		array[Mesh::ARRAY_NORMAL] = surfaces[i].normals;
 		array[Mesh::ARRAY_TEX_UV] = surfaces[i].uvs;
+		if (have_tangents) {
+			array[Mesh::ARRAY_TANGENT] = surfaces[i].tans;
+		}
 
 		int idx = root_mesh->get_surface_count();
 		root_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, array);
@@ -363,6 +516,9 @@ void CSGShape::_notification(int p_what) {
 			PhysicsServer::get_singleton()->body_set_state(root_collision_instance, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
 			PhysicsServer::get_singleton()->body_add_shape(root_collision_instance, root_collision_shape->get_rid());
 			PhysicsServer::get_singleton()->body_set_space(root_collision_instance, get_world()->get_space());
+			PhysicsServer::get_singleton()->body_attach_object_instance_id(root_collision_instance, get_instance_id());
+			set_collision_layer(collision_layer);
+			set_collision_mask(collision_mask);
 		}
 
 		_make_dirty();
@@ -381,7 +537,7 @@ void CSGShape::_notification(int p_what) {
 			parent->_make_dirty();
 		parent = NULL;
 
-		if (use_collision && is_root_shape()) {
+		if (use_collision && is_root_shape() && root_collision_instance.is_valid()) {
 			PhysicsServer::get_singleton()->free(root_collision_instance);
 			root_collision_instance = RID();
 			root_collision_shape.unref();
@@ -400,10 +556,22 @@ CSGShape::Operation CSGShape::get_operation() const {
 	return operation;
 }
 
+void CSGShape::set_calculate_tangents(bool p_calculate_tangents) {
+	calculate_tangents = p_calculate_tangents;
+	_make_dirty();
+}
+
+bool CSGShape::is_calculating_tangents() const {
+	return calculate_tangents;
+}
+
 void CSGShape::_validate_property(PropertyInfo &property) const {
-	if (is_inside_tree() && property.name.begins_with("use_collision") && !is_root_shape()) {
+	bool is_collision_prefixed = property.name.begins_with("collision_");
+	if ((is_collision_prefixed || property.name.begins_with("use_collision")) && is_inside_tree() && !is_root_shape()) {
 		//hide collision if not root
 		property.usage = PROPERTY_USAGE_NOEDITOR;
+	} else if (is_collision_prefixed && !bool(get("use_collision"))) {
+		property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
 	}
 }
 
@@ -415,15 +583,35 @@ void CSGShape::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_operation", "operation"), &CSGShape::set_operation);
 	ClassDB::bind_method(D_METHOD("get_operation"), &CSGShape::get_operation);
 
+	ClassDB::bind_method(D_METHOD("set_snap", "snap"), &CSGShape::set_snap);
+	ClassDB::bind_method(D_METHOD("get_snap"), &CSGShape::get_snap);
+
 	ClassDB::bind_method(D_METHOD("set_use_collision", "operation"), &CSGShape::set_use_collision);
 	ClassDB::bind_method(D_METHOD("is_using_collision"), &CSGShape::is_using_collision);
 
-	ClassDB::bind_method(D_METHOD("set_snap", "snap"), &CSGShape::set_snap);
-	ClassDB::bind_method(D_METHOD("get_snap"), &CSGShape::get_snap);
+	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &CSGShape::set_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_collision_layer"), &CSGShape::get_collision_layer);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &CSGShape::set_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &CSGShape::get_collision_mask);
+
+	ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &CSGShape::set_collision_mask_bit);
+	ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &CSGShape::get_collision_mask_bit);
+
+	ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &CSGShape::set_collision_layer_bit);
+	ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &CSGShape::get_collision_layer_bit);
+
+	ClassDB::bind_method(D_METHOD("set_calculate_tangents", "enabled"), &CSGShape::set_calculate_tangents);
+	ClassDB::bind_method(D_METHOD("is_calculating_tangents"), &CSGShape::is_calculating_tangents);
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "operation", PROPERTY_HINT_ENUM, "Union,Intersection,Subtraction"), "set_operation", "get_operation");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_collision"), "set_use_collision", "is_using_collision");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "snap", PROPERTY_HINT_RANGE, "0.0001,1,0.001"), "set_snap", "get_snap");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "calculate_tangents"), "set_calculate_tangents", "is_calculating_tangents");
+
+	ADD_GROUP("Collision", "collision_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_collision"), "set_use_collision", "is_using_collision");
+	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");
 
 	BIND_ENUM_CONSTANT(OPERATION_UNION);
 	BIND_ENUM_CONSTANT(OPERATION_INTERSECTION);
@@ -431,13 +619,16 @@ void CSGShape::_bind_methods() {
 }
 
 CSGShape::CSGShape() {
+	operation = OPERATION_UNION;
+	parent = NULL;
 	brush = NULL;
-	set_notify_local_transform(true);
 	dirty = false;
-	parent = NULL;
-	use_collision = false;
-	operation = OPERATION_UNION;
 	snap = 0.001;
+	use_collision = false;
+	collision_layer = 1;
+	collision_mask = 1;
+	calculate_tangents = true;
+	set_notify_local_transform(true);
 }
 
 CSGShape::~CSGShape() {
@@ -1545,6 +1736,24 @@ CSGBrush *CSGPolygon::_build_brush() {
 	Path *path = NULL;
 	Ref<Curve3D> curve;
 
+	// get bounds for our polygon
+	Vector2 final_polygon_min;
+	Vector2 final_polygon_max;
+	for (int i = 0; i < final_polygon.size(); i++) {
+		Vector2 p = final_polygon[i];
+		if (i == 0) {
+			final_polygon_min = p;
+			final_polygon_max = final_polygon_min;
+		} else {
+			if (p.x < final_polygon_min.x) final_polygon_min.x = p.x;
+			if (p.y < final_polygon_min.y) final_polygon_min.y = p.y;
+
+			if (p.x > final_polygon_max.x) final_polygon_max.x = p.x;
+			if (p.y > final_polygon_max.y) final_polygon_max.y = p.y;
+		}
+	}
+	Vector2 final_polygon_size = final_polygon_max - final_polygon_min;
+
 	if (mode == MODE_PATH) {
 		if (!has_node(path_node))
 			return NULL;
@@ -1636,6 +1845,10 @@ CSGBrush *CSGPolygon::_build_brush() {
 								v.z -= depth;
 							}
 							facesw[face * 3 + k] = v;
+							uvsw[face * 3 + k] = (p - final_polygon_min) / final_polygon_size;
+							if (i == 0) {
+								uvsw[face * 3 + k].x = 1.0 - uvsw[face * 3 + k].x; /* flip x */
+							}
 						}
 
 						smoothw[face] = false;
@@ -1767,6 +1980,7 @@ CSGBrush *CSGPolygon::_build_brush() {
 								Vector2 p = final_polygon[triangles[j + src[k]]];
 								Vector3 v = Vector3(p.x, p.y, 0);
 								facesw[face * 3 + k] = v;
+								uvsw[face * 3 + k] = (p - final_polygon_min) / final_polygon_size;
 							}
 
 							smoothw[face] = false;
@@ -1784,6 +1998,8 @@ CSGBrush *CSGPolygon::_build_brush() {
 								Vector2 p = final_polygon[triangles[j + src[k]]];
 								Vector3 v = Vector3(normali_n.x * p.x, p.y, normali_n.z * p.x);
 								facesw[face * 3 + k] = v;
+								uvsw[face * 3 + k] = (p - final_polygon_min) / final_polygon_size;
+								uvsw[face * 3 + k].x = 1.0 - uvsw[face * 3 + k].x; /* flip x */
 							}
 
 							smoothw[face] = false;
@@ -1869,10 +2085,10 @@ CSGBrush *CSGPolygon::_build_brush() {
 							};
 
 							Vector2 u[4] = {
-								Vector2(u1, 0),
 								Vector2(u1, 1),
-								Vector2(u2, 1),
-								Vector2(u2, 0)
+								Vector2(u1, 0),
+								Vector2(u2, 0),
+								Vector2(u2, 1)
 							};
 
 							// face 1
@@ -1915,6 +2131,7 @@ CSGBrush *CSGPolygon::_build_brush() {
 								Vector2 p = final_polygon[triangles[j + src[k]]];
 								Vector3 v = Vector3(p.x, p.y, 0);
 								facesw[face * 3 + k] = xf.xform(v);
+								uvsw[face * 3 + k] = (p - final_polygon_min) / final_polygon_size;
 							}
 
 							smoothw[face] = false;
@@ -1932,6 +2149,8 @@ CSGBrush *CSGPolygon::_build_brush() {
 								Vector2 p = final_polygon[triangles[j + src[k]]];
 								Vector3 v = Vector3(p.x, p.y, 0);
 								facesw[face * 3 + k] = xf.xform(v);
+								uvsw[face * 3 + k] = (p - final_polygon_min) / final_polygon_size;
+								uvsw[face * 3 + k].x = 1.0 - uvsw[face * 3 + k].x; /* flip x */
 							}
 
 							smoothw[face] = false;
@@ -1956,6 +2175,9 @@ CSGBrush *CSGPolygon::_build_brush() {
 			} else {
 				aabb.expand_to(facesw[i]);
 			}
+
+			// invert UVs on the Y-axis OpenGL = upside down
+			uvsw[i].y = 1.0 - uvsw[i].y;
 		}
 	}