6 files changed, 62 insertions, 19 deletions
diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp
index 12c88f43b3..194a6f6352 100644
--- a/core/math/geometry.cpp
+++ b/core/math/geometry.cpp
@@ -31,6 +31,7 @@
 #include "geometry.h"
 
 #include "core/print_string.h"
+#include "thirdparty/misc/triangulator.h"
 
 /* this implementation is very inefficient, commenting unless bugs happen. See the other one.
 bool Geometry::is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon) {
@@ -737,6 +738,40 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
 	return wrapped_faces;
 }
 
+Vector<Vector<Vector2> > Geometry::decompose_polygon_in_convex(Vector<Point2> polygon) {
+	Vector<Vector<Vector2> > decomp;
+	List<TriangulatorPoly> in_poly, out_poly;
+
+	TriangulatorPoly inp;
+	inp.Init(polygon.size());
+	for (int i = 0; i < polygon.size(); i++) {
+		inp.GetPoint(i) = polygon[i];
+	}
+	inp.SetOrientation(TRIANGULATOR_CCW);
+	in_poly.push_back(inp);
+	TriangulatorPartition tpart;
+	if (tpart.ConvexPartition_HM(&in_poly, &out_poly) == 0) { //failed!
+		ERR_PRINT("Convex decomposing failed!");
+		return decomp;
+	}
+
+	decomp.resize(out_poly.size());
+	int idx = 0;
+	for (List<TriangulatorPoly>::Element *I = out_poly.front(); I; I = I->next()) {
+		TriangulatorPoly &tp = I->get();
+
+		decomp.write[idx].resize(tp.GetNumPoints());
+
+		for (int i = 0; i < tp.GetNumPoints(); i++) {
+			decomp.write[idx].write[i] = tp.GetPoint(i);
+		}
+
+		idx++;
+	}
+
+	return decomp;
+}
+
 Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes) {
 
 	MeshData mesh;
diff --git a/core/math/geometry.h b/core/math/geometry.h
index f927a63ed5..4b478b6b16 100644
--- a/core/math/geometry.h
+++ b/core/math/geometry.h
@@ -950,6 +950,8 @@ public:
 		return H;
 	}
 
+	static Vector<Vector<Vector2> > decompose_polygon_in_convex(Vector<Point2> polygon);
+
 	static MeshData build_convex_mesh(const PoolVector<Plane> &p_planes);
 	static PoolVector<Plane> build_sphere_planes(real_t p_radius, int p_lats, int p_lons, Vector3::Axis p_axis = Vector3::AXIS_Z);
 	static PoolVector<Plane> build_box_planes(const Vector3 &p_extents);
diff --git a/core/math/quick_hull.cpp b/core/math/quick_hull.cpp
index bc2b4e6fe0..fc2eb1454d 100644
--- a/core/math/quick_hull.cpp
+++ b/core/math/quick_hull.cpp
@@ -36,8 +36,6 @@ uint32_t QuickHull::debug_stop_after = 0xFFFFFFFF;
 
 Error QuickHull::build(const Vector<Vector3> &p_points, Geometry::MeshData &r_mesh) {
 
-	static const real_t over_tolerance = 0.0001;
-
 	/* CREATE AABB VOLUME */
 
 	AABB aabb;
@@ -180,6 +178,8 @@ Error QuickHull::build(const Vector<Vector3> &p_points, Geometry::MeshData &r_me
 		faces.push_back(f);
 	}
 
+	real_t over_tolerance = 3 * UNIT_EPSILON * (aabb.size.x + aabb.size.y + aabb.size.z);
+
 	/* COMPUTE AVAILABLE VERTICES */
 
 	for (int i = 0; i < p_points.size(); i++) {
diff --git a/core/math/quick_hull.h b/core/math/quick_hull.h
index 2e659cab6e..a445a47cbe 100644
--- a/core/math/quick_hull.h
+++ b/core/math/quick_hull.h
@@ -64,7 +64,7 @@ public:
 	struct Face {
 
 		Plane plane;
-		int vertices[3];
+		uint32_t vertices[3];
 		Vector<int> points_over;
 
 		bool operator<(const Face &p_face) const {
diff --git a/core/math/random_pcg.cpp b/core/math/random_pcg.cpp
index 8bbcca88fe..45467b32b2 100644
--- a/core/math/random_pcg.cpp
+++ b/core/math/random_pcg.cpp
@@ -32,24 +32,25 @@
 
 #include "core/os/os.h"
 
-RandomPCG::RandomPCG(uint64_t seed, uint64_t inc) :
-		pcg() {
-	pcg.state = seed;
-	pcg.inc = inc;
+RandomPCG::RandomPCG(uint64_t p_seed, uint64_t p_inc) :
+		pcg(),
+		current_seed(DEFAULT_SEED) {
+	pcg.inc = p_inc;
+	seed(p_seed);
 }
 
 void RandomPCG::randomize() {
 	seed(OS::get_singleton()->get_ticks_usec() * pcg.state + PCG_DEFAULT_INC_64);
 }
 
-double RandomPCG::random(double from, double to) {
+double RandomPCG::random(double p_from, double p_to) {
 	unsigned int r = rand();
 	double ret = (double)r / (double)RANDOM_MAX;
-	return (ret) * (to - from) + from;
+	return (ret) * (p_to - p_from) + p_from;
 }
 
-float RandomPCG::random(float from, float to) {
+float RandomPCG::random(float p_from, float p_to) {
 	unsigned int r = rand();
 	float ret = (float)r / (float)RANDOM_MAX;
-	return (ret) * (to - from) + from;
+	return (ret) * (p_to - p_from) + p_from;
 }
diff --git a/core/math/random_pcg.h b/core/math/random_pcg.h
index 2a69d43904..230eb9a11b 100644
--- a/core/math/random_pcg.h
+++ b/core/math/random_pcg.h
@@ -37,28 +37,33 @@
 
 class RandomPCG {
 	pcg32_random_t pcg;
+	uint64_t current_seed; // seed with this to get the same state
 
 public:
 	static const uint64_t DEFAULT_SEED = 12047754176567800795U;
 	static const uint64_t DEFAULT_INC = PCG_DEFAULT_INC_64;
 	static const uint64_t RANDOM_MAX = 0xFFFFFFFF;
 
-	RandomPCG(uint64_t seed = DEFAULT_SEED, uint64_t inc = PCG_DEFAULT_INC_64);
+	RandomPCG(uint64_t p_seed = DEFAULT_SEED, uint64_t p_inc = PCG_DEFAULT_INC_64);
 
-	_FORCE_INLINE_ void seed(uint64_t seed) {
-		pcg.state = seed;
+	_FORCE_INLINE_ void seed(uint64_t p_seed) {
+		current_seed = p_seed;
+		pcg.state = p_seed;
 		pcg32_random_r(&pcg); // Force changing internal state to avoid initial 0
 	}
-	_FORCE_INLINE_ uint64_t get_seed() { return pcg.state; }
+	_FORCE_INLINE_ uint64_t get_seed() { return current_seed; }
 
 	void randomize();
-	_FORCE_INLINE_ uint32_t rand() { return pcg32_random_r(&pcg); }
+	_FORCE_INLINE_ uint32_t rand() {
+		current_seed = pcg.state;
+		return pcg32_random_r(&pcg);
+	}
 	_FORCE_INLINE_ double randd() { return (double)rand() / (double)RANDOM_MAX; }
 	_FORCE_INLINE_ float randf() { return (float)rand() / (float)RANDOM_MAX; }
 
-	double random(double from, double to);
-	float random(float from, float to);
-	real_t random(int from, int to) { return (real_t)random((real_t)from, (real_t)to); }
+	double random(double p_from, double p_to);
+	float random(float p_from, float p_to);
+	real_t random(int p_from, int p_to) { return (real_t)random((real_t)p_from, (real_t)p_to); }
 };
 
 #endif // RANDOM_PCG_H