1 files changed, 68 insertions, 26 deletions

diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index 4a2263407c..85f47c3bbb 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -34,6 +34,7 @@
 #include "bullet_physics_server.h"
 #include "bullet_types_converter.h"
 #include "bullet_utilities.h"
+#include "core/project_settings.h"
 #include "shape_owner_bullet.h"
 
 #include <BulletCollision/CollisionDispatch/btInternalEdgeUtility.h>
@@ -64,7 +65,8 @@ btCollisionShape *ShapeBullet::prepare(btCollisionShape *p_btShape) const {
 
 void ShapeBullet::notifyShapeChanged() {
 	for (Map<ShapeOwnerBullet *, int>::Element *E = owners.front(); E; E = E->next()) {
-		static_cast<ShapeOwnerBullet *>(E->key())->on_shape_changed(this);
+		ShapeOwnerBullet *owner = static_cast<ShapeOwnerBullet *>(E->key());
+		owner->shape_changed(owner->find_shape(this));
 	}
 }
 
@@ -146,7 +148,13 @@ btHeightfieldTerrainShape *ShapeBullet::create_shape_height_field(PoolVector<rea
 	const bool flipQuadEdges = false;
 	const void *heightsPtr = p_heights.read().ptr();
 
-	return bulletnew(btHeightfieldTerrainShape(p_width, p_depth, heightsPtr, ignoredHeightScale, p_min_height, p_max_height, YAxis, PHY_FLOAT, flipQuadEdges));
+	btHeightfieldTerrainShape *heightfield = bulletnew(btHeightfieldTerrainShape(p_width, p_depth, heightsPtr, ignoredHeightScale, p_min_height, p_max_height, YAxis, PHY_FLOAT, flipQuadEdges));
+
+	// The shape can be created without params when you do PhysicsServer.shape_create(PhysicsServer.SHAPE_HEIGHTMAP)
+	if (heightsPtr)
+		heightfield->buildAccelerator(16);
+
+	return heightfield;
 }
 
 btRayShape *ShapeBullet::create_shape_ray(real_t p_length, bool p_slips_on_slope) {
@@ -400,18 +408,22 @@ void ConcavePolygonShapeBullet::setup(PoolVector<Vector3> p_faces) {
 		btVector3 supVec_1;
 		btVector3 supVec_2;
 		for (int i = 0; i < src_face_count; ++i) {
-			G_TO_B(facesr[i * 3], supVec_0);
+			G_TO_B(facesr[i * 3 + 0], supVec_0);
 			G_TO_B(facesr[i * 3 + 1], supVec_1);
 			G_TO_B(facesr[i * 3 + 2], supVec_2);
 
-			shapeInterface->addTriangle(supVec_0, supVec_1, supVec_2);
+			// Inverted from standard godot otherwise btGenerateInternalEdgeInfo generates wrong edge info
+			shapeInterface->addTriangle(supVec_2, supVec_1, supVec_0);
 		}
 
 		const bool useQuantizedAabbCompression = true;
 
 		meshShape = bulletnew(btBvhTriangleMeshShape(shapeInterface, useQuantizedAabbCompression));
-		btTriangleInfoMap *triangleInfoMap = new btTriangleInfoMap();
-		btGenerateInternalEdgeInfo(meshShape, triangleInfoMap);
+
+		if (GLOBAL_DEF("physics/3d/smooth_trimesh_collision", false)) {
+			btTriangleInfoMap *triangleInfoMap = new btTriangleInfoMap();
+			btGenerateInternalEdgeInfo(meshShape, triangleInfoMap);
+		}
 	} else {
 		meshShape = NULL;
 		ERR_PRINT("The faces count are 0, the mesh shape cannot be created");
@@ -426,6 +438,7 @@ btCollisionShape *ConcavePolygonShapeBullet::create_bt_shape(const btVector3 &p_
 		cs = ShapeBullet::create_shape_empty();
 	cs->setLocalScaling(p_implicit_scale);
 	prepare(cs);
+	cs->setMargin(0);
 	return cs;
 }
 
@@ -454,7 +467,46 @@ void HeightMapShapeBullet::set_data(const Variant &p_data) {
 
 	int l_width = d["width"];
 	int l_depth = d["depth"];
-	PoolVector<real_t> l_heights = d["heights"];
+
+	// TODO This code will need adjustments if real_t is set to `double`,
+	// because that precision is unnecessary for a heightmap and Bullet doesn't support it...
+
+	PoolVector<real_t> l_heights;
+	Variant l_heights_v = d["heights"];
+
+	if (l_heights_v.get_type() == Variant::POOL_REAL_ARRAY) {
+		// Ready-to-use heights can be passed
+
+		l_heights = l_heights_v;
+
+	} else if (l_heights_v.get_type() == Variant::OBJECT) {
+		// If an image is passed, we have to convert it to a format Bullet supports.
+		// this would be expensive to do with a script, so it's nice to have it here.
+
+		Ref<Image> l_image = l_heights_v;
+		ERR_FAIL_COND(l_image.is_null());
+
+		// Float is the only common format between Godot and Bullet that can be used for decent collision.
+		// (Int16 would be nice too but we still don't have it)
+		// We could convert here automatically but it's better to not be intrusive and let the caller do it if necessary.
+		ERR_FAIL_COND(l_image->get_format() != Image::FORMAT_RF);
+
+		PoolByteArray im_data = l_image->get_data();
+
+		l_heights.resize(l_image->get_width() * l_image->get_height());
+
+		PoolRealArray::Write w = l_heights.write();
+		PoolByteArray::Read r = im_data.read();
+		float *rp = (float *)r.ptr();
+		// At this point, `rp` could be used directly for Bullet, but I don't know how safe it would be.
+
+		for (int i = 0; i < l_heights.size(); ++i) {
+			w[i] = rp[i];
+		}
+
+	} else {
+		ERR_FAIL_MSG("Expected PoolRealArray or float Image.");
+	}
 
 	ERR_FAIL_COND(l_width <= 0);
 	ERR_FAIL_COND(l_depth <= 0);
@@ -463,16 +515,17 @@ void HeightMapShapeBullet::set_data(const Variant &p_data) {
 	// 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();
+		PoolVector<real_t>::Read r = l_heights.read();
+		int heights_size = l_heights.size();
 
 		for (int i = 0; i < heights_size; ++i) {
 			real_t h = r[i];
 
-			if (h < l_min_height)
+			if (h < l_min_height) {
 				l_min_height = h;
-			else if (h > l_max_height)
+			} else if (h > l_max_height) {
 				l_max_height = h;
+			}
 		}
 	}
 
@@ -490,19 +543,8 @@ PhysicsServer::ShapeType HeightMapShapeBullet::get_type() const {
 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();
-		PoolVector<real_t>::Write heights_w = heights.write();
-		for (int i = heights_size - 1; 0 <= i; --i) {
-			heights_w[i] = p_heights_r[i];
-		}
-	}
+	// If this array is resized outside of here, it should be preserved due to CoW
+	heights = p_heights;
 
 	width = p_width;
 	depth = p_depth;