Blast 1.1.3. See docs/release_notes.txt.v1.1.3_rc1

1 files changed, 373 insertions, 373 deletions

diff --git a/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp b/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp
index 5abdea9..ffb838b 100644..100755
--- a/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp
+++ b/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp
@@ -1,373 +1,373 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.
-
-
-#include "NvBlastExtTriangleProcessor.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-#define COLLIN_EPS 1e-4f
-#define V_COMP_EPS 1e-5f
-
-using namespace physx;
-
-namespace Nv
-{
-namespace Blast
-{
-/**
-	Segments bounding box interseciton test
-*/
-bool boundingRectangleIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2)
-{
-	// sl1/sl2 is always left bottom end of rectangle
-	// se1/el2 is always right top end of rectangle
-
-	PxF32 sl1, sl2, el1, el2;
-	if (s1.x < e1.x)
-	{
-		sl1 = s1.x;
-		el1 = e1.x;
-	}
-	else
-	{
-		el1 = s1.x;
-		sl1 = e1.x;
-	}
-
-	if (s2.x < e2.x)
-	{
-		sl2 = s2.x;
-		el2 = e2.x;
-	}
-	else
-	{
-		el2 = s2.x;
-		sl2 = e2.x;
-	}
-	if (PxMax(sl1, sl2) > PxMin(el1, el2))
-		return false;
-
-	if (s1.y < e1.y)
-	{
-		sl1 = s1.y;
-		el1 = e1.y;
-	}
-	else
-	{
-		el1 = s1.y;
-		sl1 = e1.y;
-	}
-
-	if (s2.y < e2.y)
-	{
-		sl2 = s2.y;
-		el2 = e2.y;
-	}
-	else
-	{
-		el2 = s2.y;
-		sl2 = e2.y;
-	}
-	if (PxMax(sl1, sl2) > PxMin(el1, el2))
-		return false;
-
-	return true;
-}
-
-inline PxF32 getRotation(PxVec2 a, PxVec2 b)
-{
-	return a.x * b.y - a.y * b.x;
-}
-
-inline PxF32 getParameter(const PxVec2& a, const PxVec2& b, const PxVec2& point)
-{
-	return (point - a).magnitude() / (b - a).magnitude();
-}
-inline PxVec3 lerp3D(const PxVec3& a, const PxVec3& b, const PxF32 t)
-{
-	return (b - a) * t + a;
-}
-
-
-
-struct Line2D
-{
-	PxVec2 normal;
-	PxF32 c;
-	Line2D(PxVec2 vec, PxVec2 point)
-	{
-		normal.x = vec.y;
-		normal.y = -vec.x;
-		c = -normal.dot(point);
-	}
-};
-
-
-uint32_t TriangleProcessor::getSegmentIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2, PxF32& t1)
-{
-	if (!boundingRectangleIntersection(s1, e1, s2, e2))
-		return 0;
-
-	PxVec2 vec1 = e1 - s1;
-	PxVec2 vec2 = e2 - s2;
-	PxF32 det1 = getRotation(vec1, vec2);
-	if (PxAbs(det1) < COLLIN_EPS)
-	{
-		return 0;
-	}
-	Line2D lineA(vec1, s1);
-	Line2D lineB(vec2, s2);
-	PxVec2 fInt;
-
-	PxF32 detX = lineA.normal.y * lineB.c - lineA.c * lineB.normal.y;
-	PxF32 detY = lineA.c * lineB.normal.x - lineB.c * lineA.normal.x;
-	PxF32 x = detX / det1;
-	PxF32 y = detY / det1;
-
-	if (x + V_COMP_EPS >= PxMax(PxMin(s1.x, e1.x), PxMin(s2.x, e2.x)) &&
-		x - V_COMP_EPS <= PxMin(PxMax(s1.x, e1.x), PxMax(s2.x, e2.x)) &&
-		y + V_COMP_EPS >= PxMax(PxMin(s1.y, e1.y), PxMin(s2.y, e2.y)) &&
-		y - V_COMP_EPS <= PxMin(PxMax(s1.y, e1.y), PxMax(s2.y, e2.y)))
-	{
-		fInt.x = x;
-		fInt.y = y;
-		t1 = getParameter(s1, e1, fInt);
-		return 1;
-	}
-
-	return 0;
-}
-
-struct cwComparer
-{
-	PxVec3 basePoint;
-	PxVec3 normal;
-	cwComparer(PxVec3 basePointIn, PxVec3 norm)
-	{
-		basePoint = basePointIn;
-		normal = norm;
-	};
-	bool operator()(const PxVec3& a, const PxVec3& b)
-	{
-		PxVec3 norm = (a - basePoint).cross(b - basePoint);
-		return normal.dot(norm) > 0;		
-	}
-};
-
-bool vec3Comparer(const PxVec3& a, const PxVec3& b)
-{
-		if (a.x + V_COMP_EPS < b.x) return true;
-		if (a.x - V_COMP_EPS > b.x) return false;
-		if (a.y + V_COMP_EPS < b.y) return true;
-		if (a.y - V_COMP_EPS > b.y) return false;
-		if (a.z + V_COMP_EPS < b.z) return true;
-		return false;
-}
-
-void TriangleProcessor::sortToCCW(std::vector<PxVec3>& points, PxVec3& normal)
-{
-	std::sort(points.begin(), points.end(), vec3Comparer);
-	int lastUnique = 0;
-	for (uint32_t i = 1; i < points.size(); ++i)
-	{
-		PxVec3 df = points[i] - points[lastUnique];
-		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)
-		{
-			points[++lastUnique] = points[i];
-		}
-	}
-	points.resize(lastUnique + 1);
-	if (points.size() > 2)
-	{
-		cwComparer compr(points[0], normal);
-		std::sort(points.begin() + 1, points.end(), compr);
-	}
-}
-
-
-
-void TriangleProcessor::buildConvexHull(std::vector<PxVec3>& points, std::vector<PxVec3>& convexHull,const PxVec3& normal)
-{
-
-	std::sort(points.begin(), points.end(), vec3Comparer);
-	int lastUnique = 0;
-	for (uint32_t i = 1; i < points.size(); ++i)
-	{
-		PxVec3 df = points[i] - points[lastUnique];
-		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)
-		{
-			points[++lastUnique] = points[i];
-		}
-	}
-	points.resize(lastUnique + 1);
-	if (points.size() > 2)
-	{
-		cwComparer compr(points[0], normal);
-		std::sort(points.begin() + 1, points.end(), compr);
-	}
-	if (points.size() < 3)
-		return;
-	convexHull.push_back(points[0]);
-	convexHull.push_back(points[1]);
-	ProjectionDirections projectionDirection = getProjectionDirection(normal);
-	for (uint32_t i = 2; i < points.size(); ++i)
-	{
-		PxVec2 pnt = getProjectedPointWithWinding(points[i], projectionDirection);
-		PxVec2 vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);
-		if (vec.x < V_COMP_EPS && vec.y < V_COMP_EPS)
-		{
-			continue;
-		}
-		if (getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) < 0)
-		{
-			convexHull.push_back(points[i]);
-		}
-		else
-		{
-			while (convexHull.size() > 1 && getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) > 0)
-			{
-				convexHull.pop_back();
-				vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);
-			}
-			convexHull.push_back(points[i]);
-		}
-	}
-}
-
-
-uint32_t TriangleProcessor::getTriangleIntersection(TrPrcTriangle& a, TrPrcTriangle2d& aProjected, TrPrcTriangle &b, PxVec3& centroid, std::vector<PxVec3>& intersectionBuffer, PxVec3 normal)
-{
-
-	b.points[0] -= centroid;
-	b.points[1] -= centroid;
-	b.points[2] -= centroid;
-
-	ProjectionDirections prjDir = getProjectionDirection(normal);
-
-	TrPrcTriangle2d bProjected;
-	bProjected.points[0] = getProjectedPointWithWinding(b.points[0], prjDir);
-	bProjected.points[1] = getProjectedPointWithWinding(b.points[1], prjDir);
-	bProjected.points[2] = getProjectedPointWithWinding(b.points[2], prjDir);
-
-
-	if (!triangleBoundingBoxIntersection(aProjected, bProjected)) return 0;
-
-	//* Check triangle A against points of B *//
-	for (int i = 0; i < 3; ++i)
-	{
-		if (isPointInside(bProjected.points[i], aProjected))
-		{
-			intersectionBuffer.push_back(b.points[i]);
-		}
-	}
-	//* Check triangle B against points of A *//
-	for (int i = 0; i < 3; ++i)
-	{
-		if (isPointInside(aProjected.points[i], bProjected))
-		{
-			intersectionBuffer.push_back(a.points[i]);
-		}
-	}
-
-	//* Check edges intersection *//
-	float param = 0;
-	for (int i = 0; i < 3; ++i)
-	{
-		for (int j = 0; j < 3; ++j)
-		{
-			if (getSegmentIntersection(aProjected.points[i], aProjected.points[(i + 1) % 3], bProjected.points[j], bProjected.points[(j + 1) % 3], param))
-			{
-				intersectionBuffer.push_back(lerp3D(a.points[i], a.points[(i + 1) % 3], param));
-			}
-		}
-	}
-
-	if (intersectionBuffer.size() == 0)
-		return 0;
-
-	// Intersection between two triangles is convex, but points should be reordered to construct right polygon //
-	std::vector<PxVec3> intrs;
-	buildConvexHull(intersectionBuffer, intrs, normal);
-	intersectionBuffer = intrs;
-
-	// Return all points back from origin //
-	for (uint32_t i = 0; i < intersectionBuffer.size(); ++i)
-	{
-		intersectionBuffer[i] += centroid;
-	}
-	return 1;
-}
-
-
-
-bool TriangleProcessor::triangleBoundingBoxIntersection(TrPrcTriangle2d& a, TrPrcTriangle2d& b)
-{
-	float fb = std::min(a.points[0].x, std::min(a.points[1].x, a.points[2].x));
-	float fe = std::max(a.points[0].x, std::max(a.points[1].x, a.points[2].x));
-
-	float sb = std::min(b.points[0].x, std::min(b.points[1].x, b.points[2].x));
-	float se = std::max(b.points[0].x, std::max(b.points[1].x, b.points[2].x));
-
-	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;
-
-	fb = std::min(a.points[0].y, std::min(a.points[1].y, a.points[2].y));
-	fe = std::max(a.points[0].y, std::max(a.points[1].y, a.points[2].y));
-
-	sb = std::min(b.points[0].y, std::min(b.points[1].y, b.points[2].y));
-	se = std::max(b.points[0].y, std::max(b.points[1].y, b.points[2].y));
-	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;
-	return 1;
-}
-
-
-uint32_t TriangleProcessor::isPointInside(const PxVec2& point, const TrPrcTriangle2d& triangle)
-{
-	PxF32 av = getRotation(point - triangle.points[0], triangle.points[1] - triangle.points[0]);
-	PxF32 bv = getRotation(point - triangle.points[1], triangle.points[2] - triangle.points[1]);
-	PxF32 cv = getRotation(point - triangle.points[2], triangle.points[0] - triangle.points[2]);
-
-
-	if (PxAbs(av) < COLLIN_EPS) av = 0;
-	if (PxAbs(bv) < COLLIN_EPS) bv = 0;
-	if (PxAbs(cv) < COLLIN_EPS) cv = 0;
-
-	if (av >= 0 && bv >= 0 && cv >= 0)
-	{
-		if (av == 0 || bv == 0 || cv == 0)
-			return 2;
-		return 1;
-	}
-	if (av <= 0 && bv <= 0 && cv <= 0)
-	{
-		if (av == 0 || bv == 0 || cv == 0)
-			return 2;
-		return 1;
-	}
-	return 0;
-}
-
-} // namespace Blast
-} // namespace Nv
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.

+

+

+#include "NvBlastExtTriangleProcessor.h"

+#include "NvBlastExtAuthoringInternalCommon.h"

+#define COLLIN_EPS 1e-4f

+#define V_COMP_EPS 1e-5f

+

+using namespace physx;

+

+namespace Nv

+{

+namespace Blast

+{

+/**

+	Segments bounding box interseciton test

+*/

+bool boundingRectangleIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2)

+{

+	// sl1/sl2 is always left bottom end of rectangle

+	// se1/el2 is always right top end of rectangle

+

+	PxF32 sl1, sl2, el1, el2;

+	if (s1.x < e1.x)

+	{

+		sl1 = s1.x;

+		el1 = e1.x;

+	}

+	else

+	{

+		el1 = s1.x;

+		sl1 = e1.x;

+	}

+

+	if (s2.x < e2.x)

+	{

+		sl2 = s2.x;

+		el2 = e2.x;

+	}

+	else

+	{

+		el2 = s2.x;

+		sl2 = e2.x;

+	}

+	if (PxMax(sl1, sl2) > PxMin(el1, el2))

+		return false;

+

+	if (s1.y < e1.y)

+	{

+		sl1 = s1.y;

+		el1 = e1.y;

+	}

+	else

+	{

+		el1 = s1.y;

+		sl1 = e1.y;

+	}

+

+	if (s2.y < e2.y)

+	{

+		sl2 = s2.y;

+		el2 = e2.y;

+	}

+	else

+	{

+		el2 = s2.y;

+		sl2 = e2.y;

+	}

+	if (PxMax(sl1, sl2) > PxMin(el1, el2))

+		return false;

+

+	return true;

+}

+

+inline PxF32 getRotation(PxVec2 a, PxVec2 b)

+{

+	return a.x * b.y - a.y * b.x;

+}

+

+inline PxF32 getParameter(const PxVec2& a, const PxVec2& b, const PxVec2& point)

+{

+	return (point - a).magnitude() / (b - a).magnitude();

+}

+inline PxVec3 lerp3D(const PxVec3& a, const PxVec3& b, const PxF32 t)

+{

+	return (b - a) * t + a;

+}

+

+

+

+struct Line2D

+{

+	PxVec2 normal;

+	PxF32 c;

+	Line2D(PxVec2 vec, PxVec2 point)

+	{

+		normal.x = vec.y;

+		normal.y = -vec.x;

+		c = -normal.dot(point);

+	}

+};

+

+

+uint32_t TriangleProcessor::getSegmentIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2, PxF32& t1)

+{

+	if (!boundingRectangleIntersection(s1, e1, s2, e2))

+		return 0;

+

+	PxVec2 vec1 = e1 - s1;

+	PxVec2 vec2 = e2 - s2;

+	PxF32 det1 = getRotation(vec1, vec2);

+	if (PxAbs(det1) < COLLIN_EPS)

+	{

+		return 0;

+	}

+	Line2D lineA(vec1, s1);

+	Line2D lineB(vec2, s2);

+	PxVec2 fInt;

+

+	PxF32 detX = lineA.normal.y * lineB.c - lineA.c * lineB.normal.y;

+	PxF32 detY = lineA.c * lineB.normal.x - lineB.c * lineA.normal.x;

+	PxF32 x = detX / det1;

+	PxF32 y = detY / det1;

+

+	if (x + V_COMP_EPS >= PxMax(PxMin(s1.x, e1.x), PxMin(s2.x, e2.x)) &&

+		x - V_COMP_EPS <= PxMin(PxMax(s1.x, e1.x), PxMax(s2.x, e2.x)) &&

+		y + V_COMP_EPS >= PxMax(PxMin(s1.y, e1.y), PxMin(s2.y, e2.y)) &&

+		y - V_COMP_EPS <= PxMin(PxMax(s1.y, e1.y), PxMax(s2.y, e2.y)))

+	{

+		fInt.x = x;

+		fInt.y = y;

+		t1 = getParameter(s1, e1, fInt);

+		return 1;

+	}

+

+	return 0;

+}

+

+struct cwComparer

+{

+	PxVec3 basePoint;

+	PxVec3 normal;

+	cwComparer(PxVec3 basePointIn, PxVec3 norm)

+	{

+		basePoint = basePointIn;

+		normal = norm;

+	};

+	bool operator()(const PxVec3& a, const PxVec3& b)

+	{

+		PxVec3 norm = (a - basePoint).cross(b - basePoint);

+		return normal.dot(norm) > 0;		

+	}

+};

+

+bool vec3Comparer(const PxVec3& a, const PxVec3& b)

+{

+		if (a.x + V_COMP_EPS < b.x) return true;

+		if (a.x - V_COMP_EPS > b.x) return false;

+		if (a.y + V_COMP_EPS < b.y) return true;

+		if (a.y - V_COMP_EPS > b.y) return false;

+		if (a.z + V_COMP_EPS < b.z) return true;

+		return false;

+}

+

+void TriangleProcessor::sortToCCW(std::vector<PxVec3>& points, PxVec3& normal)

+{

+	std::sort(points.begin(), points.end(), vec3Comparer);

+	int lastUnique = 0;

+	for (uint32_t i = 1; i < points.size(); ++i)

+	{

+		PxVec3 df = points[i] - points[lastUnique];

+		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)

+		{

+			points[++lastUnique] = points[i];

+		}

+	}

+	points.resize(lastUnique + 1);

+	if (points.size() > 2)

+	{

+		cwComparer compr(points[0], normal);

+		std::sort(points.begin() + 1, points.end(), compr);

+	}

+}

+

+

+

+void TriangleProcessor::buildConvexHull(std::vector<PxVec3>& points, std::vector<PxVec3>& convexHull,const PxVec3& normal)

+{

+

+	std::sort(points.begin(), points.end(), vec3Comparer);

+	int lastUnique = 0;

+	for (uint32_t i = 1; i < points.size(); ++i)

+	{

+		PxVec3 df = points[i] - points[lastUnique];

+		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)

+		{

+			points[++lastUnique] = points[i];

+		}

+	}

+	points.resize(lastUnique + 1);

+	if (points.size() > 2)

+	{

+		cwComparer compr(points[0], normal);

+		std::sort(points.begin() + 1, points.end(), compr);

+	}

+	if (points.size() < 3)

+		return;

+	convexHull.push_back(points[0]);

+	convexHull.push_back(points[1]);

+	ProjectionDirections projectionDirection = getProjectionDirection(normal);

+	for (uint32_t i = 2; i < points.size(); ++i)

+	{

+		PxVec2 pnt = getProjectedPointWithWinding(points[i], projectionDirection);

+		PxVec2 vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);

+		if (vec.x < V_COMP_EPS && vec.y < V_COMP_EPS)

+		{

+			continue;

+		}

+		if (getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) < 0)

+		{

+			convexHull.push_back(points[i]);

+		}

+		else

+		{

+			while (convexHull.size() > 1 && getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) > 0)

+			{

+				convexHull.pop_back();

+				vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);

+			}

+			convexHull.push_back(points[i]);

+		}

+	}

+}

+

+

+uint32_t TriangleProcessor::getTriangleIntersection(TrPrcTriangle& a, TrPrcTriangle2d& aProjected, TrPrcTriangle &b, PxVec3& centroid, std::vector<PxVec3>& intersectionBuffer, PxVec3 normal)

+{

+

+	b.points[0] -= centroid;

+	b.points[1] -= centroid;

+	b.points[2] -= centroid;

+

+	ProjectionDirections prjDir = getProjectionDirection(normal);

+

+	TrPrcTriangle2d bProjected;

+	bProjected.points[0] = getProjectedPointWithWinding(b.points[0], prjDir);

+	bProjected.points[1] = getProjectedPointWithWinding(b.points[1], prjDir);

+	bProjected.points[2] = getProjectedPointWithWinding(b.points[2], prjDir);

+

+

+	if (!triangleBoundingBoxIntersection(aProjected, bProjected)) return 0;

+

+	//* Check triangle A against points of B *//

+	for (int i = 0; i < 3; ++i)

+	{

+		if (isPointInside(bProjected.points[i], aProjected))

+		{

+			intersectionBuffer.push_back(b.points[i]);

+		}

+	}

+	//* Check triangle B against points of A *//

+	for (int i = 0; i < 3; ++i)

+	{

+		if (isPointInside(aProjected.points[i], bProjected))

+		{

+			intersectionBuffer.push_back(a.points[i]);

+		}

+	}

+

+	//* Check edges intersection *//

+	float param = 0;

+	for (int i = 0; i < 3; ++i)

+	{

+		for (int j = 0; j < 3; ++j)

+		{

+			if (getSegmentIntersection(aProjected.points[i], aProjected.points[(i + 1) % 3], bProjected.points[j], bProjected.points[(j + 1) % 3], param))

+			{

+				intersectionBuffer.push_back(lerp3D(a.points[i], a.points[(i + 1) % 3], param));

+			}

+		}

+	}

+

+	if (intersectionBuffer.size() == 0)

+		return 0;

+

+	// Intersection between two triangles is convex, but points should be reordered to construct right polygon //

+	std::vector<PxVec3> intrs;

+	buildConvexHull(intersectionBuffer, intrs, normal);

+	intersectionBuffer = intrs;

+

+	// Return all points back from origin //

+	for (uint32_t i = 0; i < intersectionBuffer.size(); ++i)

+	{

+		intersectionBuffer[i] += centroid;

+	}

+	return 1;

+}

+

+

+

+bool TriangleProcessor::triangleBoundingBoxIntersection(TrPrcTriangle2d& a, TrPrcTriangle2d& b)

+{

+	float fb = std::min(a.points[0].x, std::min(a.points[1].x, a.points[2].x));

+	float fe = std::max(a.points[0].x, std::max(a.points[1].x, a.points[2].x));

+

+	float sb = std::min(b.points[0].x, std::min(b.points[1].x, b.points[2].x));

+	float se = std::max(b.points[0].x, std::max(b.points[1].x, b.points[2].x));

+

+	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;

+

+	fb = std::min(a.points[0].y, std::min(a.points[1].y, a.points[2].y));

+	fe = std::max(a.points[0].y, std::max(a.points[1].y, a.points[2].y));

+

+	sb = std::min(b.points[0].y, std::min(b.points[1].y, b.points[2].y));

+	se = std::max(b.points[0].y, std::max(b.points[1].y, b.points[2].y));

+	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;

+	return 1;

+}

+

+

+uint32_t TriangleProcessor::isPointInside(const PxVec2& point, const TrPrcTriangle2d& triangle)

+{

+	PxF32 av = getRotation(point - triangle.points[0], triangle.points[1] - triangle.points[0]);

+	PxF32 bv = getRotation(point - triangle.points[1], triangle.points[2] - triangle.points[1]);

+	PxF32 cv = getRotation(point - triangle.points[2], triangle.points[0] - triangle.points[2]);

+

+

+	if (PxAbs(av) < COLLIN_EPS) av = 0;

+	if (PxAbs(bv) < COLLIN_EPS) bv = 0;

+	if (PxAbs(cv) < COLLIN_EPS) cv = 0;

+

+	if (av >= 0 && bv >= 0 && cv >= 0)

+	{

+		if (av == 0 || bv == 0 || cv == 0)

+			return 2;

+		return 1;

+	}

+	if (av <= 0 && bv <= 0 && cv <= 0)

+	{

+		if (av == 0 || bv == 0 || cv == 0)

+			return 2;

+		return 1;

+	}

+	return 0;

+}

+

+} // namespace Blast

+} // namespace Nv