1 files changed, 101 insertions, 22 deletions

diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index 27eac4e6ee..e4c1a5f9b5 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -113,6 +113,10 @@ btCapsuleShapeZ *ShapeBullet::create_shape_capsule(btScalar radius, btScalar hei
 	return bulletnew(btCapsuleShapeZ(radius, height));
 }
 
+btCylinderShape *ShapeBullet::create_shape_cylinder(btScalar radius, btScalar height) {
+	return bulletnew(btCylinderShape(btVector3(radius, height / 2.0, radius)));
+}
+
 btConvexPointCloudShape *ShapeBullet::create_shape_convex(btAlignedObjectArray<btVector3> &p_vertices, const btVector3 &p_local_scaling) {
 	return bulletnew(btConvexPointCloudShape(&p_vertices[0], p_vertices.size(), p_local_scaling));
 }
@@ -125,18 +129,19 @@ btScaledBvhTriangleMeshShape *ShapeBullet::create_shape_concave(btBvhTriangleMes
 	}
 }
 
-btHeightfieldTerrainShape *ShapeBullet::create_shape_height_field(PoolVector<real_t> &p_heights, int p_width, int p_depth, real_t p_cell_size) {
+btHeightfieldTerrainShape *ShapeBullet::create_shape_height_field(PoolVector<real_t> &p_heights, int p_width, int p_depth, real_t p_min_height, real_t p_max_height) {
 	const btScalar ignoredHeightScale(1);
-	const btScalar fieldHeight(500); // Meters
 	const int YAxis = 1; // 0=X, 1=Y, 2=Z
 	const bool flipQuadEdges = false;
 	const void *heightsPtr = p_heights.read().ptr();
 
-	return bulletnew(btHeightfieldTerrainShape(p_width, p_depth, heightsPtr, ignoredHeightScale, -fieldHeight, fieldHeight, YAxis, PHY_FLOAT, flipQuadEdges));
+	return bulletnew(btHeightfieldTerrainShape(p_width, p_depth, heightsPtr, ignoredHeightScale, p_min_height, p_max_height, YAxis, PHY_FLOAT, flipQuadEdges));
 }
 
-btRayShape *ShapeBullet::create_shape_ray(real_t p_length) {
-	return bulletnew(btRayShape(p_length));
+btRayShape *ShapeBullet::create_shape_ray(real_t p_length, bool p_slips_on_slope) {
+	btRayShape *r(bulletnew(btRayShape(p_length)));
+	r->setSlipsOnSlope(p_slips_on_slope);
+	return r;
 }
 
 /* PLANE */
@@ -253,6 +258,39 @@ btCollisionShape *CapsuleShapeBullet::create_bt_shape(const btVector3 &p_implici
 	return prepare(ShapeBullet::create_shape_capsule(radius * p_implicit_scale[0] + p_margin, height * p_implicit_scale[1] + p_margin));
 }
 
+/* Cylinder */
+
+CylinderShapeBullet::CylinderShapeBullet() :
+		ShapeBullet() {}
+
+void CylinderShapeBullet::set_data(const Variant &p_data) {
+	Dictionary d = p_data;
+	ERR_FAIL_COND(!d.has("radius"));
+	ERR_FAIL_COND(!d.has("height"));
+	setup(d["height"], d["radius"]);
+}
+
+Variant CylinderShapeBullet::get_data() const {
+	Dictionary d;
+	d["radius"] = radius;
+	d["height"] = height;
+	return d;
+}
+
+PhysicsServer::ShapeType CylinderShapeBullet::get_type() const {
+	return PhysicsServer::SHAPE_CYLINDER;
+}
+
+void CylinderShapeBullet::setup(real_t p_height, real_t p_radius) {
+	radius = p_radius;
+	height = p_height;
+	notifyShapeChanged();
+}
+
+btCollisionShape *CylinderShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_margin) {
+	return prepare(ShapeBullet::create_shape_cylinder(radius * p_implicit_scale[0] + p_margin, height * p_implicit_scale[1] + p_margin));
+}
+
 /* Convex polygon */
 
 ConvexPolygonShapeBullet::ConvexPolygonShapeBullet() :
@@ -266,7 +304,7 @@ void ConvexPolygonShapeBullet::get_vertices(Vector<Vector3> &out_vertices) {
 	const int n_of_vertices = vertices.size();
 	out_vertices.resize(n_of_vertices);
 	for (int i = n_of_vertices - 1; 0 <= i; --i) {
-		B_TO_G(vertices[i], out_vertices[i]);
+		B_TO_G(vertices[i], out_vertices.write[i]);
 	}
 }
 
@@ -282,7 +320,7 @@ PhysicsServer::ShapeType ConvexPolygonShapeBullet::get_type() const {
 }
 
 void ConvexPolygonShapeBullet::setup(const Vector<Vector3> &p_vertices) {
-	// Make a copy of verticies
+	// Make a copy of vertices
 	const int n_of_vertices = p_vertices.size();
 	vertices.resize(n_of_vertices);
 	for (int i = n_of_vertices - 1; 0 <= i; --i) {
@@ -335,10 +373,10 @@ void ConcavePolygonShapeBullet::setup(PoolVector<Vector3> p_faces) {
 	int src_face_count = faces.size();
 	if (0 < src_face_count) {
 
-		btTriangleMesh *shapeInterface = bulletnew(btTriangleMesh);
-
 		// It counts the faces and assert the array contains the correct number of vertices.
 		ERR_FAIL_COND(src_face_count % 3);
+
+		btTriangleMesh *shapeInterface = bulletnew(btTriangleMesh);
 		src_face_count /= 3;
 		PoolVector<Vector3>::Read r = p_faces.read();
 		const Vector3 *facesr = r.ptr();
@@ -385,19 +423,44 @@ void HeightMapShapeBullet::set_data(const Variant &p_data) {
 	Dictionary d = p_data;
 	ERR_FAIL_COND(!d.has("width"));
 	ERR_FAIL_COND(!d.has("depth"));
-	ERR_FAIL_COND(!d.has("cell_size"));
 	ERR_FAIL_COND(!d.has("heights"));
 
+	real_t l_min_height = 0.0;
+	real_t l_max_height = 0.0;
+
+	// If specified, min and max height will be used as precomputed values
+	if (d.has("min_height"))
+		l_min_height = d["min_height"];
+	if (d.has("max_height"))
+		l_max_height = d["max_height"];
+
+	ERR_FAIL_COND(l_min_height > l_max_height);
+
 	int l_width = d["width"];
 	int l_depth = d["depth"];
-	real_t l_cell_size = d["cell_size"];
 	PoolVector<real_t> l_heights = d["heights"];
 
 	ERR_FAIL_COND(l_width <= 0);
 	ERR_FAIL_COND(l_depth <= 0);
-	ERR_FAIL_COND(l_cell_size <= CMP_EPSILON);
-	ERR_FAIL_COND(l_heights.size() != (width * depth));
-	setup(heights, width, depth, cell_size);
+	ERR_FAIL_COND(l_heights.size() != (l_width * l_depth));
+
+	// Compute min and max heights if not specified.
+	if (!d.has("min_height") && !d.has("max_height")) {
+
+		PoolVector<real_t>::Read r = heights.read();
+		int heights_size = heights.size();
+
+		for (int i = 0; i < heights_size; ++i) {
+			real_t h = r[i];
+
+			if (h < l_min_height)
+				l_min_height = h;
+			else if (h > l_max_height)
+				l_max_height = h;
+		}
+	}
+
+	setup(l_heights, l_width, l_depth, l_min_height, l_max_height);
 }
 
 Variant HeightMapShapeBullet::get_data() const {
@@ -408,8 +471,14 @@ PhysicsServer::ShapeType HeightMapShapeBullet::get_type() const {
 	return PhysicsServer::SHAPE_HEIGHTMAP;
 }
 
-void HeightMapShapeBullet::setup(PoolVector<real_t> &p_heights, int p_width, int p_depth, real_t p_cell_size) {
+void HeightMapShapeBullet::setup(PoolVector<real_t> &p_heights, int p_width, int p_depth, real_t p_min_height, real_t p_max_height) {
+	// TODO cell size must be tweaked using localScaling, which is a shared property for all Bullet shapes
+
 	{ // Copy
+
+		// TODO If Godot supported 16-bit integer image format, we could share the same memory block for heightfields
+		// without having to copy anything, optimizing memory and loading performance (Bullet only reads and doesn't take ownership of the data).
+
 		const int heights_size = p_heights.size();
 		heights.resize(heights_size);
 		PoolVector<real_t>::Read p_heights_r = p_heights.read();
@@ -418,14 +487,16 @@ void HeightMapShapeBullet::setup(PoolVector<real_t> &p_heights, int p_width, int
 			heights_w[i] = p_heights_r[i];
 		}
 	}
+
 	width = p_width;
 	depth = p_depth;
-	cell_size = p_cell_size;
+	min_height = p_min_height;
+	max_height = p_max_height;
 	notifyShapeChanged();
 }
 
 btCollisionShape *HeightMapShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_margin) {
-	btCollisionShape *cs(ShapeBullet::create_shape_height_field(heights, width, depth, cell_size));
+	btCollisionShape *cs(ShapeBullet::create_shape_height_field(heights, width, depth, min_height, max_height));
 	cs->setLocalScaling(p_implicit_scale);
 	prepare(cs);
 	cs->setMargin(p_margin);
@@ -435,25 +506,33 @@ btCollisionShape *HeightMapShapeBullet::create_bt_shape(const btVector3 &p_impli
 /* Ray shape */
 RayShapeBullet::RayShapeBullet() :
 		ShapeBullet(),
-		length(1) {}
+		length(1),
+		slips_on_slope(false) {}
 
 void RayShapeBullet::set_data(const Variant &p_data) {
-	setup(p_data);
+
+	Dictionary d = p_data;
+	setup(d["length"], d["slips_on_slope"]);
 }
 
 Variant RayShapeBullet::get_data() const {
-	return length;
+
+	Dictionary d;
+	d["length"] = length;
+	d["slips_on_slope"] = slips_on_slope;
+	return d;
 }
 
 PhysicsServer::ShapeType RayShapeBullet::get_type() const {
 	return PhysicsServer::SHAPE_RAY;
 }
 
-void RayShapeBullet::setup(real_t p_length) {
+void RayShapeBullet::setup(real_t p_length, bool p_slips_on_slope) {
 	length = p_length;
+	slips_on_slope = p_slips_on_slope;
 	notifyShapeChanged();
 }
 
 btCollisionShape *RayShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_margin) {
-	return prepare(ShapeBullet::create_shape_ray(length * p_implicit_scale[1] + p_margin));
+	return prepare(ShapeBullet::create_shape_ray(length * p_implicit_scale[1] + p_margin, slips_on_slope));
 }