Add CSGConvexCage3D

modules/csg/config.py

@@ -17,6 +17,7 @@ def get_doc_classes():
         "CSGShape3D",
         "CSGSphere3D",
         "CSGTorus3D",
+        "CSGConvexCage3D",
     ]
 
 

modules/csg/csg.cpp

@@ -387,10 +387,8 @@ static void pack_manifold(
 static void unpack_manifold(
 		const manifold::Manifold &p_manifold,
 		const HashMap<int32_t, Ref<Material>> &mesh_materials,
+		Ref<StandardMaterial3D> default_material,
 		CSGBrush *r_mesh_merge) {
-	Ref<StandardMaterial3D> default_material;
-	default_material.instantiate();
-
 	manifold::MeshGL64 mesh = p_manifold.GetMeshGL64();
 
 	constexpr int32_t order[3] = { 0, 2, 1 };
@@ -426,6 +424,7 @@ static void unpack_manifold(
 
 				ERR_FAIL_COND_MSG(property_i * mesh.numProp >= mesh.vertProperties.size(), "Invalid index into vertex properties");
 
+				// Position is guaranteed. Others are not.
 				face.vertices[tri_order_i] = Vector3(
 						mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_POSITION_X],
 						mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_POSITION_Y],
@@ -435,8 +434,12 @@ static void unpack_manifold(
 						mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_UV_X_0],
 						mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_UV_Y_0]);
 
-				face.smooth = mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_SMOOTH_GROUP] > 0.5f;
-				face.invert = mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_INVERT] > 0.5f;
+				if (mesh.numProp > MANIFOLD_PROPERTY_SMOOTH_GROUP) {
+					face.smooth = mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_SMOOTH_GROUP] > 0.5f;
+				}
+				if (mesh.numProp > MANIFOLD_PROPERTY_INVERT) {
+					face.invert = mesh.vertProperties[property_i * mesh.numProp + MANIFOLD_PROPERTY_INVERT] > 0.5f;
+				}
 			}
 
 			r_mesh_merge->faces.push_back(face);
@@ -449,6 +452,9 @@ static void unpack_manifold(
 // CSGBrushOperation
 
 void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_brush_a, const CSGBrush &p_brush_b, CSGBrush &r_merged_brush, float p_vertex_snap) {
+	Ref<StandardMaterial3D> default_material;
+	default_material.instantiate();
+
 	HashMap<int32_t, Ref<Material>> mesh_materials;
 	manifold::Manifold brush_a;
 	pack_manifold(&p_brush_a, brush_a, mesh_materials, p_vertex_snap);
@@ -466,7 +472,23 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
 			merged_brush = brush_a - brush_b;
 			break;
 	}
-	unpack_manifold(merged_brush, mesh_materials, &r_merged_brush);
+	unpack_manifold(merged_brush, mesh_materials, default_material, &r_merged_brush);
+}
+
+void make_brush_hull(
+		CSGBrush *brush,
+		const Vector<Vector3> &points,
+		const Ref<Material> material) {
+
+	std::vector<manifold::vec3> converted_points;
+	for (int i = 0; i < points.size(); i++) {
+		converted_points.push_back(manifold::vec3(points[i].x, points[i].y, points[i].z));
+	}
+
+	HashMap<int32_t, Ref<Material>> mesh_materials;
+	manifold::Manifold m;
+	m = m.Hull(converted_points);
+	unpack_manifold(m, mesh_materials, material, brush);
 }
 
 // CSGBrushOperation::MeshMerge

modules/csg/csg.h

@@ -207,4 +207,9 @@ struct CSGBrushOperation {
 	void update_faces(const CSGBrush &p_brush_a, const int p_face_idx_a, const CSGBrush &p_brush_b, const int p_face_idx_b, Build2DFaceCollection &p_collection, float p_vertex_snap);
 };
 
+extern void make_brush_hull(
+		CSGBrush *brush,
+		const Vector<Vector3> &points,
+		const Ref<Material> material);
+
 #endif // CSG_H

modules/csg/csg_shape.cpp

@@ -2444,3 +2444,28 @@ CSGPolygon3D::CSGPolygon3D() {
 	path_joined = false;
 	path = nullptr;
 }
+
+///////////////
+
+CSGBrush *CSGConvexCage3D::_build_brush() {
+    CSGBrush *new_brush = memnew(CSGBrush);
+    Ref<Mesh> mesh = get_mesh();
+    Vector<Vector3> points;
+    if (mesh.is_valid()) {
+        for (int i = 0; i < mesh->get_surface_count(); ++i) {
+            Array vertices = mesh->surface_get_arrays(i)[Mesh::ARRAY_VERTEX];
+            for (int j = 0; j < vertices.size(); ++j) {
+                points.push_back(vertices[j]);
+            }
+        }
+        if (points.size() < 4) {
+            return new_brush;
+        }
+    } else {
+        return new_brush;
+    }
+
+    make_brush_hull(new_brush, points, get_material());
+
+    return new_brush;
+}

modules/csg/csg_shape.h

@@ -456,4 +456,11 @@ VARIANT_ENUM_CAST(CSGPolygon3D::Mode)
 VARIANT_ENUM_CAST(CSGPolygon3D::PathRotation)
 VARIANT_ENUM_CAST(CSGPolygon3D::PathIntervalType)
 
+class CSGConvexCage3D : public CSGMesh3D {
+	GDCLASS(CSGConvexCage3D, CSGMesh3D);
+
+private:
+	virtual CSGBrush *_build_brush() override;
+};
+
 #endif // CSG_SHAPE_H

modules/csg/doc_classes/CSGConvexCage3D.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="CSGConvexCage3D" inherits="CSGMesh3D" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+		A CSG convex hull shape.
+	</brief_description>
+	<description>
+		This node creates a mesh based on the convex hull of a set of points for use with the CSG system.
+		[b]Note:[/b] CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a [MeshInstance3D] with a [PrimitiveMesh]. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+	</description>
+	<tutorials>
+		<link title="Prototyping levels with CSG">$DOCS_URL/tutorials/3d/csg_tools.html</link>
+	</tutorials>
+</class>

modules/csg/register_types.cpp

@@ -48,6 +48,7 @@ void initialize_csg_module(ModuleInitializationLevel p_level) {
 		GDREGISTER_CLASS(CSGCylinder3D);
 		GDREGISTER_CLASS(CSGTorus3D);
 		GDREGISTER_CLASS(CSGPolygon3D);
+		GDREGISTER_CLASS(CSGConvexCage3D);
 		GDREGISTER_CLASS(CSGCombiner3D);
 	}
 #ifdef TOOLS_ENABLED