439 lines
12 KiB
C++
439 lines
12 KiB
C++
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Copyright (c) 2008-2025 NVIDIA Corporation. All rights reserved.
|
|
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
|
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
|
|
|
#include "extensions/PxRemeshingExt.h"
|
|
#include "foundation/PxHashMap.h"
|
|
|
|
using namespace physx;
|
|
|
|
static void assignTriangle(PxArray<PxU32>& triangles, PxU32 triIndex, PxU32 a, PxU32 b, PxU32 c)
|
|
{
|
|
triangles[3 * triIndex] = a;
|
|
triangles[3 * triIndex + 1] = b;
|
|
triangles[3 * triIndex + 2] = c;
|
|
}
|
|
|
|
static void addTriangle(PxArray<PxU32>& triangles, PxU32 a, PxU32 b, PxU32 c)
|
|
{
|
|
triangles.pushBack(a);
|
|
triangles.pushBack(b);
|
|
triangles.pushBack(c);
|
|
}
|
|
|
|
static void subdivideTriangle(int i, int ab, int bc, int ac, PxArray<PxU32>& triangles, PxArray<PxVec3>& points)
|
|
{
|
|
PxU32 tri[3] = { triangles[3 * i],triangles[3 * i + 1],triangles[3 * i + 2] };
|
|
if (ab >= 0 && bc >= 0 && ac >= 0)
|
|
{
|
|
addTriangle(triangles, tri[0], ab, ac);
|
|
addTriangle(triangles, tri[1], bc, ab);
|
|
addTriangle(triangles, tri[2], ac, bc);
|
|
assignTriangle(triangles, i, ab, bc, ac);
|
|
}
|
|
else if (ac >= 0 && ab >= 0)
|
|
{
|
|
float dB = (points[ac] - points[tri[1]]).magnitudeSquared();
|
|
float dC = (points[ab] - points[tri[2]]).magnitudeSquared();
|
|
if (dB < dC)
|
|
{
|
|
addTriangle(triangles, tri[1], tri[2], ac);
|
|
addTriangle(triangles, tri[1], ac, ab);
|
|
}
|
|
else
|
|
{
|
|
addTriangle(triangles, tri[1], tri[2], ab);
|
|
addTriangle(triangles, tri[2], ac, ab);
|
|
}
|
|
assignTriangle(triangles, i, tri[0], ab, ac);
|
|
}
|
|
else if (ab >= 0 && bc >= 0)
|
|
{
|
|
float dA = (points[bc] - points[tri[0]]).magnitudeSquared();
|
|
float dC = (points[ab] - points[tri[2]]).magnitudeSquared();
|
|
if (dC < dA)
|
|
{
|
|
addTriangle(triangles, tri[2], tri[0], ab);
|
|
addTriangle(triangles, tri[2], ab, bc);
|
|
}
|
|
else
|
|
{
|
|
addTriangle(triangles, tri[2], tri[0], bc);
|
|
addTriangle(triangles, tri[0], ab, bc);
|
|
}
|
|
assignTriangle(triangles, i, tri[1], bc, ab);
|
|
}
|
|
else if (bc >= 0 && ac >= 0)
|
|
{
|
|
float dA = (points[bc] - points[tri[0]]).magnitudeSquared();
|
|
float dB = (points[ac] - points[tri[1]]).magnitudeSquared();
|
|
if (dA < dB)
|
|
{
|
|
addTriangle(triangles, tri[0], tri[1], bc);
|
|
addTriangle(triangles, tri[0], bc, ac);
|
|
}
|
|
else
|
|
{
|
|
addTriangle(triangles, tri[0], tri[1], ac);
|
|
addTriangle(triangles, tri[1], bc, ac);
|
|
}
|
|
assignTriangle(triangles, i, tri[2], ac, bc);
|
|
}
|
|
else if (ab >= 0)
|
|
{
|
|
addTriangle(triangles, tri[1], tri[2], ab);
|
|
assignTriangle(triangles, i, tri[2], tri[0], ab);
|
|
}
|
|
else if (bc >= 0)
|
|
{
|
|
addTriangle(triangles, tri[2], tri[0], bc);
|
|
assignTriangle(triangles, i, tri[0], tri[1], bc);
|
|
}
|
|
else if (ac >= 0)
|
|
{
|
|
addTriangle(triangles, tri[1], tri[2], ac);
|
|
assignTriangle(triangles, i, tri[0], tri[1], ac);
|
|
}
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxU64 key(PxU32 a, PxU32 b)
|
|
{
|
|
if (a < b)
|
|
return ((PxU64(a)) << 32) | (PxU64(b));
|
|
else
|
|
return ((PxU64(b)) << 32) | (PxU64(a));
|
|
}
|
|
|
|
static void checkEdge(PxU32 a, PxU32 b, PxHashMap<PxU64, PxI32>& edges, PxArray<PxVec3>& points, PxReal maxEdgeLength)
|
|
{
|
|
if ((points[a] - points[b]).magnitudeSquared() < maxEdgeLength * maxEdgeLength)
|
|
return;
|
|
|
|
PxU64 k = key(a, b);
|
|
if (edges.find(k))
|
|
return;
|
|
|
|
edges.insert(k, points.size());
|
|
points.pushBack(0.5f * (points[a] + points[b]));
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxI32 getEdge(PxU32 a, PxU32 b, PxHashMap<PxU64, PxI32>& edges)
|
|
{
|
|
if (const PxPair<const PxU64, PxI32>* ptr = edges.find(key(a, b)))
|
|
return ptr->second;
|
|
return -1;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct Info
|
|
{
|
|
PxI32 StartIndex;
|
|
PxI32 Count;
|
|
|
|
Info(PxI32 startIndex, PxI32 count)
|
|
{
|
|
StartIndex = startIndex;
|
|
Count = count;
|
|
}
|
|
};
|
|
}
|
|
|
|
static void checkEdge(PxU32 a, PxU32 b, PxHashMap<PxU64, Info>& edges, PxArray<PxVec3>& points, PxReal maxEdgeLength)
|
|
{
|
|
if (a > b)
|
|
PxSwap(a, b);
|
|
|
|
PxReal l = (points[a] - points[b]).magnitudeSquared();
|
|
if (l < maxEdgeLength * maxEdgeLength)
|
|
return;
|
|
|
|
l = PxSqrt(l);
|
|
|
|
PxU32 numSubdivisions = (PxU32)(l / maxEdgeLength);
|
|
if (numSubdivisions <= 1)
|
|
return;
|
|
|
|
PxU64 k = key(a, b);
|
|
if (edges.find(k))
|
|
return;
|
|
|
|
edges.insert(k, Info(points.size(), numSubdivisions - 1));
|
|
for (PxU32 i = 1; i < numSubdivisions; ++i)
|
|
{
|
|
PxReal p = (PxReal)i / numSubdivisions;
|
|
points.pushBack((1 - p) * points[a] + p * points[b]);
|
|
}
|
|
}
|
|
|
|
static PX_FORCE_INLINE Info getEdge(PxU32 a, PxU32 b, PxHashMap<PxU64, Info>& edges)
|
|
{
|
|
const PxPair<const PxU64, Info>* value = edges.find(key(a, b));
|
|
if (value)
|
|
return value->second;
|
|
return Info(-1, -1);
|
|
}
|
|
|
|
static PX_FORCE_INLINE void addPoints(PxArray<PxU32>& polygon, const Info& ab, bool reverse)
|
|
{
|
|
if (reverse)
|
|
{
|
|
for (PxI32 i = ab.Count - 1; i >= 0; --i)
|
|
polygon.pushBack(ab.StartIndex + i);
|
|
}
|
|
else
|
|
{
|
|
for (PxI32 i = 0; i < ab.Count; ++i)
|
|
polygon.pushBack(ab.StartIndex + i);
|
|
}
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxReal angle(const PxVec3& l, const PxVec3& r)
|
|
{
|
|
PxReal d = l.dot(r) / PxSqrt(l.magnitudeSquared() * r.magnitudeSquared());
|
|
if (d <= -1) return PxPi;
|
|
if (d >= 1) return 0.0f;
|
|
return PxAcos(d);
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxReal evaluateCost(const PxArray<PxVec3>& vertices, PxU32 a, PxU32 b, PxU32 c)
|
|
{
|
|
const PxVec3& aa = vertices[a];
|
|
const PxVec3& bb = vertices[b];
|
|
const PxVec3& cc = vertices[c];
|
|
|
|
PxReal a1 = angle(bb - aa, cc - aa);
|
|
PxReal a2 = angle(aa - bb, cc - bb);
|
|
PxReal a3 = angle(aa - cc, bb - cc);
|
|
|
|
return PxMax(a1, PxMax(a2, a3));
|
|
|
|
//return (aa - bb).magnitude() + (aa - cc).magnitude() + (bb - cc).magnitude();
|
|
}
|
|
|
|
static void triangulateConvex(PxU32 originalTriangleIndexTimes3, PxArray<PxU32>& polygon, const PxArray<PxVec3>& vertices, PxArray<PxU32>& triangles, PxArray<PxI32>& offsets)
|
|
{
|
|
offsets.forceSize_Unsafe(0);
|
|
offsets.reserve(polygon.size());
|
|
for (PxU32 i = 0; i < polygon.size(); ++i)
|
|
offsets.pushBack(1);
|
|
|
|
PxI32 start = 0;
|
|
PxU32 count = polygon.size();
|
|
PxU32 triCounter = 0;
|
|
while (count > 2)
|
|
{
|
|
PxReal minCost = FLT_MAX;
|
|
PxI32 best = -1;
|
|
PxI32 i = start;
|
|
for (PxU32 j = 0; j < count; ++j)
|
|
{
|
|
PxU32 a = polygon[i];
|
|
|
|
PX_ASSERT(offsets[i] >= 0);
|
|
|
|
PxI32 n = (i + offsets[i]) % polygon.size();
|
|
|
|
PX_ASSERT(offsets[n] >= 0);
|
|
|
|
PxU32 b = polygon[n];
|
|
PxU32 nn = (n + offsets[n]) % polygon.size();
|
|
|
|
PX_ASSERT(offsets[nn] >= 0);
|
|
|
|
PxU32 c = polygon[nn];
|
|
|
|
PxReal cost = evaluateCost(vertices, a, b, c);
|
|
if (cost < minCost)
|
|
{
|
|
minCost = cost;
|
|
best = i;
|
|
}
|
|
i = n;
|
|
}
|
|
{
|
|
PxU32 a = polygon[best];
|
|
PxI32 n = (best + offsets[best]) % polygon.size();
|
|
PxU32 b = polygon[n];
|
|
PxU32 nn = (n + offsets[n]) % polygon.size();
|
|
PxU32 c = polygon[nn];
|
|
|
|
if (n == start)
|
|
start += offsets[n];
|
|
|
|
offsets[best] += offsets[n];
|
|
offsets[n] = -1;
|
|
|
|
PX_ASSERT(offsets[(best + offsets[best]) % polygon.size()] >= 0);
|
|
|
|
if (triCounter == 0)
|
|
{
|
|
triangles[originalTriangleIndexTimes3 + 0] = a;
|
|
triangles[originalTriangleIndexTimes3 + 1] = b;
|
|
triangles[originalTriangleIndexTimes3 + 2] = c;
|
|
}
|
|
else
|
|
{
|
|
triangles.pushBack(a);
|
|
triangles.pushBack(b);
|
|
triangles.pushBack(c);
|
|
}
|
|
++triCounter;
|
|
}
|
|
|
|
--count;
|
|
}
|
|
}
|
|
|
|
static bool limitMaxEdgeLengthAdaptive(PxArray<PxU32>& triangles, PxArray<PxVec3>& points, PxReal maxEdgeLength, PxArray<PxU32>* triangleMap = NULL)
|
|
{
|
|
PxHashMap<PxU64, Info> edges;
|
|
bool split = false;
|
|
|
|
//Analyze edges
|
|
for (PxU32 i = 0; i < triangles.size(); i += 3)
|
|
{
|
|
const PxU32* t = &triangles[i];
|
|
checkEdge(t[0], t[1], edges, points, maxEdgeLength);
|
|
checkEdge(t[1], t[2], edges, points, maxEdgeLength);
|
|
checkEdge(t[0], t[2], edges, points, maxEdgeLength);
|
|
}
|
|
|
|
PxArray<PxI32> offsets;
|
|
PxArray<PxU32> polygon;
|
|
|
|
//Subdivide triangles if required
|
|
PxU32 size = triangles.size();
|
|
for (PxU32 i = 0; i < size; i += 3)
|
|
{
|
|
const PxU32* t = &triangles[i];
|
|
Info ab = getEdge(t[0], t[1], edges);
|
|
Info bc = getEdge(t[1], t[2], edges);
|
|
Info ac = getEdge(t[0], t[2], edges);
|
|
if (ab.StartIndex >= 0 || bc.StartIndex >= 0 || ac.StartIndex >= 0)
|
|
{
|
|
polygon.forceSize_Unsafe(0);
|
|
polygon.pushBack(t[0]);
|
|
addPoints(polygon, ab, t[0] > t[1]);
|
|
polygon.pushBack(t[1]);
|
|
addPoints(polygon, bc, t[1] > t[2]);
|
|
polygon.pushBack(t[2]);
|
|
addPoints(polygon, ac, t[2] > t[0]);
|
|
|
|
PxU32 s = triangles.size();
|
|
triangulateConvex(i, polygon, points, triangles, offsets);
|
|
split = true;
|
|
|
|
if (triangleMap != NULL)
|
|
{
|
|
for (PxU32 j = s; j < triangles.size(); ++j)
|
|
triangleMap->pushBack((*triangleMap)[i]);
|
|
}
|
|
}
|
|
/*else
|
|
{
|
|
result.pushBack(t[0]);
|
|
result.pushBack(t[1]);
|
|
result.pushBack(t[2]);
|
|
if (triangleMap != NULL)
|
|
triangleMap->pushBack((*triangleMap)[i]);
|
|
}*/
|
|
}
|
|
return split;
|
|
}
|
|
|
|
bool PxRemeshingExt::reduceSliverTriangles(PxArray<PxU32>& triangles, PxArray<PxVec3>& points, PxReal maxEdgeLength, PxU32 maxIterations, PxArray<PxU32>* triangleMap, PxU32 triangleCountThreshold)
|
|
{
|
|
bool split = limitMaxEdgeLengthAdaptive(triangles, points, maxEdgeLength, triangleMap);
|
|
if (!split)
|
|
return false;
|
|
|
|
for (PxU32 i = 1; i < maxIterations; ++i)
|
|
{
|
|
split = limitMaxEdgeLengthAdaptive(triangles, points, maxEdgeLength, triangleMap);
|
|
|
|
if (!split)
|
|
break;
|
|
|
|
if (triangles.size() >= triangleCountThreshold)
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PxRemeshingExt::limitMaxEdgeLength(PxArray<PxU32>& triangles, PxArray<PxVec3>& points, PxReal maxEdgeLength, PxU32 maxIterations, PxArray<PxU32>* triangleMap, PxU32 triangleCountThreshold)
|
|
{
|
|
if (triangleMap)
|
|
{
|
|
triangleMap->clear();
|
|
triangleMap->reserve(triangles.size() / 3);
|
|
for (PxU32 i = 0; i < triangles.size() / 3; ++i)
|
|
triangleMap->pushBack(i);
|
|
}
|
|
|
|
PxU32 numIndices = triangles.size();
|
|
PxHashMap<PxU64, PxI32> edges;
|
|
bool success = true;
|
|
for (PxU32 k = 0; k < maxIterations && success; ++k)
|
|
{
|
|
success = false;
|
|
edges.clear();
|
|
|
|
//Analyze edges
|
|
for (PxU32 i = 0; i < triangles.size(); i += 3)
|
|
{
|
|
checkEdge(triangles[i], triangles[i + 1], edges, points, maxEdgeLength);
|
|
checkEdge(triangles[i + 1], triangles[i + 2], edges, points, maxEdgeLength);
|
|
checkEdge(triangles[i], triangles[i + 2], edges, points, maxEdgeLength);
|
|
}
|
|
|
|
//Subdivide triangles if required
|
|
PxU32 size = triangles.size();
|
|
for (PxU32 i = 0; i < size; i += 3)
|
|
{
|
|
PxI32 ab = getEdge(triangles[i], triangles[i + 1], edges);
|
|
PxI32 bc = getEdge(triangles[i + 1], triangles[i + 2], edges);
|
|
PxI32 ac = getEdge(triangles[i], triangles[i + 2], edges);
|
|
if (ab >= 0 || bc >= 0 || ac >= 0)
|
|
{
|
|
PxU32 s = triangles.size();
|
|
subdivideTriangle(i / 3, ab, bc, ac, triangles, points);
|
|
success = true;
|
|
if (triangleMap)
|
|
{
|
|
for (PxU32 j = s / 3; j < triangles.size() / 3; ++j)
|
|
triangleMap->pushBack((*triangleMap)[i / 3]);
|
|
}
|
|
}
|
|
}
|
|
if (triangles.size() >= triangleCountThreshold)
|
|
break;
|
|
}
|
|
return numIndices != triangles.size();
|
|
}
|