Blast SDK 1.1.5 prerelease #1v1.1.5_pre1

1 files changed, 209 insertions, 204 deletions

diff --git a/sdk/extensions/authoring/source/NvBlastExtAuthoringMeshNoiser.cpp b/sdk/extensions/authoring/source/NvBlastExtAuthoringMeshNoiser.cpp
index 22e5d4d..5810b9a 100755
--- a/sdk/extensions/authoring/source/NvBlastExtAuthoringMeshNoiser.cpp
+++ b/sdk/extensions/authoring/source/NvBlastExtAuthoringMeshNoiser.cpp
@@ -38,11 +38,11 @@
 #include <set>

 #include <queue>

 #include <NvBlastAssert.h>

+#include <NvBlastPxSharedHelpers.h>

 

 using namespace Nv::Blast;

 using namespace std;

 

-

 void MeshNoiser::computeFalloffAndNormals()

 {

 	// Map newly created vertices according to positions

@@ -73,8 +73,8 @@ void MeshNoiser::computeFalloffAndNormals()
 	{

 		if (mTrMeshEdToTr[i].c != 0 && (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == EXTERNAL_BORDER_EDGE))

 		{

-			int32_t v1 = mPositionMappedVrt[mEdges[i].s];

-			int32_t v2 = mPositionMappedVrt[mEdges[i].e];

+			int32_t v1             = mPositionMappedVrt[mEdges[i].s];

+			int32_t v2             = mPositionMappedVrt[mEdges[i].e];

 			mVerticesDistances[v1] = 0.0f;

 			mVerticesDistances[v2] = 0.0f;

 			que.push(v1);

@@ -89,7 +89,7 @@ void MeshNoiser::computeFalloffAndNormals()
 		for (uint32_t i = 0; i < mGeometryGraph[curr].size(); ++i)

 		{

 			int32_t to = mGeometryGraph[curr][i];

-			float d = mVerticesDistances[curr] + 0.1f;// (mVertices[to].p - mVertices[curr].p).magnitudeSquared();

+			float d    = mVerticesDistances[curr] + 0.1f;  // (mVertices[to].p - mVertices[curr].p).magnitudeSquared();

 			if (d < mVerticesDistances[to])

 			{

 				mVerticesDistances[to] = d;

@@ -100,24 +100,28 @@ void MeshNoiser::computeFalloffAndNormals()
 

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

 	{

-		int32_t from = mPositionMappedVrt[i];

-		mVerticesDistances[i] = mVerticesDistances[from]; 

+		int32_t from          = mPositionMappedVrt[i];

+		mVerticesDistances[i] = mVerticesDistances[from];

 	}

 }

 

-bool edgeOverlapTest(PxVec3& as, PxVec3& ae, PxVec3& bs, PxVec3& be)

+bool edgeOverlapTest(NvcVec3& as, NvcVec3& ae, NvcVec3& bs, NvcVec3& be)

 {

-	//return false;

-	if (std::max(std::min(as.x, ae.x), std::min(bs.x, be.x)) > std::min(std::max(as.x, ae.x), std::max(bs.x, be.x))) return false;

-	if (std::max(std::min(as.y, ae.y), std::min(bs.y, be.y)) > std::min(std::max(as.y, ae.y), std::max(bs.y, be.y))) return false;

-	if (std::max(std::min(as.z, ae.z), std::min(bs.z, be.z)) > std::min(std::max(as.z, ae.z), std::max(bs.z, be.z))) return false;

-

-	return ((bs - as).cross(ae - as)).magnitudeSquared() < 1e-6f && ((be - as).cross(ae - as)).magnitudeSquared() < 1e-6f;

+	// return false;

+	if (std::max(std::min(as.x, ae.x), std::min(bs.x, be.x)) > std::min(std::max(as.x, ae.x), std::max(bs.x, be.x)))

+		return false;

+	if (std::max(std::min(as.y, ae.y), std::min(bs.y, be.y)) > std::min(std::max(as.y, ae.y), std::max(bs.y, be.y)))

+		return false;

+	if (std::max(std::min(as.z, ae.z), std::min(bs.z, be.z)) > std::min(std::max(as.z, ae.z), std::max(bs.z, be.z)))

+		return false;

+

+	return (toPxShared(bs - as).cross(toPxShared(ae - as))).magnitudeSquared() < 1e-6f &&

+	       (toPxShared(be - as).cross(toPxShared(ae - as))).magnitudeSquared() < 1e-6f;

 }

 

 void MeshNoiser::computePositionedMapping()

 {

-	std::map<PxVec3, int32_t, VrtPositionComparator> mPosMap;

+	std::map<NvcVec3, int32_t, VrtPositionComparator> mPosMap;

 	mPositionMappedVrt.clear();

 	mPositionMappedVrt.resize(mVertices.size());

 

@@ -128,7 +132,7 @@ void MeshNoiser::computePositionedMapping()
 		if (it == mPosMap.end())

 		{

 			mPosMap[mVertices[i].p] = i;

-			mPositionMappedVrt[i] = i;

+			mPositionMappedVrt[i]   = i;

 		}

 		else

 		{

@@ -138,8 +142,6 @@ void MeshNoiser::computePositionedMapping()
 }

 

 

-

-

 void MeshNoiser::relax(int32_t iteration, float factor, std::vector<Vertex>& vertices)

 {

 	std::vector<PxVec3> verticesTemp(vertices.size());

@@ -152,7 +154,7 @@ void MeshNoiser::relax(int32_t iteration, float factor, std::vector<Vertex>& ver
 			{

 				continue;

 			}

-			PxVec3 cps = vertices[i].p;

+			PxVec3 cps = toPxShared(vertices[i].p);

 			PxVec3 cns = mVerticesNormalsSmoothed[i];

 			PxVec3 averaged(0, 0, 0);

 			PxVec3 averagedNormal(0, 0, 0);

@@ -160,14 +162,13 @@ void MeshNoiser::relax(int32_t iteration, float factor, std::vector<Vertex>& ver
 			for (uint32_t p = 0; p < mGeometryGraph[mPositionMappedVrt[i]].size(); ++p)

 			{

 				int32_t to = mGeometryGraph[mPositionMappedVrt[i]][p];

-				averaged += vertices[to].p;

+				averaged += toPxShared(vertices[to].p);

 				averagedNormal += mVerticesNormalsSmoothed[to];

-

 			}

 			averaged *= (1.0f / mGeometryGraph[mPositionMappedVrt[i]].size());

 			averagedNormal *= (1.0f / mGeometryGraph[mPositionMappedVrt[i]].size());

 			verticesTemp[i] = cps + (averaged - cps) * factor;

-			normalsTemp[i] = cns * (1.0f - factor) + averagedNormal * factor;

+			normalsTemp[i]  = cns * (1.0f - factor) + averagedNormal * factor;

 		}

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

 		{

@@ -175,15 +176,14 @@ void MeshNoiser::relax(int32_t iteration, float factor, std::vector<Vertex>& ver
 			{

 				continue;

 			}

-			vertices[i].p = verticesTemp[i];

+			vertices[i].p               = fromPxShared(verticesTemp[i]);

 			mVerticesNormalsSmoothed[i] = normalsTemp[i].getNormalized();

-

 		}

 	}

-

 }

 

-NV_FORCE_INLINE void markEdge(int32_t ui, int32_t ed, std::vector<MeshNoiser::EdgeFlag>& shortMarkup, std::vector<int32_t>& lastOwner)

+NV_FORCE_INLINE void

+markEdge(int32_t ui, int32_t ed, std::vector<MeshNoiser::EdgeFlag>& shortMarkup, std::vector<int32_t>& lastOwner)

 {

 	if (shortMarkup[ed] == MeshNoiser::NONE)

 	{

@@ -227,7 +227,7 @@ void MeshNoiser::prebuildEdgeFlagArray()
 	mEdgeFlag.clear();

 	mEdgeFlag.resize(mEdges.size(), NONE);

 

-	std::map<PxVec3, int32_t, VrtPositionComparator> mPosMap;

+	std::map<NvcVec3, int32_t, VrtPositionComparator> mPosMap;

 	mPositionMappedVrt.clear();

 	mPositionMappedVrt.resize(mVertices.size(), 0);

 

@@ -238,7 +238,7 @@ void MeshNoiser::prebuildEdgeFlagArray()
 		if (it == mPosMap.end())

 		{

 			mPosMap[mVertices[i].p] = i;

-			mPositionMappedVrt[i] = i;

+			mPositionMappedVrt[i]   = i;

 		}

 		else

 		{

@@ -252,12 +252,13 @@ void MeshNoiser::prebuildEdgeFlagArray()
 

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

 	{

-		Edge tmp = Edge(mPositionMappedVrt[mEdges[i].s], mPositionMappedVrt[mEdges[i].e]);

-		if (tmp.e < tmp.s) std::swap(tmp.e, tmp.s);

+		Edge tmp = { mPositionMappedVrt[mEdges[i].s], mPositionMappedVrt[mEdges[i].e] };

+		if (tmp.e < tmp.s)

+			std::swap(tmp.e, tmp.s);

 		auto it = mPositionEdgeMap.find(tmp);

 		if (it == mPositionEdgeMap.end())

 		{

-			mPositionEdgeMap[tmp] = i;

+			mPositionEdgeMap[tmp]  = i;

 			mPositionBasedEdges[i] = i;

 		}

 		else

@@ -278,7 +279,7 @@ void MeshNoiser::prebuildEdgeFlagArray()
 		{

 			Edge& ed1 = mEdges[it1->second];

 			Edge& ed2 = mEdges[it2->second];

-			

+

 			if (edgeOverlapTest(mVertices[ed1.s].p, mVertices[ed1.e].p, mVertices[ed2.s].p, mVertices[ed2.e].p))

 			{

 				edgeOverlap[it1->second].push_back(it2->second);

@@ -289,29 +290,28 @@ void MeshNoiser::prebuildEdgeFlagArray()
 	for (uint32_t i = 0; i < mTriangles.size(); ++i)

 	{

 		int32_t ui = mTriangles[i].userData;

-		int32_t ed = mPositionBasedEdges[findEdge(Edge(mTriangles[i].ea, mTriangles[i].eb))];

+		int32_t ed = mPositionBasedEdges[findEdge({ mTriangles[i].ea, mTriangles[i].eb })];

+

 

-		

 		markEdge(ui, ed, shortMarkup, lastOwner);

 		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)

 		{

 			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);

 		}

 

-		ed = mPositionBasedEdges[findEdge(Edge(mTriangles[i].ea, mTriangles[i].ec))];

+		ed = mPositionBasedEdges[findEdge({ mTriangles[i].ea, mTriangles[i].ec })];

 		markEdge(ui, ed, shortMarkup, lastOwner);

 		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)

 		{

 			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);

 		}

 

-		ed = mPositionBasedEdges[findEdge(Edge(mTriangles[i].eb, mTriangles[i].ec))];

+		ed = mPositionBasedEdges[findEdge({ mTriangles[i].eb, mTriangles[i].ec })];

 		markEdge(ui, ed, shortMarkup, lastOwner);

 		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)

 		{

 			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);

 		}

-

 	}

 

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

@@ -321,20 +321,19 @@ void MeshNoiser::prebuildEdgeFlagArray()
 

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

 	{

-		if (mTriangles[i].userData != 0) continue;

+		if (mTriangles[i].userData != 0)

+			continue;

 

-		int32_t ed = findEdge(Edge(mTriangles[i].ea, mTriangles[i].eb));

+		int32_t ed    = findEdge({ mTriangles[i].ea, mTriangles[i].eb });

 		mEdgeFlag[ed] = EXTERNAL_EDGE;

-		ed = findEdge(Edge(mTriangles[i].ec, mTriangles[i].eb));

+		ed            = findEdge({ mTriangles[i].ec, mTriangles[i].eb });

 		mEdgeFlag[ed] = EXTERNAL_EDGE;

-		ed = findEdge(Edge(mTriangles[i].ea, mTriangles[i].ec));

+		ed            = findEdge({ mTriangles[i].ea, mTriangles[i].ec });

 		mEdgeFlag[ed] = EXTERNAL_EDGE;

 	}

 }

 

 

-

-

 NV_FORCE_INLINE int32_t MeshNoiser::addVerticeIfNotExist(const Vertex& p)

 {

 	auto it = mVertMap.find(p);

@@ -353,7 +352,8 @@ NV_FORCE_INLINE int32_t MeshNoiser::addVerticeIfNotExist(const Vertex& p)
 NV_FORCE_INLINE int32_t MeshNoiser::addEdge(const Edge& e)

 {

 	Edge ed = e;

-	if (ed.e < ed.s) std::swap(ed.s, ed.e);

+	if (ed.e < ed.s)

+		std::swap(ed.s, ed.e);

 	auto it = mEdgeMap.find(ed);

 	if (it == mEdgeMap.end())

 	{

@@ -372,7 +372,8 @@ NV_FORCE_INLINE int32_t MeshNoiser::addEdge(const Edge& e)
 NV_FORCE_INLINE int32_t MeshNoiser::findEdge(const Edge& e)

 {

 	Edge ed = e;

-	if (ed.e < ed.s) std::swap(ed.s, ed.e);

+	if (ed.e < ed.s)

+		std::swap(ed.s, ed.e);

 	auto it = mEdgeMap.find(ed);

 	if (it == mEdgeMap.end())

 	{

@@ -386,38 +387,37 @@ NV_FORCE_INLINE int32_t MeshNoiser::findEdge(const Edge& e)
 

 

 /**

-	Weld input vertices, build edge and triangle buffers

+    Weld input vertices, build edge and triangle buffers

 */

 void MeshNoiser::setMesh(const vector<Triangle>& mesh)

 {

 	uint32_t a, b, c;

-	PxBounds3 box;

+	physx::PxBounds3 box;

 	box.setEmpty();

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

 	{

 		const Triangle& tr = mesh[i];

-		a = addVerticeIfNotExist(tr.a);

-		b = addVerticeIfNotExist(tr.b);

-		c = addVerticeIfNotExist(tr.c);

-		box.include(tr.a.p);

-		box.include(tr.b.p);

-		box.include(tr.c.p);

-		addEdge(Edge(a, b));

-		addEdge(Edge(b, c));

-		addEdge(Edge(a, c));

-		mTriangles.push_back(TriangleIndexed(a, b, c));

-		mTriangles.back().userData = tr.userData;

-		mTriangles.back().materialId = tr.materialId;

+		a                  = addVerticeIfNotExist(tr.a);

+		b                  = addVerticeIfNotExist(tr.b);

+		c                  = addVerticeIfNotExist(tr.c);

+		box.include(toPxShared(tr.a.p));

+		box.include(toPxShared(tr.b.p));

+		box.include(toPxShared(tr.c.p));

+		addEdge({ a, b });

+		addEdge({ b, c });

+		addEdge({ a, c });

+		mTriangles.push_back({a, b, c});

+		mTriangles.back().userData       = tr.userData;

+		mTriangles.back().materialId     = tr.materialId;

 		mTriangles.back().smoothingGroup = tr.smoothingGroup;

-

 	}

-	mOffset = box.getCenter();

-	mScale = max(box.getExtents(0), max(box.getExtents(1), box.getExtents(2)));

+	mOffset        = box.getCenter();

+	mScale         = max(box.getExtents(0), max(box.getExtents(1), box.getExtents(2)));

 	float invScale = 1.0f / mScale;

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

 	{

-		mVertices[i].p = mVertices[i].p - box.getCenter();

-		mVertices[i].p *= invScale;

+		mVertices[i].p = mVertices[i].p - fromPxShared(box.getCenter());

+		mVertices[i].p = mVertices[i].p * invScale;

 	}

 }

 

@@ -441,41 +441,41 @@ void MeshNoiser::tesselateInternalSurface(float maxLenIn)
 		}

 	}

 

-	

-	float maxLen = maxLenIn; 

-	float mlSq = maxLen * maxLen;

-	float minD = maxLen * 0.5f;

-		minD = minD * minD;

-		

-		for (int32_t iter = 0; iter < 15; ++iter)

+

+	float maxLen = maxLenIn;

+	float mlSq   = maxLen * maxLen;

+	float minD   = maxLen * 0.5f;

+	minD         = minD * minD;

+

+	for (int32_t iter = 0; iter < 15; ++iter)

+	{

+		updateVertEdgeInfo();

+		uint32_t oldSize = (uint32_t)mEdges.size();

+		for (uint32_t i = 0; i < oldSize; ++i)

 		{

-			updateVertEdgeInfo();

-			uint32_t oldSize = (uint32_t)mEdges.size();

-			for (uint32_t i = 0; i < oldSize; ++i)

+			if (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == INTERNAL_BORDER_EDGE)

 			{

-				if (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == INTERNAL_BORDER_EDGE)

-				{

-					continue;

-				}

-				if ((mVertices[mEdges[i].s].p - mVertices[mEdges[i].e].p).magnitudeSquared() < minD)

-				{

-					collapseEdge(i);

-				}

+				continue;

 			}

-			oldSize = (uint32_t)mEdges.size();

-			updateEdgeTriangleInfo();

-			for (uint32_t i = 0; i < oldSize; ++i)

+			if (toPxShared(mVertices[mEdges[i].s].p - mVertices[mEdges[i].e].p).magnitudeSquared() < minD)

 			{

-				if (mEdgeFlag[i] == EXTERNAL_EDGE)

-				{

-					continue;

-				}

-				if ((mVertices[mEdges[i].s].p - mVertices[mEdges[i].e].p).magnitudeSquared() > mlSq)

-				{

-					divideEdge(i);

-				}

+				collapseEdge(i);

+			}

+		}

+		oldSize = (uint32_t)mEdges.size();

+		updateEdgeTriangleInfo();

+		for (uint32_t i = 0; i < oldSize; ++i)

+		{

+			if (mEdgeFlag[i] == EXTERNAL_EDGE)

+			{

+				continue;

+			}

+			if (toPxShared(mVertices[mEdges[i].s].p - mVertices[mEdges[i].e].p).magnitudeSquared() > mlSq)

+			{

+				divideEdge(i);

 			}

 		}

+	}

 	computeFalloffAndNormals();

 	prebuildTesselatedTriangles();

 	isTesselated = true;

@@ -488,13 +488,13 @@ void MeshNoiser::updateEdgeTriangleInfo()
 	for (uint32_t i = 0; i < mTriangles.size(); ++i)

 	{

 		TriangleIndexed& tr = mTriangles[i];

-		if (tr.ea == NOT_VALID_VERTEX)

+		if (tr.ea == kNotValidVertexIndex)

 			continue;

-		int32_t ed = addEdge(Edge(tr.ea, tr.eb));

+		int32_t ed = addEdge({ tr.ea, tr.eb });

 		mTrMeshEdToTr[ed].add(i);

-		ed = addEdge(Edge(tr.ea, tr.ec));

+		ed = addEdge({ tr.ea, tr.ec });

 		mTrMeshEdToTr[ed].add(i);

-		ed = addEdge(Edge(tr.ec, tr.eb));

+		ed = addEdge({ tr.ec, tr.eb });

 		mTrMeshEdToTr[ed].add(i);

 	}

 }

@@ -506,7 +506,8 @@ void MeshNoiser::updateVertEdgeInfo()
 	for (uint32_t i = 0; i < mTriangles.size(); ++i)

 	{

 		TriangleIndexed& tr = mTriangles[i];

-		if (tr.ea == NOT_VALID_VERTEX) continue;

+		if (tr.ea == kNotValidVertexIndex)

+			continue;

 		mVertexToTriangleMap[tr.ea].push_back(i);

 		mVertexToTriangleMap[tr.eb].push_back(i);

 		mVertexToTriangleMap[tr.ec].push_back(i);

@@ -523,19 +524,22 @@ void MeshNoiser::updateVertEdgeInfo()
 		}

 	}

 }

-

+inline bool isContainEdge(const TriangleIndexed& t, uint32_t a, uint32_t b)

+{

+	return (a == t.ea || a == t.eb || a == t.ec) && (b == t.ea || b == t.eb || b == t.ec);

+}

 

 void MeshNoiser::collapseEdge(int32_t id)

 {

-	Edge cEdge = mEdges[id];

+	Edge cEdge    = mEdges[id];

 	uint32_t from = cEdge.s;

-	uint32_t to = cEdge.e;

+	uint32_t to   = cEdge.e;

 

 	if (mRestrictionFlag[from] && mRestrictionFlag[to])

 	{

 		return;

 	}

-	

+

 	if (mVertexValence[from] > mVertexValence[to])

 	{

 		std::swap(from, to);

@@ -550,13 +554,14 @@ void MeshNoiser::collapseEdge(int32_t id)
 	std::set<int32_t> connectedToEnd;

 	std::set<int32_t> neighboorTriangles;

 

-	int32_t trWithEdge[2] = {-1, -1};

-	int32_t cntr = 0;

+	int32_t trWithEdge[2] = { -1, -1 };

+	int32_t cntr          = 0;

 	for (uint32_t i = 0; i < mVertexToTriangleMap[from].size(); ++i)

 	{

-		if (mTriangles[mVertexToTriangleMap[from][i]].ea == NOT_VALID_VERTEX)

+		if (mTriangles[mVertexToTriangleMap[from][i]].ea == kNotValidVertexIndex)

 			continue;

-		if (neighboorTriangles.insert(mVertexToTriangleMap[from][i]).second && mTriangles[mVertexToTriangleMap[from][i]].isContainEdge(from, to))

+		if (neighboorTriangles.insert(mVertexToTriangleMap[from][i]).second &&

+		    isContainEdge(mTriangles[mVertexToTriangleMap[from][i]] , from, to))

 		{

 			trWithEdge[cntr] = mVertexToTriangleMap[from][i];

 			cntr++;

@@ -564,9 +569,10 @@ void MeshNoiser::collapseEdge(int32_t id)
 	}

 	for (uint32_t i = 0; i < mVertexToTriangleMap[to].size(); ++i)

 	{

-		if (mTriangles[mVertexToTriangleMap[to][i]].ea == NOT_VALID_VERTEX)

+		if (mTriangles[mVertexToTriangleMap[to][i]].ea == kNotValidVertexIndex)

 			continue;

-		if (neighboorTriangles.insert(mVertexToTriangleMap[to][i]).second && mTriangles[mVertexToTriangleMap[to][i]].isContainEdge(from, to))

+		if (neighboorTriangles.insert(mVertexToTriangleMap[to][i]).second &&

+		    isContainEdge(mTriangles[mVertexToTriangleMap[to][i]], from, to))

 		{

 			trWithEdge[cntr] = mVertexToTriangleMap[to][i];

 			cntr++;

@@ -582,7 +588,7 @@ void MeshNoiser::collapseEdge(int32_t id)
 		return;

 	}

 

-	for (uint32_t i: neighboorTriangles)

+	for (uint32_t i : neighboorTriangles)

 	{

 		if (mTriangles[i].ea == from || mTriangles[i].eb == from || mTriangles[i].ec == from)

 		{

@@ -614,10 +620,10 @@ void MeshNoiser::collapseEdge(int32_t id)
 		for (int32_t tr : neighboorTriangles)

 		{

 			if ((mTriangles[tr].ea == from || mTriangles[tr].eb == from || mTriangles[tr].ec == from) &&

-				(mTriangles[tr].ea == to || mTriangles[tr].eb == to || mTriangles[tr].ec == to) &&

-				(mTriangles[tr].ea == currV || mTriangles[tr].eb == currV || mTriangles[tr].ec == currV))

+			    (mTriangles[tr].ea == to || mTriangles[tr].eb == to || mTriangles[tr].ec == to) &&

+			    (mTriangles[tr].ea == currV || mTriangles[tr].eb == currV || mTriangles[tr].ec == currV))

 			{

-				found = true; 

+				found = true;

 				break;

 			}

 		}

@@ -631,26 +637,28 @@ void MeshNoiser::collapseEdge(int32_t id)
 	{

 		for (int32_t i : neighboorTriangles)

 		{

-			if (trWithEdge[0] == i) continue;

-			if (cntr == 2 && trWithEdge[1] == i) continue;

+			if (trWithEdge[0] == i)

+				continue;

+			if (cntr == 2 && trWithEdge[1] == i)

+				continue;

 			TriangleIndexed tr = mTriangles[i];

-			PxVec3 oldNormal = (mVertices[tr.eb].p - mVertices[tr.ea].p).cross(mVertices[tr.ec].p - mVertices[tr.ea].p);

+			PxVec3 oldNormal =

+			    toPxShared(mVertices[tr.eb].p - mVertices[tr.ea].p).cross(toPxShared(mVertices[tr.ec].p - mVertices[tr.ea].p));

 

 			if (tr.ea == from)

 			{

 				tr.ea = to;

 			}

-			else

-				if (tr.eb == from)

-				{

-					tr.eb = to;

-				}

-				else

-					if (tr.ec == from)

-					{

-						tr.ec = to;

-					}

-			PxVec3 newNormal = (mVertices[tr.eb].p - mVertices[tr.ea].p).cross(mVertices[tr.ec].p - mVertices[tr.ea].p);

+			else if (tr.eb == from)

+			{

+				tr.eb = to;

+			}

+			else if (tr.ec == from)

+			{

+				tr.ec = to;

+			}

+			PxVec3 newNormal =

+			    toPxShared(mVertices[tr.eb].p - mVertices[tr.ea].p).cross(toPxShared(mVertices[tr.ec].p - mVertices[tr.ea].p));

 			if (newNormal.magnitude() < 1e-8f)

 			{

 				canBeCollapsed = false;

@@ -662,12 +670,13 @@ void MeshNoiser::collapseEdge(int32_t id)
 				break;

 			}

 		}

-		mTriangles[trWithEdge[0]].ea = NOT_VALID_VERTEX;

-		if (cntr == 2)mTriangles[trWithEdge[1]].ea = NOT_VALID_VERTEX;

+		mTriangles[trWithEdge[0]].ea = kNotValidVertexIndex;

+		if (cntr == 2)

+			mTriangles[trWithEdge[1]].ea = kNotValidVertexIndex;

 

 		for (int32_t i : neighboorTriangles)

 		{

-			if (mTriangles[i].ea == NOT_VALID_VERTEX)

+			if (mTriangles[i].ea == kNotValidVertexIndex)

 				continue;

 			if (mTriangles[i].ea == from)

 			{

@@ -675,15 +684,13 @@ void MeshNoiser::collapseEdge(int32_t id)
 				mVertexToTriangleMap[from].clear();

 				mVertexToTriangleMap[to].push_back(i);

 			}

-			else

-			if (mTriangles[i].eb == from)

+			else if (mTriangles[i].eb == from)

 			{

 				mTriangles[i].eb = to;

 				mVertexToTriangleMap[from].clear();

 				mVertexToTriangleMap[to].push_back(i);

 			}

-			else

-			if (mTriangles[i].ec == from)

+			else if (mTriangles[i].ec == from)

 			{

 				mTriangles[i].ec = to;

 				mVertexToTriangleMap[from].clear();

@@ -697,21 +704,21 @@ void MeshNoiser::collapseEdge(int32_t id)
 void MeshNoiser::divideEdge(int32_t id)

 {

 

-	if (mTrMeshEdToTr[id].c == 0 )

+	if (mTrMeshEdToTr[id].c == 0)

 	{

 		return;

 	}

 

-	Edge cEdge = mEdges[id];

+	Edge cEdge               = mEdges[id];

 	EdgeFlag snapRestriction = mEdgeFlag[id];

 	Vertex middle;

-	uint32_t nv = NOT_VALID_VERTEX;

+	uint32_t nv = kNotValidVertexIndex;

 	for (int32_t t = 0; t < mTrMeshEdToTr[id].c; ++t)

 	{

 		int32_t oldTriangleIndex = mTrMeshEdToTr[id].tr[t];

-		TriangleIndexed tr = mTriangles[mTrMeshEdToTr[id].tr[t]];

+		TriangleIndexed tr       = mTriangles[mTrMeshEdToTr[id].tr[t]];

 

-		if (tr.ea == NOT_VALID_VERTEX)

+		if (tr.ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

@@ -719,7 +726,7 @@ void MeshNoiser::divideEdge(int32_t id)
 		uint32_t pbf[3];

 		pbf[0] = tr.ea;

 		pbf[1] = tr.eb;

-		pbf[2] = tr.ec;		

+		pbf[2] = tr.ec;

 		for (int32_t p = 0; p < 3; ++p)

 		{

 			int32_t pnx = (p + 1) % 3;

@@ -727,10 +734,10 @@ void MeshNoiser::divideEdge(int32_t id)
 

 			if ((pbf[p] == cEdge.s && pbf[pnx] == cEdge.e) || (pbf[p] == cEdge.e && pbf[pnx] == cEdge.s))

 			{

-				if (nv == NOT_VALID_VERTEX)

+				if (nv == kNotValidVertexIndex)

 				{

-					middle.p = (mVertices[pbf[p]].p + mVertices[pbf[pnx]].p) * 0.5f;

-					middle.n = (mVertices[pbf[p]].n + mVertices[pbf[pnx]].n) * 0.5f;

+					middle.p     = (mVertices[pbf[p]].p + mVertices[pbf[pnx]].p) * 0.5f;

+					middle.n     = (mVertices[pbf[p]].n + mVertices[pbf[pnx]].n) * 0.5f;

 					middle.uv[0] = (mVertices[pbf[p]].uv[0] + mVertices[pbf[pnx]].uv[0]) * 0.5f;

 

 					nv = (uint32_t)mVertices.size();

@@ -738,40 +745,42 @@ void MeshNoiser::divideEdge(int32_t id)
 				}

 				if (nv < mRestrictionFlag.size())

 				{

-					mRestrictionFlag[nv] = ((snapRestriction == EXTERNAL_BORDER_EDGE) || (snapRestriction == INTERNAL_BORDER_EDGE));

+					mRestrictionFlag[nv] =

+					    ((snapRestriction == EXTERNAL_BORDER_EDGE) || (snapRestriction == INTERNAL_BORDER_EDGE));

 				}

 				else

 				{

-					mRestrictionFlag.push_back((snapRestriction == EXTERNAL_BORDER_EDGE) || (snapRestriction == INTERNAL_BORDER_EDGE));

+					mRestrictionFlag.push_back((snapRestriction == EXTERNAL_BORDER_EDGE) ||

+					                           (snapRestriction == INTERNAL_BORDER_EDGE));

 				}

-	

-				uint32_t ind1 = addEdge(Edge(pbf[p], nv));

-				uint32_t ind2 = addEdge(Edge(nv, pbf[pnx]));

-				uint32_t ind3 = addEdge(Edge(nv, pbf[opp]));

 

-		

+				uint32_t ind1 = addEdge({ pbf[p], nv });

+				uint32_t ind2 = addEdge({ nv, pbf[pnx] });

+				uint32_t ind3 = addEdge({ nv, pbf[opp] });

+

+

 				mEdgeFlag[ind1] = snapRestriction;

 				mEdgeFlag[ind2] = snapRestriction;

 				mEdgeFlag[ind3] = INTERNAL_EDGE;

-				

+

 				mTrMeshEdToTr[ind1].add(mTrMeshEdToTr[id].tr[t]);

-				int32_t userInfo = mTriangles[mTrMeshEdToTr[id].tr[t]].userData;

-				int32_t matId = mTriangles[mTrMeshEdToTr[id].tr[t]].materialId;

-				int32_t smId = mTriangles[mTrMeshEdToTr[id].tr[t]].smoothingGroup;

-				mTriangles[mTrMeshEdToTr[id].tr[t]] = TriangleIndexed(pbf[p], nv, pbf[opp]);

-				mTriangles[mTrMeshEdToTr[id].tr[t]].userData = userInfo;

-				mTriangles[mTrMeshEdToTr[id].tr[t]].materialId = matId;

+				int32_t userInfo                                   = mTriangles[mTrMeshEdToTr[id].tr[t]].userData;

+				int32_t matId                                      = mTriangles[mTrMeshEdToTr[id].tr[t]].materialId;

+				int32_t smId                                       = mTriangles[mTrMeshEdToTr[id].tr[t]].smoothingGroup;

+				mTriangles[mTrMeshEdToTr[id].tr[t]]                = {pbf[p], nv, pbf[opp]};

+				mTriangles[mTrMeshEdToTr[id].tr[t]].userData       = userInfo;

+				mTriangles[mTrMeshEdToTr[id].tr[t]].materialId     = matId;

 				mTriangles[mTrMeshEdToTr[id].tr[t]].smoothingGroup = smId;

 

 				mTrMeshEdToTr[ind2].add((int32_t)mTriangles.size());

 				mTrMeshEdToTr[ind3].add((int32_t)mTrMeshEdToTr[id].tr[t]);

 				mTrMeshEdToTr[ind3].add((int32_t)mTriangles.size());

-				mTriangles.push_back(TriangleIndexed(nv,pbf[pnx], pbf[opp]));

-				mTriangles.back().userData = userInfo;

-				mTriangles.back().materialId = matId;

+				mTriangles.push_back({nv, pbf[pnx], pbf[opp]});

+				mTriangles.back().userData       = userInfo;

+				mTriangles.back().materialId     = matId;

 				mTriangles.back().smoothingGroup = smId;

 

-				int32_t ed1 = findEdge(Edge(pbf[pnx], pbf[opp]));

+				int32_t ed1 = findEdge({ pbf[pnx], pbf[opp] });

 				mTrMeshEdToTr[ed1].replace(oldTriangleIndex, (int32_t)mTriangles.size() - 1);

 				break;

 			}

@@ -783,40 +792,40 @@ void MeshNoiser::divideEdge(int32_t id)
 float falloffFunction(float x, float mx)

 {

 	float t = (x) / (mx + 1e-6f);

-	t = std::min(1.0f, t);

+	t       = std::min(1.0f, t);

 	return t * t;

 }

 

 void MeshNoiser::recalcNoiseDirs()

 {

 	/**

-		Compute normals direction to apply noise

+	    Compute normals direction to apply noise

 	*/

 	mVerticesNormalsSmoothed.resize(mVertices.size(), PxVec3(0, 0, 0));

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

 	{

-		if (mTriangles[i].ea == NOT_VALID_VERTEX)

+		if (mTriangles[i].ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

 		TriangleIndexed& tr = mTriangles[i];

-		if (tr.userData == 0) continue;

-			

+		if (tr.userData == 0)

+			continue;

+

 		if (tr.userData < 0)

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] += mVertices[tr.ea].n.getNormalized();

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] += toPxShared(mVertices[tr.ea].n).getNormalized();

 		else

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] -= mVertices[tr.ea].n.getNormalized();

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] -= toPxShared(mVertices[tr.ea].n).getNormalized();

 

 		if (tr.userData < 0)

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] += mVertices[tr.eb].n.getNormalized();

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] += toPxShared(mVertices[tr.eb].n).getNormalized();

 		else

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] -= mVertices[tr.eb].n.getNormalized();

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] -= toPxShared(mVertices[tr.eb].n).getNormalized();

 

 		if (tr.userData < 0)

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] += mVertices[tr.ec].n.getNormalized();

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] += toPxShared(mVertices[tr.ec].n).getNormalized();

 		else

-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] -= mVertices[tr.ec].n.getNormalized();

-

+			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] -= toPxShared(mVertices[tr.ec].n).getNormalized();

 	}

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

 	{

@@ -827,7 +836,6 @@ void MeshNoiser::recalcNoiseDirs()
 }

 

 

-

 void MeshNoiser::applyNoise(SimplexNoise& noise, float falloff, int32_t /*relaxIterations*/, float /*relaxFactor*/)

 {

 	NVBLAST_ASSERT(isTesselated);

@@ -850,14 +858,14 @@ void MeshNoiser::applyNoise(SimplexNoise& noise, float falloff, int32_t /*relaxI
 		}

 	}

 	std::vector<Vertex> localVertices = mVertices;

-	

+

 	recalcNoiseDirs();

 

-	//relax(relaxIterations, relaxFactor, localVertices);

-	

+	// relax(relaxIterations, relaxFactor, localVertices);

 

-	/** 

-		Apply noise

+

+	/**

+	    Apply noise

 	*/

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

 	{

@@ -865,8 +873,9 @@ void MeshNoiser::applyNoise(SimplexNoise& noise, float falloff, int32_t /*relaxI
 		if (!mRestrictionFlag[i])

 		{

 

-			float d = noise.sample(localVertices[i].p);

-			localVertices[i].p += (falloffFunction(mVerticesDistances[i], falloff)) * mVerticesNormalsSmoothed[i] * d;

+			float d = noise.sample(toPxShared(localVertices[i].p));

+			toPxShared(localVertices[i].p) +=

+			    (falloffFunction(mVerticesDistances[i], falloff)) * mVerticesNormalsSmoothed[i] * d;

 		}

 	}

 

@@ -875,15 +884,16 @@ void MeshNoiser::applyNoise(SimplexNoise& noise, float falloff, int32_t /*relaxI
 	mVerticesNormalsSmoothed.assign(mVerticesNormalsSmoothed.size(), PxVec3(0, 0, 0));

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

 	{

-		if (mTriangles[i].ea == NOT_VALID_VERTEX)

+		if (mTriangles[i].ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

 		TriangleIndexed& tr = mTriangles[i];

-		if (tr.userData == 0) continue;

+		if (tr.userData == 0)

+			continue;

 

 		Triangle pTr(localVertices[tr.ea], localVertices[tr.eb], localVertices[tr.ec]);

-		PxVec3 nrm = pTr.getNormal().getNormalized();

+		PxVec3 nrm   = toPxShared(pTr.b.p - pTr.a.p).cross(toPxShared(pTr.c.p - pTr.a.p)).getNormalized();

 

 		mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] += nrm;

 		mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] += nrm;

@@ -896,30 +906,29 @@ void MeshNoiser::applyNoise(SimplexNoise& noise, float falloff, int32_t /*relaxI
 	}

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

 	{

-		if (mTriangles[i].ea == NOT_VALID_VERTEX)

+		if (mTriangles[i].ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

 		TriangleIndexed& tr = mTriangles[i];

-		if (tr.userData == 0) continue;

+		if (tr.userData == 0)

+			continue;

 

-		localVertices[tr.ea].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]];

-		localVertices[tr.eb].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]];

-		localVertices[tr.ec].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]];

+		localVertices[tr.ea].n = fromPxShared(mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]]);

+		localVertices[tr.eb].n = fromPxShared(mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]]);

+		localVertices[tr.ec].n = fromPxShared(mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]]);

 	}

 

 	mResultTriangles.clear();

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

 	{

-		if (mTriangles[i].ea == NOT_VALID_VERTEX)

+		if (mTriangles[i].ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

-		mResultTriangles.push_back(Triangle(localVertices[mTriangles[i].ea], localVertices[mTriangles[i].eb], localVertices[mTriangles[i].ec]));

-		mResultTriangles.back().userData = mTriangles[i].userData;

-		mResultTriangles.back().materialId = mTriangles[i].materialId;

-		mResultTriangles.back().smoothingGroup = mTriangles[i].smoothingGroup;

-

+		mResultTriangles.push_back({ localVertices[mTriangles[i].ea], localVertices[mTriangles[i].eb],

+		                             localVertices[mTriangles[i].ec], mTriangles[i].userData, mTriangles[i].materialId,

+		                             mTriangles[i].smoothingGroup });

 	}

 }

 

@@ -930,22 +939,18 @@ void MeshNoiser::prebuildTesselatedTriangles()
 

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

 	{

-		mVertices[i].p = mVertices[i].p * mScale + mOffset;

+		mVertices[i].p = mVertices[i].p * mScale + fromPxShared(mOffset);

 	}

 

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

 	{

-		if (mTriangles[i].ea == NOT_VALID_VERTEX)

+		if (mTriangles[i].ea == kNotValidVertexIndex)

 		{

 			continue;

 		}

-		mResultTriangles.push_back(Triangle(mVertices[mTriangles[i].ea], mVertices[mTriangles[i].eb], mVertices[mTriangles[i].ec]));

-		mResultTriangles.back().userData = mTriangles[i].userData;

-		mResultTriangles.back().materialId = mTriangles[i].materialId;

-		mResultTriangles.back().smoothingGroup = mTriangles[i].smoothingGroup;

-

+		mResultTriangles.push_back({ mVertices[mTriangles[i].ea], mVertices[mTriangles[i].eb], mVertices[mTriangles[i].ec],

+		                             mTriangles[i].userData, mTriangles[i].materialId, mTriangles[i].smoothingGroup });

 	}

-

 }

 

 

@@ -962,7 +967,7 @@ void MeshNoiser::reset()
 	mEdges.clear();

 	mVertMap.clear();

 	mEdgeMap.clear();

-    mResultTriangles.clear();

+	mResultTriangles.clear();

 	mRestrictionFlag.clear();

 	mEdgeFlag.clear();

 	mTrMeshEdToTr.clear();

@@ -975,6 +980,6 @@ void MeshNoiser::reset()
 	mGeometryGraph.clear();

 

 	isTesselated = false;

-	mOffset = PxVec3(0, 0, 0);

-	mScale = 1.0f;

+	mOffset      = PxVec3(0, 0, 0);

+	mScale       = 1.0f;

 }
\ No newline at end of file