[Scummvm-git-logs] scummvm master -> 0d57b7aae37d0284ce142236c44729c74e11e75e
grisenti
noreply at scummvm.org
Thu Sep 7 07:19:43 UTC 2023
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
0d57b7aae3 HPL1: Remove unnecessary platform specific #ifdef
Commit: 0d57b7aae37d0284ce142236c44729c74e11e75e
https://github.com/scummvm/scummvm/commit/0d57b7aae37d0284ce142236c44729c74e11e75e
Author: grisenti (emanuele at grisenti.net)
Date: 2023-09-07T09:19:27+02:00
Commit Message:
HPL1: Remove unnecessary platform specific #ifdef
Changed paths:
engines/hpl1/engine/libraries/newton/Newton.cpp
engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
engines/hpl1/engine/libraries/newton/core/dgTypes.h
engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.h
engines/hpl1/engine/libraries/newton/physics/dgCollision.h
engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp
diff --git a/engines/hpl1/engine/libraries/newton/Newton.cpp b/engines/hpl1/engine/libraries/newton/Newton.cpp
index 53a4d83ce3e..a938f0107d8 100644
--- a/engines/hpl1/engine/libraries/newton/Newton.cpp
+++ b/engines/hpl1/engine/libraries/newton/Newton.cpp
@@ -34,12 +34,6 @@ void NewtonDestroyGlobals() {
}
-#ifdef _WIN32
-#ifdef _DEBUG
-//#define DG_USED_DEBUG_EXCEPTIONS
-#endif // _DEBUG
-#endif // _WIN32
-
#ifdef _DEBUG
void TraceFuntionName(const char *name) {
diff --git a/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp b/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
index 6448230b74e..39b20cfb2c5 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
@@ -37,10 +37,6 @@
#define DG_STACK_DEPTH 63
-#ifdef _MSC_VER
-#pragma warning (disable: 4201) //nonstandard extension used : nameless struct/union
-#endif
-
class dgAABBTree {
class TreeNode {
diff --git a/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp b/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
index e7e21dedb3b..2aa70a4e801 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
@@ -122,11 +122,6 @@ dgConvexHull3d::~dgConvexHull3d(void) {
}
void dgConvexHull3d::BuildHull(const dgFloat64 *const vertexCloud, dgInt32 strideInBytes, dgInt32 count, dgFloat64 distTol, dgInt32 maxVertexCount) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
dgInt32 treeCount = count / (DG_VERTEX_CLUMP_SIZE_3D >> 1);
if (treeCount < 4) {
treeCount = 4;
@@ -140,10 +135,6 @@ void dgConvexHull3d::BuildHull(const dgFloat64 *const vertexCloud, dgInt32 strid
if (m_count >= 4) {
CalculateConvexHull(&treePool[0], &points[0], count, distTol, maxVertexCount);
}
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
}
dgInt32 dgConvexHull3d::ConvexCompareVertex(const dgHullVertex *const A, const dgHullVertex *const B, void *const context) {
diff --git a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
index 4634d5ca3c1..d4451d66889 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
@@ -267,11 +267,6 @@ dgConvexHull4d::~dgConvexHull4d(void) {
void dgConvexHull4d::BuildHull(dgMemoryAllocator *const allocator,
const dgBigVector *const vertexCloud, dgInt32 count, dgFloat64 distTol) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
// InitVertexArray(vertexCloud, count);
dgInt32 treeCount = count / (DG_VERTEX_CLUMP_SIZE_4D >> 1);
@@ -288,10 +283,6 @@ void dgConvexHull4d::BuildHull(dgMemoryAllocator *const allocator,
if (m_count >= 4) {
CalculateConvexHull(&treePool[0], &points[0], count, distTol);
}
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
}
void dgConvexHull4d::TessellateTriangle(dgInt32 level, const dgVector &p0,
@@ -1101,11 +1092,6 @@ dgConvexHull4d::dgListNode *dgConvexHull4d::FindFacingNode(
}
dgInt32 dgConvexHull4d::AddVertex(const dgBigVector &vertex) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
dgInt32 index = -1;
dgListNode *const faceNode = FindFacingNode(vertex);
if (faceNode) {
@@ -1125,9 +1111,5 @@ dgInt32 dgConvexHull4d::AddVertex(const dgBigVector &vertex) {
}
}
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
-
return index;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp b/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
index 65b95bae39a..992e259b98f 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
@@ -29,10 +29,6 @@ dgDelaunayTetrahedralization::dgDelaunayTetrahedralization(
dgMemoryAllocator *const allocator, const dgFloat64 *const vertexCloud,
dgInt32 count, dgInt32 strideInByte, dgFloat64 distTol) :
dgConvexHull4d(allocator) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
dgStack<dgBigVector> pool(count);
@@ -98,28 +94,15 @@ dgDelaunayTetrahedralization::dgDelaunayTetrahedralization(
#ifdef _DEBUG
SortVertexArray();
#endif
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
}
dgDelaunayTetrahedralization::~dgDelaunayTetrahedralization() {
}
dgInt32 dgDelaunayTetrahedralization::AddVertex(const dgBigVector &vertex) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
dgBigVector p(vertex);
p.m_w = p % p;
dgInt32 index = dgConvexHull4d::AddVertex(p);
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
return index;
}
@@ -156,11 +139,6 @@ void dgDelaunayTetrahedralization::SortVertexArray() {
#endif
void dgDelaunayTetrahedralization::RemoveUpperHull() {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
dgListNode *nextNode = NULL;
// const dgHullVector* const points = &m_points[0];
for (dgListNode *node = GetFirst(); node; node = nextNode) {
@@ -179,10 +157,6 @@ void dgDelaunayTetrahedralization::RemoveUpperHull() {
DeleteFace(node);
}
}
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
}
void dgDelaunayTetrahedralization::DeleteFace(dgListNode *const node) {
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp b/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
index 2de7748e07a..e5fc759c633 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
@@ -346,11 +346,6 @@ static dgInt32 QuickSortVertices(dgFloat64 *const vertList, dgInt32 stride,
dgInt32 dgVertexListToIndexList(dgFloat64 *const vertList,
dgInt32 strideInBytes, dgInt32 compareCount, dgInt32 vertexCount,
dgInt32 *const indexListOut, dgFloat64 tolerance) {
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
if (strideInBytes < 3 * dgInt32(sizeof(dgFloat64))) {
return 0;
}
@@ -399,10 +394,6 @@ dgInt32 dgVertexListToIndexList(dgFloat64 *const vertList,
m += stride2;
}
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
-
return count;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTypes.h b/engines/hpl1/engine/libraries/newton/core/dgTypes.h
index 56370d6b85d..903fa133be7 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTypes.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgTypes.h
@@ -115,13 +115,7 @@
// NB: End of disabled header section
//************************************************************
-#ifndef _WIN32
-#ifdef _DEBUG
#define _ASSERTE(x) assert(x)
-#else
-#define _ASSERTE(x)
-#endif
-#endif
#define __USE_CPU_FOUND__
@@ -625,13 +619,6 @@ enum dgCpuClass {
#define PointerToInt(x) ((size_t)x)
#define IntToPointer(x) ((void *)(size_t(x)))
-#ifndef _WIN64
-#define dgControlFP(x, y) _controlfp(x, y)
-#else
-#define dgControlFP(x, y) x
-#define stricmp(x, y) strcasecmp(x, y)
-#endif
-
DG_INLINE dgFloat32 dgAbsf(dgFloat32 x) {
#if 0
dgDoubleInt val;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.h b/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.h
index 4841902c726..c32b5dac524 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.h
@@ -23,9 +23,6 @@
#define AFX_DGBALLCONSTRAINT_H__7C9E1F9A_5EC6_48BE_8C9F_FB90132C6619__INCLUDED_
#include "dgBilateralConstraint.h"
-#ifdef _MSC_VER
-#pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
-#endif
// template<class T> class dgPool;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollision.h b/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
index 29c0a8782c8..e0696524e56 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
@@ -22,14 +22,6 @@
#ifndef AFX_DGCOLLISION_H__57E159CE_6B6F_42DE_891C_1F6C38EB9D29__INCLUDED_
#define AFX_DGCOLLISION_H__57E159CE_6B6F_42DE_891C_1F6C38EB9D29__INCLUDED_
-#ifdef _WIN32
-// #define DG_INLINE_FUNTION inline
-#define DG_INLINE_FUNTION DG_INLINE
-// #define DG_INLINE_FUNTION __forceinline
-#else
-#define DG_INLINE_FUNTION inline
-#endif
-
#include "dgBody.h"
#include "hpl1/engine/libraries/newton/core/dg.h"
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
index 8d2cc817d40..4c311ea3741 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
@@ -79,1754 +79,6 @@ dgMeshEffect::dgMeshEffect(dgMemoryAllocator *const allocator,
}
}
-#if 0
-
-class Tetrahedralization: public dgDelaunayTetrahedralization {
- class dgIndexMapPair {
- public:
- dgInt32 m_meshIndex;
- dgInt32 m_convexIndex;
- };
-
- class dgMissingEdges: public dgList<dgPolyhedra::dgTreeNode *> {
- public:
- dgMissingEdges(dgMemoryAllocator *const allocator)
- : dgList<dgPolyhedra::dgTreeNode*> (allocator) {
- }
- ~dgMissingEdges() {
- }
- };
-
- class dgEdgeSharedTetras: public dgList<dgListNode *> {
- public:
- dgEdgeSharedTetras(const dgEdgeSharedTetras ©)
- : dgList(copy.GetAllocator()) {
- }
-
- dgEdgeSharedTetras(dgMemoryAllocator *const allocator)
- : dgList(allocator) {
- }
-
- ~dgEdgeSharedTetras() {
- }
- };
-
- class dgEdgeMap: public dgTree<dgEdgeSharedTetras, dgUnsigned64> {
- public:
- dgEdgeMap(dgMemoryAllocator *const allocator)
- : dgTree<dgEdgeSharedTetras, dgUnsigned64>(allocator) {
- }
-
- ~dgEdgeMap() {
- while (GetRoot()) {
- dgEdgeSharedTetras &header = GetRoot()->GetInfo();
- header.RemoveAll();
- Remove(GetRoot());
- }
- }
- };
-
- class dgVertexMap: public dgTree<dgEdgeSharedTetras, dgInt32> {
- public:
- dgVertexMap(dgMemoryAllocator *const allocator)
- : dgTree<dgEdgeSharedTetras, dgInt32>(allocator) {
- }
-
- ~dgVertexMap() {
- while (GetRoot()) {
- dgEdgeSharedTetras &header = GetRoot()->GetInfo();
- header.RemoveAll();
- Remove(GetRoot());
- }
- }
- };
-
- /*
- #ifdef _DEBUG
- class dgEdgeFaceKey
- {
- public:
- dgEdgeFaceKey ()
- {}
-
- dgEdgeFaceKey (dgInt32 i0, dgInt32 i1, dgInt32 i2)
- {
- m_index[0] = i0;
- m_index[1] = i1;
- m_index[2] = i2;
- while ((m_index[0] > m_index[1]) || (m_index[0] > m_index[2])) {
- i0 = m_index[0];
- m_index[0] = m_index[1];
- m_index[1] = m_index[2];
- m_index[2] = i0;
- }
- }
-
- dgInt32 Compared (const dgEdgeFaceKey& key) const
- {
- for (dgInt32 i = 0; i < 3; i ++) {
- if (m_index[i] < key.m_index[i]) {
- return -1;
- } else if (m_index[i] > key.m_index[i]) {
- return 1;
- }
- }
- return 0;
- }
-
-
- bool operator < (const dgEdgeFaceKey& key) const
- {
- return (Compared (key) < 0);
- }
-
- bool operator > (const dgEdgeFaceKey& key) const
- {
- return (Compared (key) > 0);
- }
-
-
- dgInt32 m_index[3];
-
- };
-
-
- class dgFaceKeyMap: public dgTree<dgListNode*, dgEdgeFaceKey>
- {
- public:
- dgFaceKeyMap(dgMemoryAllocator* const allocator)
- :dgTree<dgListNode*, dgEdgeFaceKey>(allocator)
- {
-
- }
- };
- #endif
-
- */
-public:
- Tetrahedralization(dgMeshEffect &mesh)
- : dgDelaunayTetrahedralization(mesh.GetAllocator(), mesh.GetVertexPool(), mesh.GetVertexCount(), sizeof(dgVector), 0.0f),
- m_mesh(&mesh),
- m_edgeMap(mesh.GetAllocator()),
- m_vertexMap(mesh.GetAllocator()),
- m_missinEdges(mesh.GetAllocator()),
- m_indexMap(mesh.GetVertexCount() * 8 + 2048, mesh.GetAllocator()) {
- if (GetCount()) {
-
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
- // add every edge of each tetrahedral to a edge list
- BuildTetrahedraEdgeListAndVertexList();
-
- // make a index map to quickly find vertex mapping form the mesh to the delaunay tetrahedron
- CreateIndexMap();
-
- // Insert all missing edge in mesh as a new into the tetrahedral list
- RecoverEdges();
-
- // Recover the solid mesh from the delaunay tetrahedron
- RecoverFaces();
-
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
- }
- }
-
- ~Tetrahedralization() {
- }
-
- dgUnsigned64 GetKey(dgInt32 i0, dgInt32 i1) const {
- return (i1 > i0) ? (dgUnsigned64(i1) << 32) + i0 : (dgUnsigned64(i0) << 32) + i1;
- }
-
- void InsertNewEdgeNode(dgInt32 i0, dgInt32 i1, dgListNode *const node) {
- dgUnsigned64 key = GetKey(i1, i0);
-
- dgEdgeMap::dgTreeNode *edgeNode = m_edgeMap.Find(key);
- if (!edgeNode) {
- dgEdgeSharedTetras tmp(GetAllocator());
- edgeNode = m_edgeMap.Insert(tmp, key);
- }
- dgEdgeSharedTetras &header = edgeNode->GetInfo();
-
-#ifdef _DEBUG
- for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- NEWTON_ASSERT(ptr->GetInfo() != node);
- }
-#endif
-
- header.Append(node);
- }
-
- void RemoveEdgeNode(dgInt32 i0, dgInt32 i1, dgListNode *const node) {
- dgUnsigned64 key = GetKey(i0, i1);
-
- dgEdgeMap::dgTreeNode *const edgeNode = m_edgeMap.Find(key);
- if (edgeNode) {
- dgEdgeSharedTetras &header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- dgListNode *const me = ptr->GetInfo();
- if (me == node) {
- header.Remove(ptr);
- if (!header.GetCount()) {
- m_edgeMap.Remove(edgeNode);
- }
-
-// dgInt32 index0 = GetVertexIndex(i0);
-// dgInt32 index1 = GetVertexIndex(i1);
-// dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
-// if(edgeNode) {
-// m_missinEdges.Append(edgeNode);
-// }
-
- break;
- }
- }
- }
- }
-
- void InsertNewVertexNode(dgInt32 index, dgListNode *const node) {
- dgVertexMap::dgTreeNode *vertexNode = m_vertexMap.Find(index);
- if (!vertexNode) {
- dgEdgeSharedTetras tmp(GetAllocator());
- vertexNode = m_vertexMap.Insert(tmp, index);
- }
- dgEdgeSharedTetras &header = vertexNode->GetInfo();
-
-#ifdef _DEBUG
- for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- NEWTON_ASSERT(ptr->GetInfo() != node);
- }
-#endif
-
- header.Append(node);
- }
-
- void RemoveNewVertexNode(dgInt32 index, dgListNode *const node) {
- dgVertexMap::dgTreeNode *vertexNode = m_vertexMap.Find(index);
- NEWTON_ASSERT(vertexNode);
- dgEdgeSharedTetras &header = vertexNode->GetInfo();
-
- for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- if (ptr->GetInfo() == node) {
- header.Remove(node);
- break;
- }
- }
- NEWTON_ASSERT(header.GetCount());
-
- }
-
- void AddEdgesAndFaces(dgListNode *const node) {
- dgConvexHull4dTetraherum *const tetra = &node->GetInfo();
- if (GetTetraVolume(tetra) < 0.0f) {
- const dgConvexHull4dTetraherum::dgTetrahedrumFace &face = tetra->m_faces[0];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i0 = face.m_otherVertex;
- dgInt32 i1 = face.m_index[i];
- InsertNewEdgeNode(i0, i1, node);
- }
-
- dgInt32 i0 = face.m_index[2];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i1 = face.m_index[i];
- InsertNewEdgeNode(i0, i1, node);
- InsertNewVertexNode(i0, node);
- i0 = i1;
- }
- InsertNewVertexNode(face.m_otherVertex, node);
- }
- }
-
- void RemoveEdgesAndFaces(dgListNode *const node) {
- dgConvexHull4dTetraherum *const tetra = &node->GetInfo();
- const dgConvexHull4dTetraherum::dgTetrahedrumFace &face = tetra->m_faces[0];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i0 = face.m_otherVertex;
- dgInt32 i1 = face.m_index[i];
- RemoveEdgeNode(i0, i1, node);
- }
-
- dgInt32 i0 = face.m_index[2];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i1 = face.m_index[i];
- RemoveEdgeNode(i0, i1, node);
- RemoveNewVertexNode(i0, node);
- i0 = i1;
- }
-
- RemoveNewVertexNode(face.m_otherVertex, node);
- }
-
- dgListNode *AddFace(dgInt32 i0, dgInt32 i1, dgInt32 i2, dgInt32 i3) {
- dgListNode *const faceNode = dgDelaunayTetrahedralization::AddFace(i0, i1, i2, i3);
- AddEdgesAndFaces(faceNode);
- return faceNode;
- }
-
- void DeleteFace(dgListNode *const node) {
- RemoveEdgesAndFaces(node);
-
- dgConvexHull4dTetraherum *const tetra = &node->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- const dgConvexHull4dTetraherum::dgTetrahedrumFace &face = tetra->m_faces[i];
- dgListNode *const twinNode = face.m_twin;
- if (twinNode) {
- dgConvexHull4dTetraherum *const twinTetra = &twinNode->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- if (twinTetra->m_faces[i].m_twin == node) {
- twinTetra->m_faces[i].m_twin = NULL;
- }
- }
- }
- }
-
- dgDelaunayTetrahedralization::DeleteFace(node);
- }
-
- void BuildTetrahedraEdgeListAndVertexList() {
- for (dgListNode *node = GetFirst(); node; node = node->GetNext()) {
- AddEdgesAndFaces(node);
- }
- }
-
- static dgInt32 ConvexCompareIndex(const dgIndexMapPair *const A, const dgIndexMapPair *const B, void *const context) {
- if (A->m_meshIndex > B->m_meshIndex) {
- return 1;
- } else if (A->m_meshIndex < B->m_meshIndex) {
- return -1;
- }
- return 0;
- }
-
- void CreateIndexMap() {
- // make a index map to quickly find vertex mapping form the mesh to the delaunay tetrahedron
- m_indexMap[GetVertexCount()].m_meshIndex = 0;
- dgIndexMapPair *const indexMap = &m_indexMap[0];
- for (dgInt32 i = 0; i < GetVertexCount(); i ++) {
- indexMap[i].m_convexIndex = i;
- indexMap[i].m_meshIndex = GetVertexIndex(i);
- }
- dgSort(indexMap, GetVertexCount(), ConvexCompareIndex);
- }
-
- bool SanityPointInTetra(dgConvexHull4dTetraherum *const tetra, const dgBigVector &vertex) const {
-
- for (dgInt32 i = 0; i < 4; i ++) {
- const dgBigVector &p0 = m_points[tetra->m_faces[i].m_index[0]];
- const dgBigVector &p1 = m_points[tetra->m_faces[i].m_index[1]];
- const dgBigVector &p2 = m_points[tetra->m_faces[i].m_index[2]];
- dgBigPlane plane(p0, p1, p2);
- dgFloat64 dist = plane.Evalue(vertex);
- if (dist > dgFloat64(1.0e-12f)) {
- return false;
- }
- }
- return true;
- }
-
- dgInt32 ReplaceFaceNodes(dgListNode *const faceNode, dgInt32 faceIndex, const dgBigVector &vertex) {
- dgConvexHull4dTetraherum *const tetra = &faceNode->GetInfo();
- dgListNode *const neighborghNode = tetra->m_faces[faceIndex].m_twin;
- NEWTON_ASSERT(neighborghNode);
-
- dgConvexHull4dTetraherum *const neighborghTetra = &neighborghNode->GetInfo();
-
- dgInt32 vertexIndex = m_count;
- m_points[vertexIndex] = vertex;
- m_points[vertexIndex].m_index = vertexIndex;
- m_count ++;
-
- NEWTON_ASSERT(SanityPointInTetra(tetra, vertex));
- NEWTON_ASSERT(SanityPointInTetra(neighborghTetra, vertex));
-
- dgInt32 mark = IncMark();
- tetra->SetMark(mark);
- neighborghTetra->SetMark(mark);
-
- dgInt32 deletedCount = 2;
- dgListNode *deletedNodes[2];
- deletedNodes[0] = faceNode;
- deletedNodes[1] = neighborghNode;
-
- dgInt32 perimeterCount = 0;
- dgListNode *perimeter[16];
- for (dgInt32 i = 0; i < deletedCount; i ++) {
- dgListNode *const deleteTetraNode = deletedNodes[i];
-
- dgConvexHull4dTetraherum *const deletedTetra = &deleteTetraNode->GetInfo();
- NEWTON_ASSERT(deletedTetra->GetMark() == mark);
-
- for (dgInt32 i = 0; i < 4; i ++) {
- dgListNode *const twinNode = deletedTetra->m_faces[i].m_twin;
- dgConvexHull4dTetraherum *const twinTetra = &twinNode->GetInfo();
- NEWTON_ASSERT(twinTetra);
-
- if (twinTetra->GetMark() != mark) {
- dgInt32 index = 0;
- for (index = 0; index < perimeterCount; index ++) {
- if (perimeter[index] == twinNode) {
- break;
- }
- }
- if (index == perimeterCount) {
- perimeter[perimeterCount] = twinNode;
- perimeterCount ++;
- }
- }
- deletedTetra->m_faces[i].m_twin = NULL;
- }
- }
-
- dgInt32 coneListCount = 0;
- dgListNode *coneList[32];
- for (dgInt32 i = 0; i < perimeterCount; i ++) {
- dgListNode *const perimeterNode = perimeter[i];
- dgConvexHull4dTetraherum *const perimeterTetra = &perimeterNode->GetInfo();
-
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace *const perimeterFace = &perimeterTetra->m_faces[i];
- if (perimeterFace->m_twin->GetInfo().GetMark() == mark) {
-
- dgListNode *const newNode = AddFace(vertexIndex, perimeterFace->m_index[0], perimeterFace->m_index[1], perimeterFace->m_index[2]);
-
- dgConvexHull4dTetraherum *const newTetra = &newNode->GetInfo();
- newTetra->m_faces[2].m_twin = perimeterNode;
- perimeterFace->m_twin = newNode;
- coneList[coneListCount] = newNode;
- coneListCount ++;
- }
- }
- }
-
- for (int i = 0; i < (coneListCount - 1); i ++) {
- dgListNode *const coneNodeA = coneList[i];
- for (dgInt32 j = i + 1; j < coneListCount; j ++) {
- dgListNode *const coneNodeB = coneList[j];
- LinkSibling(coneNodeA, coneNodeB);
- }
- }
-
- for (dgInt32 i = 0; i < deletedCount; i ++) {
- //dgListNode* const node = deleteNode->GetInfo();
- dgListNode *const deleteTetraNode = deletedNodes[i];
- DeleteFace(deleteTetraNode);
- }
-
- return vertexIndex;
- }
-
- void RecoverEdges() {
- // split every missing edge at the center and add the two half to the triangulation
- // keep doing it until all edge are present in the triangulation.
-
- dgInt32 mark = m_mesh->IncLRU();
-
- // create a list all all the edge that are in the mesh but that do not appear in the delaunay tetrahedron
- const dgIndexMapPair *const indexMap = &m_indexMap[0];
- dgPolyhedra::Iterator iter(*m_mesh);
-
- for (iter.Begin(); iter; iter ++) {
- dgEdge *const edge = &iter.GetNode()->GetInfo();
- if (edge->m_mark != mark) {
- edge->m_mark = mark;
- edge->m_twin->m_mark = mark;
-
- dgInt32 i0 = indexMap[edge->m_incidentVertex].m_convexIndex;
- dgInt32 i1 = indexMap[edge->m_twin->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey(i0, i1);
- dgEdgeMap::dgTreeNode *const edgeNode = m_edgeMap.Find(key);
- if (!edgeNode) {
- m_missinEdges.Append(iter.GetNode());
- }
- }
- }
-
-//m_missinEdges.Remove(m_missinEdges.GetLast());
-
- while (m_missinEdges.GetCount()) {
- dgIndexMapPair *const indexMap = &m_indexMap[0];
-
- dgMissingEdges::dgListNode *missingEdgeNode = m_missinEdges.GetFirst();
- dgEdge *missingEdge = &missingEdgeNode->GetInfo()->GetInfo();
-
- dgInt32 k0 = missingEdge->m_incidentVertex;
- dgInt32 k1 = missingEdge->m_twin->m_incidentVertex;
- dgInt32 i0 = indexMap[k0].m_convexIndex;
- dgInt32 i1 = indexMap[k1].m_convexIndex;
-
- m_missinEdges.Remove(missingEdgeNode);
- dgUnsigned64 key = GetKey(i0, i1);
- if (!m_edgeMap.Find(key)) {
- dgVertexMap::dgTreeNode *const vertexNode = m_vertexMap.Find(i0);
- NEWTON_ASSERT(vertexNode);
- const dgEdgeSharedTetras &tetraMap = vertexNode->GetInfo();
-
- const dgBigVector &p0 = GetVertex(i0);
- const dgBigVector &p1 = GetVertex(i1);
- bool edgeFound = false;
- for (dgEdgeSharedTetras::dgListNode *node = tetraMap.GetFirst(); node; node = node->GetNext()) {
- dgListNode *const tetraNode = node->GetInfo();
- dgConvexHull4dTetraherum *const tetra = &tetraNode->GetInfo();
- dgInt32 faceIndex = -1;
- for (dgInt32 i = 0; i < 4; i ++) {
- if (tetra->m_faces[i].m_otherVertex == i0) {
- faceIndex = i;
- }
- }
- NEWTON_ASSERT(faceIndex != -1);
-
- const dgBigVector &A = GetVertex(tetra->m_faces[faceIndex].m_index[0]);
- const dgBigVector &B = GetVertex(tetra->m_faces[faceIndex].m_index[1]);
- const dgBigVector &C = GetVertex(tetra->m_faces[faceIndex].m_index[2]);
- dgBigVector baricentric(LineTriangleIntersection(p0, p1, A, B, C));
- if (baricentric.m_w == dgFloat64(0.0f)) {
- NEWTON_ASSERT((baricentric.m_x > dgFloat64(0.0f)) && (baricentric.m_y > dgFloat64(0.0f)) && (baricentric.m_z > dgFloat64(0.0f)));
- dgBigVector point(A.Scale4(baricentric.m_x) + B.Scale4(baricentric.m_y) + C.Scale4(baricentric.m_z));
- dgInt32 index = ReplaceFaceNodes(tetraNode, faceIndex, point);
-
- dgBigVector pp0(point - p0);
- dgBigVector p1p0(p1 - p0);
- dgFloat64 spliteParam = (pp0 % p1p0) / (p1p0 % p1p0);
- dgEdge *const newEdge = m_mesh->InsertEdgeVertex(missingEdge, dgFloat32(spliteParam));
-
- indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
-
- i0 = indexMap[newEdge->m_next->m_incidentVertex].m_convexIndex;
- i1 = indexMap[newEdge->m_next->m_twin->m_incidentVertex].m_convexIndex;
- key = GetKey(i0, i1);
- if (!m_edgeMap.Find(key)) {
- dgInt32 index0 = GetVertexIndex(i0);
- dgInt32 index1 = GetVertexIndex(i1);
- dgPolyhedra::dgTreeNode *const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- NEWTON_ASSERT(edgeNode);
- m_missinEdges.Addtop(edgeNode);
- }
-
- edgeFound = true;
- break;
- }
- }
- NEWTON_ASSERT(edgeFound);
- }
- }
- }
-
- /*
- void RemoveDegeneratedTetras ()
- {
- dgInt32 mark = m_mesh->IncLRU();
- dgPolyhedra::Iterator iter (*m_mesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const faceEdge = &iter.GetNode()->GetInfo();
- dgInt32 count = 0;
- dgEdge* ptr = faceEdge;
- do {
- count ++;
- ptr->m_mark = mark;
- ptr = ptr->m_next;
- } while (ptr != faceEdge);
-
- if (count > 3) {
- dgEdge* ptr = faceEdge;
- do {
- dgInt32 k0 = m_indexMap[ptr->m_incidentVertex].m_convexIndex;
- dgInt32 k1 = m_indexMap[ptr->m_next->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey (k0, k1);
- dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
- if (edgeNode) {
- dgEdgeSharedTetras& header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode* ptr1 = header.GetFirst(); ptr1; ptr1 = ptr1->GetNext()) {
- dgListNode* const tetraNode = ptr1->GetInfo();
- dgConvexHull4dTetraherum* const tetra = &tetraNode->GetInfo();
- const dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[0];
- dgInt32 index[4];
- index[0] = GetVertexIndex(face.m_index[0]);
- index[1] = GetVertexIndex(face.m_index[1]);
- index[2] = GetVertexIndex(face.m_index[2]);
- index[3] = GetVertexIndex(face.m_otherVertex);
-
- dgInt32 duplicates = 0;
- dgEdge* ptr3 = faceEdge;
- do {
- for (dgInt32 i = 0; i < 4; i ++) {
- duplicates += (ptr3->m_incidentVertex == index[i]) ? 1 : 0;
- }
- ptr3 = ptr3->m_next;
- } while (ptr3 != faceEdge);
- if (duplicates > 3) {
- DeleteFace(tetraNode);
- break;
- }
- }
- }
-
- ptr = ptr->m_next;
- } while (ptr != faceEdge);
- }
- }
- }
- */
-
- bool MatchFace(dgMeshEffect &mesh, dgEdge *const faceEdge, dgInt32 tetraMark) const {
- dgInt32 k0 = m_indexMap[faceEdge->m_incidentVertex].m_convexIndex;
- dgInt32 k1 = m_indexMap[faceEdge->m_next->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey(k0, k1);
- dgEdgeMap::dgTreeNode *const edgeNode = m_edgeMap.Find(key);
-
- NEWTON_ASSERT(edgeNode);
- dgEdgeSharedTetras &header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- dgListNode *const tetraNode = ptr->GetInfo();
- dgConvexHull4dTetraherum *const tetra = &tetraNode->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace &face = tetra->m_faces[i];
- dgInt32 i0 = face.m_index[0];
- dgInt32 i1 = face.m_index[1];
- dgInt32 i2 = face.m_index[2];
-
- if (((i0 == k0) && (i1 == k1)) || ((i1 == k0) && (i2 == k1)) || ((i2 == k0) && (i0 == k1))) {
- dgInt32 index[3];
-
- index[0] = GetVertexIndex(i0);
- index[1] = GetVertexIndex(i1);
- index[2] = GetVertexIndex(i2);
- while (index[0] != faceEdge->m_incidentVertex) {
- dgInt32 tmp = index[0];
- index[0] = index[1];
- index[1] = index[2];
- index[2] = tmp;
- }
- NEWTON_ASSERT(index[0] == faceEdge->m_incidentVertex);
- NEWTON_ASSERT(index[1] == faceEdge->m_next->m_incidentVertex);
-
- dgEdge *nextEdge = faceEdge->m_next->m_next;
- do {
- if (nextEdge->m_incidentVertex == index[2]) {
- break;
- }
- nextEdge = nextEdge->m_next;
- } while (nextEdge != faceEdge);
-
- if (nextEdge != faceEdge) {
- if (nextEdge->m_prev != faceEdge->m_next) {
- dgEdge *const edge = mesh.ConectVertex(faceEdge->m_next, nextEdge);
- NEWTON_ASSERT(edge);
- NEWTON_ASSERT(edge->m_next);
- NEWTON_ASSERT(edge->m_prev);
- NEWTON_ASSERT(edge->m_twin->m_next);
- NEWTON_ASSERT(edge->m_twin->m_prev);
- NEWTON_ASSERT(faceEdge->m_next == edge->m_twin);
- }
- if (nextEdge->m_next != faceEdge) {
-#ifdef _DEBUG
- dgEdge *const edge = mesh.ConectVertex(faceEdge, nextEdge);
- NEWTON_ASSERT(edge);
- NEWTON_ASSERT(edge->m_next);
- NEWTON_ASSERT(edge->m_prev);
- NEWTON_ASSERT(edge->m_twin->m_next);
- NEWTON_ASSERT(edge->m_twin->m_prev);
- NEWTON_ASSERT(faceEdge->m_prev == edge);
-#else
- mesh.ConectVertex(faceEdge, nextEdge);
-#endif
-
- }
-
- if (tetraMark != -1) {
- tetra->SetMark(tetraMark);
- face.m_twin = NULL;
- }
- return true;
- }
- }
- }
- }
- return false;
- }
-
- void RecoverFace(dgMeshEffect &mesh, dgEdge *const face, dgInt32 faceMark, dgInt32 tetraMark, dgTree<dgEdge *, dgEdge *> &edgeInconflict) const {
- dgInt32 count = 0;
- dgInt32 perimeterCount = 0;
- dgEdge *edgeArray[1024];
- dgEdge *perimterEdges[1024 + 1];
-
- dgEdge *ptr = face;
- do {
- edgeArray[count] = ptr;
- perimterEdges[count] = ptr;
- count ++;
- NEWTON_ASSERT(count < sizeof(edgeArray) / sizeof(edgeArray[0]));
- ptr = ptr->m_next;
- } while (ptr != face);
- perimeterCount = count;
- perimterEdges[count] = face;
-
- while (count) {
- count --;
- dgEdge *const triangleFace = edgeArray[count];
- bool state = MatchFace(mesh, triangleFace, tetraMark);
- if (state) {
- NEWTON_ASSERT(triangleFace == triangleFace->m_next->m_next->m_next);
- triangleFace->m_mark = faceMark;
- dgEdge *ptr = triangleFace->m_next;
- do {
- ptr->m_mark = faceMark;
- for (dgInt32 i = 0; i < count; i ++) {
- if (ptr == edgeArray[i]) {
- edgeArray[i] = edgeArray[count - 1];
- i --;
- count --;
- break;
- }
- }
- ptr = ptr->m_next;
- } while (ptr != triangleFace);
- }
- }
-
- NEWTON_ASSERT(count == 0);
- for (dgInt32 i = 1; i <= perimeterCount; i ++) {
- dgEdge *const last = perimterEdges[i - 1];
- for (dgEdge *edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
- if (edge->m_mark != faceMark) {
- dgInt32 index = 0;
- for (index = 0; index < count; index ++) {
- if ((edgeArray[index] == edge) || (edgeArray[index] == edge->m_twin)) {
- break;
- }
- }
- if (index == count) {
- edgeArray[count] = edge;
- count ++;
- }
- }
- }
- }
-
- if (count) {
- while (count) {
- count --;
- dgEdge *const triangleFace = edgeArray[count];
- bool state = MatchFace(mesh, triangleFace, tetraMark);
- if (state) {
- NEWTON_ASSERT(triangleFace == triangleFace->m_next->m_next->m_next);
- triangleFace->m_mark = faceMark;
- dgEdge *ptr = triangleFace->m_next;
- do {
- ptr->m_mark = faceMark;
- for (dgInt32 i = 0; i < count; i ++) {
- if (ptr == edgeArray[i]) {
- edgeArray[i] = edgeArray[count - 1];
- i --;
- count --;
- break;
- }
- }
- ptr = ptr->m_next;
- } while (ptr != triangleFace);
- }
- }
-
- NEWTON_ASSERT(count == 0);
- for (dgInt32 i = 0; i < perimeterCount; i ++) {
- dgEdge *const edge = perimterEdges[i];
- if (edge->m_mark != faceMark) {
- dgEdge *const borderEdge = m_mesh->FindEdge(edge->m_incidentVertex, edge->m_twin->m_incidentVertex);
- NEWTON_ASSERT(borderEdge);
- if (!(edgeInconflict.Find(borderEdge) || edgeInconflict.Find(borderEdge->m_twin))) {
- edgeInconflict.Insert(borderEdge, borderEdge);
- }
- }
- edge->m_mark = faceMark;
- }
-
- for (dgInt32 i = 1; i <= perimeterCount; i ++) {
- const dgEdge *const last = perimterEdges[i - 1];
- for (dgEdge *edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
- if (edge->m_mark != faceMark) {
- edge->m_mark = faceMark;
- edge->m_twin->m_mark = faceMark;
-
- dgEdge *begin = NULL;
- for (dgEdge *ptr = edge; !begin; ptr = ptr->m_next->m_twin) {
- begin = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
- }
- NEWTON_ASSERT(begin);
-
- dgEdge *end = NULL;
- for (dgEdge *ptr = edge->m_twin; !end; ptr = ptr->m_next->m_twin) {
- end = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
- }
- NEWTON_ASSERT(end);
- dgEdge *const newEdge = m_mesh->ConectVertex(end, begin);
- NEWTON_ASSERT(!edgeInconflict.Find(newEdge));
- edgeInconflict.Insert(newEdge, newEdge);
- }
- }
- }
- }
- }
-
- void RecoverFaces() {
- // recover all sub faces into a temporary mesh
- bool allFaceFound = true;
-
-// dgIndexMapPair* const indexMap = &m_indexMap[0];
- do {
- dgMeshEffect tmpMesh(*m_mesh);
- dgInt32 mark = m_mesh->IncLRU();
-
- dgTree<dgEdge *, dgEdge *> edgeInconflict(GetAllocator());
- dgMeshEffect::Iterator iter(tmpMesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge *const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark) {
- RecoverFace(tmpMesh, face, mark, -1, edgeInconflict);
- }
- }
-
- // if there are missing sub faces then we must recover those by insertion point on the sub edges of the missing faces
- allFaceFound = true;
- if (edgeInconflict.GetCount()) {
- NEWTON_ASSERT(0);
- /*
- allFaceFound = false;
-
- dgTree<dgEdge*, dgEdge*>::Iterator iter (edgeInconflict);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const missingEdge = iter.GetNode()->GetInfo();
-
- dgInt32 k0 = missingEdge->m_incidentVertex;
- dgInt32 k1 = missingEdge->m_twin->m_incidentVertex;
- dgInt32 i0 = indexMap[k0].m_convexIndex;
- dgInt32 i1 = indexMap[k1].m_convexIndex;
-
- const dgBigVector& p0 = GetVertex(i0);
- const dgBigVector& p1 = GetVertex(i1);
- dgFloat32 spliteParam = dgFloat32 (0.5f);
-
- dgEdge* const newEdge = m_mesh->InsertEdgeVertex (missingEdge, spliteParam);
- dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
- dgInt32 index = AddVertex(p);
- NEWTON_ASSERT (index != -1);
- indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
- }
- RecoverEdges ();
- */
- }
-#ifdef _DEBUG
- if (allFaceFound) {
-// NEWTON_ASSERT (0);
- /*
- dgFaceKeyMap faceMap (GetAllocator());
- for (dgListNode* node = GetFirst(); node; node = node->GetNext()) {
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
- dgEdgeFaceKey key (face.m_index[0], face.m_index[1], face.m_index[2]);
- NEWTON_ASSERT (!faceMap.Find(key));
- faceMap.Insert (node, key);
- }
- }
-
- dgInt32 mark = tmpMesh.IncLRU();
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark){
- dgEdge* ptr = face;
- do {
- ptr->m_mark = mark;
- ptr = ptr->m_next;
- } while (ptr != face);
- dgEdgeFaceKey key (face->m_incidentVertex, face->m_next->m_incidentVertex, face->m_next->m_next->m_incidentVertex);
- NEWTON_ASSERT (faceMap.Find(key));
- }
- }
- */
- }
-#endif
-
- } while (!allFaceFound);
-
- // all faces are present in the mesh now we can recover the mesh
- // remove all tetrahedral with negative volume
- RemoveUpperHull();
-
- // remove any tetrahedron that by round off error might have more that three point on on a face
-// RemoveDegeneratedTetras ();
-
- //dgInt32 tetraMark = 1;
- dgInt32 tetraMark = IncMark();
- dgInt32 mark = m_mesh->IncLRU();
-
- dgTree<dgEdge *, dgEdge *> edgeInconflict(GetAllocator());
- dgMeshEffect::Iterator iter(*m_mesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge *const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark) {
- dgEdge *ptr = face;
- //dgTrace (("%d:", ptr->m_incidentFace))
- do {
- ptr->m_mark = mark;
- //dgTrace ((" %d", ptr->m_incidentVertex))
- ptr = ptr->m_next;
- } while (ptr != face);
- //dgTrace (("\n"));
- RecoverFace(*m_mesh, face, mark, tetraMark, edgeInconflict);
- }
- }
-
- // color codes all tetrahedron inside the mesh volume
- for (dgListNode *node = GetFirst(); node; node = node->GetNext()) {
- dgConvexHull4dTetraherum *const tetra = &node->GetInfo();
- if (tetra->GetMark() == tetraMark) {
- dgInt32 stack = 0;
- dgConvexHull4dTetraherum *stackPool[1024 * 4];
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace &face = tetra->m_faces[i];
- if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
- stackPool[stack] = &face.m_twin->GetInfo();
- stack ++;
- }
- }
-
- while (stack) {
- stack --;
- dgConvexHull4dTetraherum *const skinTetra = stackPool[stack];
- skinTetra->SetMark(tetraMark);
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace &face = skinTetra->m_faces[i];
- if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
- stackPool[stack] = &face.m_twin->GetInfo();
- stack ++;
- NEWTON_ASSERT(stack < sizeof(stackPool) / sizeof(stackPool[0]));
- }
- }
- }
- }
- }
-
- // remove all tetrahedron outsize the mesh volume (those who are not painted)
- dgListNode *nextNode = NULL;
- for (dgListNode *node = GetFirst(); node; node = nextNode) {
- nextNode = node->GetNext();
- dgConvexHull4dTetraherum *const tetra = &node->GetInfo();
- if (tetra->GetMark() != tetraMark) {
- DeleteFace(node);
- }
- }
- }
-
- dgMeshEffect *m_mesh;
- dgEdgeMap m_edgeMap;
- dgVertexMap m_vertexMap;
- dgMissingEdges m_missinEdges;
- dgArray<dgIndexMapPair> m_indexMap;
-};
-
-#else
-
-/*
- class Tetrahedralization: public dgDelaunayTetrahedralization
- {
- class dgIndexMapPair
- {
- public:
- dgInt32 m_meshIndex;
- dgInt32 m_convexIndex;
- };
-
- class dgMissingEdges: public dgList<dgPolyhedra::dgTreeNode*>
- {
- public:
- dgMissingEdges (dgMemoryAllocator* const allocator)
- :dgList<dgPolyhedra::dgTreeNode*> (allocator)
- {
- }
- ~dgMissingEdges()
- {
- }
- };
-
- class dgEdgeSharedTetras: public dgList<dgDelaunayTetrahedralization::dgListNode*>
- {
- public:
- dgEdgeSharedTetras(const dgEdgeSharedTetras& copy)
- :dgList<dgDelaunayTetrahedralization::dgListNode*>(copy.GetAllocator())
- {
- }
-
- dgEdgeSharedTetras(dgMemoryAllocator* const allocator)
- :dgList<dgDelaunayTetrahedralization::dgListNode*>(allocator)
- {
- }
-
- ~dgEdgeSharedTetras ()
- {
- }
- };
-
- class dgEdgeMap: public dgTree<dgEdgeSharedTetras, dgUnsigned64>
- {
- public:
- dgEdgeMap(dgMemoryAllocator* const allocator)
- :dgTree<dgEdgeSharedTetras, dgUnsigned64>(allocator)
- {
- }
-
- ~dgEdgeMap()
- {
- while(GetRoot()) {
- dgEdgeSharedTetras& header = GetRoot()->GetInfo();
- header.RemoveAll();
- Remove(GetRoot());
- }
- }
- };
-
- #ifdef _DEBUG
- class dgEdgeFaceKey
- {
- public:
- dgEdgeFaceKey ()
- {}
-
- dgEdgeFaceKey (dgInt32 i0, dgInt32 i1, dgInt32 i2)
- {
- m_index[0] = i0;
- m_index[1] = i1;
- m_index[2] = i2;
- while ((m_index[0] > m_index[1]) || (m_index[0] > m_index[2])) {
- i0 = m_index[0];
- m_index[0] = m_index[1];
- m_index[1] = m_index[2];
- m_index[2] = i0;
- }
- }
-
- dgInt32 Compared (const dgEdgeFaceKey& key) const
- {
- for (dgInt32 i = 0; i < 3; i ++) {
- if (m_index[i] < key.m_index[i]) {
- return -1;
- } else if (m_index[i] > key.m_index[i]) {
- return 1;
- }
- }
- return 0;
- }
-
-
- bool operator < (const dgEdgeFaceKey& key) const
- {
- return (Compared (key) < 0);
- }
-
- bool operator > (const dgEdgeFaceKey& key) const
- {
- return (Compared (key) > 0);
- }
-
-
- dgInt32 m_index[3];
-
- };
-
-
- class dgFaceKeyMap: public dgTree<dgListNode*, dgEdgeFaceKey>
- {
- public:
- dgFaceKeyMap(dgMemoryAllocator* const allocator)
- :dgTree<dgListNode*, dgEdgeFaceKey>(allocator)
- {
-
- }
- };
- #endif
-
- public:
- Tetrahedralization (dgMeshEffect& mesh)
- :dgDelaunayTetrahedralization (mesh.GetAllocator(), mesh.GetVertexPool(), mesh.GetVertexCount(), sizeof (dgVector), 0.0f),
- m_mesh (&mesh),
- m_edgeMap (mesh.GetAllocator()),
- m_missinEdges(mesh.GetAllocator()),
- m_indexMap (mesh.GetVertexCount() * 8 + 2048, mesh.GetAllocator())
- {
- if (GetCount()) {
- // add every edge of each tetrahedral to a edge list
- BuildTetrahedraEdgeList ();
-
- // make a index map to quickly find vertex mapping form the mesh to the delaunay tetrahedron
- CreateIndexMap ();
-
- // Insert all missing edge in mesh as a new into the tetrahedral list
- RecoverEdges ();
-
- // Recover the solid mesh from the delaunay tetrahedron
- RecoverFaces ();
- }
- }
-
-
- ~Tetrahedralization()
- {
- }
-
- void BuildTetrahedraEdgeList ()
- {
- for (dgListNode* node = GetFirst(); node; node = node->GetNext()) {
- AddEdges (node);
- }
- }
-
- void RecoverEdges ()
- {
- // split every missing edge at the center and add the two half to the triangulation
- // keep doing it until all edge are present in the triangulation.
-
- dgInt32 mark = m_mesh->IncLRU();
-
- // create a list all all the edge that are in the mesh but that do not appear in the delaunay tetrahedron
- const dgIndexMapPair* const indexMap = &m_indexMap[0];
- dgPolyhedra::Iterator iter (*m_mesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const edge = &iter.GetNode()->GetInfo();
- if (edge->m_mark != mark) {
- edge->m_mark = mark;
- edge->m_twin->m_mark = mark;
-
- dgInt32 i0 = indexMap[edge->m_incidentVertex].m_convexIndex;
- dgInt32 i1 = indexMap[edge->m_twin->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey (i0, i1);
- dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
- if (!edgeNode) {
- m_missinEdges.Append(iter.GetNode());
- }
- }
- }
-
- while (m_missinEdges.GetCount()){
- dgIndexMapPair* const indexMap = &m_indexMap[0];
-
- dgMissingEdges::dgListNode* missingEdgeNode = m_missinEdges.GetFirst();
- dgEdge* missingEdge = &missingEdgeNode->GetInfo()->GetInfo();
-
- dgInt32 k0 = missingEdge->m_incidentVertex;
- dgInt32 k1 = missingEdge->m_twin->m_incidentVertex;
- dgInt32 i0 = indexMap[k0].m_convexIndex;
- dgInt32 i1 = indexMap[k1].m_convexIndex;
-
- m_missinEdges.Remove(missingEdgeNode);
- dgUnsigned64 key = GetKey (i0, i1);
- if (!m_edgeMap.Find(key)) {
- const dgBigVector& p0 = GetVertex(i0);
- const dgBigVector& p1 = GetVertex(i1);
- dgFloat64 spliteParam = dgFloat64 (0.5f);
- dgEdge* const newEdge = m_mesh->InsertEdgeVertex (missingEdge, dgFloat32 (spliteParam));
- newEdge->m_mark = mark;
- newEdge->m_next->m_mark = mark;
- newEdge->m_twin->m_mark = mark;
- newEdge->m_twin->m_prev->m_mark = mark;
-
- dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
- dgInt32 index = AddVertex(p);
- NEWTON_ASSERT (index != -1);
- indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
-
- i0 = indexMap[newEdge->m_incidentVertex].m_convexIndex;
- i1 = indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex;
- key = GetKey (i0, i1);
- if (!m_edgeMap.Find(key)) {
- dgInt32 index0 = GetVertexIndex(i0);
- dgInt32 index1 = GetVertexIndex(i1);
- dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- NEWTON_ASSERT (edgeNode);
- m_missinEdges.Append(edgeNode);
- }
-
- i0 = indexMap[newEdge->m_next->m_incidentVertex].m_convexIndex;
- i1 = indexMap[newEdge->m_next->m_twin->m_incidentVertex].m_convexIndex;
- key = GetKey (i0, i1);
- if (!m_edgeMap.Find(key)) {
- dgInt32 index0 = GetVertexIndex(i0);
- dgInt32 index1 = GetVertexIndex(i1);
- dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- NEWTON_ASSERT (edgeNode);
- m_missinEdges.Append(edgeNode);
- }
- }
- }
- }
-
- void RemoveDegeneratedTetras ()
- {
- dgInt32 mark = m_mesh->IncLRU();
- dgPolyhedra::Iterator iter (*m_mesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const faceEdge = &iter.GetNode()->GetInfo();
- dgInt32 count = 0;
- dgEdge* ptr = faceEdge;
- do {
- count ++;
- ptr->m_mark = mark;
- ptr = ptr->m_next;
- } while (ptr != faceEdge);
-
- if (count > 3) {
- dgEdge* ptr = faceEdge;
- do {
- dgInt32 k0 = m_indexMap[ptr->m_incidentVertex].m_convexIndex;
- dgInt32 k1 = m_indexMap[ptr->m_next->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey (k0, k1);
- dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
- if (edgeNode) {
- dgEdgeSharedTetras& header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode* ptr1 = header.GetFirst(); ptr1; ptr1 = ptr1->GetNext()) {
- dgListNode* const tetraNode = ptr1->GetInfo();
- dgConvexHull4dTetraherum* const tetra = &tetraNode->GetInfo();
- const dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[0];
- dgInt32 index[4];
- index[0] = GetVertexIndex(face.m_index[0]);
- index[1] = GetVertexIndex(face.m_index[1]);
- index[2] = GetVertexIndex(face.m_index[2]);
- index[3] = GetVertexIndex(face.m_otherVertex);
-
- dgInt32 duplicates = 0;
- dgEdge* ptr3 = faceEdge;
- do {
- for (dgInt32 i = 0; i < 4; i ++) {
- duplicates += (ptr3->m_incidentVertex == index[i]) ? 1 : 0;
- }
- ptr3 = ptr3->m_next;
- } while (ptr3 != faceEdge);
- if (duplicates > 3) {
- DeleteFace(tetraNode);
- break;
- }
- }
- }
-
- ptr = ptr->m_next;
- } while (ptr != faceEdge);
- }
- }
- }
-
-
- bool MatchFace (dgMeshEffect& mesh, dgEdge* const faceEdge, dgInt32 tetraMark) const
- {
- dgInt32 k0 = m_indexMap[faceEdge->m_incidentVertex].m_convexIndex;
- dgInt32 k1 = m_indexMap[faceEdge->m_next->m_incidentVertex].m_convexIndex;
- dgUnsigned64 key = GetKey (k0, k1);
- dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
-
- NEWTON_ASSERT (edgeNode);
- dgEdgeSharedTetras& header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode* ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- dgListNode* const tetraNode = ptr->GetInfo();
- dgConvexHull4dTetraherum* const tetra = &tetraNode->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
- dgInt32 i0 = face.m_index[0];
- dgInt32 i1 = face.m_index[1];
- dgInt32 i2 = face.m_index[2];
-
- if (((i0 == k0) && (i1 == k1)) || ((i1 == k0) && (i2 == k1)) || ((i2 == k0) && (i0 == k1))) {
- dgInt32 index[3];
-
- index[0] = GetVertexIndex (i0);
- index[1] = GetVertexIndex (i1);
- index[2] = GetVertexIndex (i2);
- while (index[0] != faceEdge->m_incidentVertex) {
- dgInt32 tmp = index[0];
- index[0] = index[1];
- index[1] = index[2];
- index[2] = tmp;
- }
- NEWTON_ASSERT (index[0] == faceEdge->m_incidentVertex);
- NEWTON_ASSERT (index[1] == faceEdge->m_next->m_incidentVertex);
-
- dgEdge* nextEdge = faceEdge->m_next->m_next;
- do {
- if (nextEdge->m_incidentVertex == index[2]) {
- break;
- }
- nextEdge = nextEdge->m_next;
- } while (nextEdge != faceEdge);
-
- if (nextEdge != faceEdge) {
- #ifdef _MSC_VER
- #ifdef _DEBUG
- if (nextEdge->m_prev != faceEdge->m_next) {
- dgEdge* const edge = mesh.ConectVertex(faceEdge->m_next, nextEdge);
- NEWTON_ASSERT (edge);
- NEWTON_ASSERT (edge->m_next);
- NEWTON_ASSERT (edge->m_prev);
- NEWTON_ASSERT (edge->m_twin->m_next);
- NEWTON_ASSERT (edge->m_twin->m_prev);
- NEWTON_ASSERT (faceEdge->m_next == edge->m_twin);
- }
- #endif
- #endif
- if (nextEdge->m_next != faceEdge) {
- #ifdef _DEBUG
- dgEdge* const edge = mesh.ConectVertex(faceEdge, nextEdge);
- NEWTON_ASSERT (edge);
- NEWTON_ASSERT (edge->m_next);
- NEWTON_ASSERT (edge->m_prev);
- NEWTON_ASSERT (edge->m_twin->m_next);
- NEWTON_ASSERT (edge->m_twin->m_prev);
- NEWTON_ASSERT (faceEdge->m_prev == edge);
- #else
- mesh.ConectVertex(faceEdge, nextEdge);
- #endif
-
- }
-
- if (tetraMark != -1) {
- tetra->SetMark (tetraMark);
- face.m_twin = NULL;
- }
- return true;
- }
- }
- }
- }
- return false;
- }
-
- void RecoverFace (dgMeshEffect& mesh, dgEdge* const face, dgInt32 faceMark, dgInt32 tetraMark, dgTree<dgEdge*, dgEdge*>& edgeInconflict) const
- {
- dgInt32 count = 0;
- dgInt32 perimeterCount = 0;
- dgEdge* edgeArray[1024];
- dgEdge* perimterEdges[1024 + 1];
-
- dgEdge* ptr = face;
- do {
- edgeArray[count] = ptr;
- perimterEdges[count] = ptr;
- count ++;
- NEWTON_ASSERT (count < sizeof (edgeArray) / sizeof (edgeArray[0]));
- ptr = ptr->m_next;
- } while (ptr != face);
- perimeterCount = count;
- perimterEdges[count] = face;
-
-
- while (count) {
- count --;
- dgEdge* const triangleFace = edgeArray[count];
- bool state = MatchFace (mesh, triangleFace, tetraMark);
- if (state) {
- NEWTON_ASSERT (triangleFace == triangleFace->m_next->m_next->m_next);
- triangleFace->m_mark = faceMark;
- dgEdge* ptr = triangleFace->m_next;
- do {
- ptr->m_mark = faceMark;
- for (dgInt32 i = 0; i < count; i ++) {
- if (ptr == edgeArray[i]) {
- edgeArray[i] = edgeArray[count - 1];
- i --;
- count --;
- break;
- }
- }
- ptr = ptr->m_next;
- } while (ptr != triangleFace);
- }
- }
-
- NEWTON_ASSERT (count == 0);
- for (dgInt32 i = 1; i <= perimeterCount; i ++) {
- dgEdge* const last = perimterEdges[i - 1];
- for (dgEdge* edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
- if (edge->m_mark != faceMark) {
- dgInt32 index = 0;
- for (index = 0; index < count; index ++) {
- if ((edgeArray[index] == edge) || (edgeArray[index] == edge->m_twin)) {
- break;
- }
- }
- if (index == count) {
- edgeArray[count] = edge;
- count ++;
- }
- }
- }
- }
-
- if (count) {
- while (count) {
- count --;
- dgEdge* const triangleFace = edgeArray[count];
- bool state = MatchFace (mesh, triangleFace, tetraMark);
- if (state) {
- NEWTON_ASSERT (triangleFace == triangleFace->m_next->m_next->m_next);
- triangleFace->m_mark = faceMark;
- dgEdge* ptr = triangleFace->m_next;
- do {
- ptr->m_mark = faceMark;
- for (dgInt32 i = 0; i < count; i ++) {
- if (ptr == edgeArray[i]) {
- edgeArray[i] = edgeArray[count - 1];
- i --;
- count --;
- break;
- }
- }
- ptr = ptr->m_next;
- } while (ptr != triangleFace);
- }
- }
-
- NEWTON_ASSERT (count == 0);
- for (dgInt32 i = 0; i < perimeterCount; i ++) {
- dgEdge* const edge = perimterEdges[i];
- if (edge->m_mark != faceMark) {
- dgEdge* const borderEdge = m_mesh->FindEdge(edge->m_incidentVertex, edge->m_twin->m_incidentVertex);
- NEWTON_ASSERT (borderEdge);
- if (!(edgeInconflict.Find(borderEdge) || edgeInconflict.Find(borderEdge->m_twin))) {
- edgeInconflict.Insert(borderEdge, borderEdge);
- }
- }
- edge->m_mark = faceMark;
- }
-
- for (dgInt32 i = 1; i <= perimeterCount; i ++) {
- const dgEdge* const last = perimterEdges[i - 1];
- for (dgEdge* edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
- if (edge->m_mark != faceMark) {
- edge->m_mark = faceMark;
- edge->m_twin->m_mark = faceMark;
-
- dgEdge* begin = NULL;
- for (dgEdge* ptr = edge; !begin; ptr = ptr->m_next->m_twin) {
- begin = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
- }
- NEWTON_ASSERT (begin);
-
- dgEdge* end = NULL;
- for (dgEdge* ptr = edge->m_twin; !end; ptr = ptr->m_next->m_twin) {
- end = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
- }
- NEWTON_ASSERT (end);
- dgEdge* const newEdge = m_mesh->ConectVertex(end, begin);
- NEWTON_ASSERT (!edgeInconflict.Find(newEdge));
- edgeInconflict.Insert(newEdge, newEdge);
- }
- }
- }
- }
- }
-
-
- static dgInt32 ConvexCompareIndex(const dgIndexMapPair* const A, const dgIndexMapPair* const B, void* const context)
- {
- if (A->m_meshIndex > B->m_meshIndex) {
- return 1;
- } else if (A->m_meshIndex < B->m_meshIndex) {
- return -1;
- }
- return 0;
- }
-
- void CreateIndexMap ()
- {
- // make a index map to quickly find vertex mapping form the mesh to the delaunay tetrahedron
- m_indexMap[GetVertexCount()].m_meshIndex = 0;
- dgIndexMapPair* const indexMap = &m_indexMap[0];
- for (dgInt32 i = 0; i < GetVertexCount(); i ++) {
- indexMap[i].m_convexIndex = i;
- indexMap[i].m_meshIndex = GetVertexIndex(i);
- }
- dgSort(indexMap, GetVertexCount(), ConvexCompareIndex);
- }
-
- dgUnsigned64 GetKey (dgInt32 i0, dgInt32 i1) const
- {
- return (i1 > i0) ? (dgUnsigned64 (i1) << 32) + i0 : (dgUnsigned64 (i0) << 32) + i1;
- }
-
- void InsertNewNode (dgInt32 i0, dgInt32 i1, dgListNode* const node)
- {
- dgUnsigned64 key = GetKey (i1, i0);
-
- dgEdgeMap::dgTreeNode* edgeNode = m_edgeMap.Find(key);
- if (!edgeNode) {
- dgEdgeSharedTetras tmp (GetAllocator());
- edgeNode = m_edgeMap.Insert(tmp, key);
- }
- dgEdgeSharedTetras& header = edgeNode->GetInfo();
-
- #ifdef _DEBUG
- for (dgEdgeSharedTetras::dgListNode* ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- NEWTON_ASSERT (ptr->GetInfo() != node);
- }
- #endif
- header.Append(node);
- }
-
- void AddEdges (dgListNode* const node)
- {
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- dgFloat64 volume = GetTetraVolume (tetra);
- if (volume < dgFloat64 (0.0f)) {
- const dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[0];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i0 = face.m_otherVertex;
- dgInt32 i1 = face.m_index[i];
- InsertNewNode (i0, i1, node);
- }
-
- dgInt32 i0 = face.m_index[2];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i1 = face.m_index[i];
- InsertNewNode (i0, i1, node);
- i0 = i1;
- }
- }
- }
-
- void RemoveNode(dgInt32 i0, dgInt32 i1, dgListNode* const node)
- {
- dgUnsigned64 key = GetKey (i0, i1);
-
- dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
- if (edgeNode) {
- dgEdgeSharedTetras& header = edgeNode->GetInfo();
- for (dgEdgeSharedTetras::dgListNode* ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- dgListNode* const me = ptr->GetInfo();
- if (me == node) {
- header.Remove(ptr);
- if (!header.GetCount()) {
- m_edgeMap.Remove(edgeNode);
- }
-
- dgInt32 index0 = GetVertexIndex(i0);
- dgInt32 index1 = GetVertexIndex(i1);
- dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- if(edgeNode) {
- m_missinEdges.Append(edgeNode);
- }
- break;
- }
- }
- }
- }
-
- void RemoveEdges (dgListNode* const node)
- {
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- const dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[0];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i0 = face.m_otherVertex;
- dgInt32 i1 = face.m_index[i];
- RemoveNode(i0, i1, node);
- }
-
- dgInt32 i0 = face.m_index[2];
- for (dgInt32 i = 0; i < 3; i ++) {
- dgInt32 i1 = face.m_index[i];
- RemoveNode(i0, i1, node);
- i0 = i1;
- }
- }
-
- dgListNode* AddFace (dgInt32 i0, dgInt32 i1, dgInt32 i2, dgInt32 i3)
- {
- dgListNode* const face = dgDelaunayTetrahedralization::AddFace(i0, i1, i2, i3);
- AddEdges(face);
- return face;
- }
-
- void DeleteFace (dgListNode* const node)
- {
- RemoveEdges (node);
-
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- for (dgInt32 i= 0; i < 4; i ++) {
- const dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
- dgListNode* const twinNode = face.m_twin;
- if (twinNode) {
- dgConvexHull4dTetraherum* const twinTetra = &twinNode->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- if (twinTetra->m_faces[i].m_twin == node) {
- twinTetra->m_faces[i].m_twin = NULL;
- }
- }
- }
- }
-
- dgDelaunayTetrahedralization::DeleteFace(node);
- }
-
-
-
-
- void RecoverFaces ()
- {
- // recover all sub faces into a temporary mesh
- bool allFaceFound = true;
-
- dgIndexMapPair* const indexMap = &m_indexMap[0];
- do {
- dgMeshEffect tmpMesh (*m_mesh);
- dgInt32 mark = m_mesh->IncLRU();
-
- dgTree<dgEdge*, dgEdge*> edgeInconflict(GetAllocator());
- dgMeshEffect::Iterator iter(tmpMesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark){
- RecoverFace (tmpMesh, face, mark, -1, edgeInconflict);
- }
- }
-
- // if there are missing sub faces then we must recover those by insertion point on the sub edges of the missing faces
- allFaceFound = true;
- if (edgeInconflict.GetCount()) {
- allFaceFound = false;
-
- dgTree<dgEdge*, dgEdge*>::Iterator iter (edgeInconflict);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const missingEdge = iter.GetNode()->GetInfo();
-
- dgInt32 k0 = missingEdge->m_incidentVertex;
- dgInt32 k1 = missingEdge->m_twin->m_incidentVertex;
- dgInt32 i0 = indexMap[k0].m_convexIndex;
- dgInt32 i1 = indexMap[k1].m_convexIndex;
-
- const dgBigVector& p0 = GetVertex(i0);
- const dgBigVector& p1 = GetVertex(i1);
- dgFloat32 spliteParam = dgFloat32 (0.5f);
-
- dgEdge* const newEdge = m_mesh->InsertEdgeVertex (missingEdge, spliteParam);
- dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
- dgInt32 index = AddVertex(p);
- NEWTON_ASSERT (index != -1);
- indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
- }
- RecoverEdges ();
- }
-
- #ifdef _DEBUG
- if (allFaceFound) {
- dgFaceKeyMap faceMap (GetAllocator());
- for (dgListNode* node = GetFirst(); node; node = node->GetNext()) {
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
- dgEdgeFaceKey key (face.m_index[0], face.m_index[1], face.m_index[2]);
- NEWTON_ASSERT (!faceMap.Find(key));
- faceMap.Insert (node, key);
- }
- }
-
- dgInt32 mark = tmpMesh.IncLRU();
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark){
- dgEdge* ptr = face;
- do {
- ptr->m_mark = mark;
- ptr = ptr->m_next;
- } while (ptr != face);
- dgEdgeFaceKey key (face->m_incidentVertex, face->m_next->m_incidentVertex, face->m_next->m_next->m_incidentVertex);
- NEWTON_ASSERT (faceMap.Find(key));
- }
- }
- }
- #endif
-
-
- } while (!allFaceFound);
-
-
- // all faces are present in the mesh now we can recover the mesh
- // remove all tetrahedral with negative volume
- RemoveUpperHull ();
-
- // remove any tetrahedron that by round off error might have more that three point on on a face
- RemoveDegeneratedTetras ();
-
-
- //dgInt32 tetraMark = 1;
- dgInt32 tetraMark = IncMark();
- dgInt32 mark = m_mesh->IncLRU();
-
- dgTree<dgEdge*, dgEdge*> edgeInconflict(GetAllocator());
- dgMeshEffect::Iterator iter(*m_mesh);
- for (iter.Begin(); iter; iter ++) {
- dgEdge* const face = &iter.GetNode()->GetInfo();
- if (face->m_mark != mark){
- dgEdge* ptr = face;
- //dgTrace (("%d:", ptr->m_incidentFace))
- do {
- ptr->m_mark = mark;
- //dgTrace ((" %d", ptr->m_incidentVertex))
- ptr = ptr->m_next;
- } while (ptr != face);
- //dgTrace (("\n"));
- RecoverFace (*m_mesh, face, mark, tetraMark, edgeInconflict);
- }
- }
-
- // color codes all tetrahedron inside the mesh volume
- for (dgListNode* node = GetFirst(); node; node = node->GetNext()) {
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- if (tetra->GetMark() == tetraMark) {
- dgInt32 stack = 0;
- dgConvexHull4dTetraherum* stackPool[1024 * 4];
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
- if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
- stackPool[stack] = &face.m_twin->GetInfo();
- stack ++;
- }
- }
-
- while (stack) {
- stack --;
- dgConvexHull4dTetraherum* const skinTetra = stackPool[stack];
- skinTetra->SetMark (tetraMark);
- for (dgInt32 i = 0; i < 4; i ++) {
- dgConvexHull4dTetraherum::dgTetrahedrumFace& face = skinTetra->m_faces[i];
- if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
- stackPool[stack] = &face.m_twin->GetInfo();
- stack ++;
- NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
- }
- }
- }
- }
- }
-
- // remove all tetrahedron outsize the mesh volume (those who are not painted)
- dgListNode* nextNode = NULL;
- for (dgListNode* node = GetFirst(); node; node = nextNode) {
- nextNode = node->GetNext();
- dgConvexHull4dTetraherum* const tetra = &node->GetInfo();
- if (tetra->GetMark() != tetraMark) {
- DeleteFace (node);
- }
- }
- }
-
-
- dgMeshEffect* m_mesh;
- dgEdgeMap m_edgeMap;
- dgMissingEdges m_missinEdges;
- dgArray<dgIndexMapPair> m_indexMap;
- };
- */
-
-#endif
dgMeshEffect *dgMeshEffect::CreateDelanayTretrahedralization(
dgInt32 interionMaterial, dgMatrix &matrix) const {
@@ -1839,11 +91,6 @@ dgMeshEffect *dgMeshEffect::CreateVoronoiPartition(dgInt32 pointsCount,
dgInt32 interiorMaterial, dgMatrix &textureProjectionMatrix) const {
// return new (GetAllocator()) dgMeshEffect (*this);
-#ifdef _WIN32
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-
dgMeshEffectSolidTree *const tree = CreateSolidTree();
NEWTON_ASSERT(tree);
@@ -1996,10 +243,6 @@ dgMeshEffect *dgMeshEffect::CreateVoronoiPartition(dgInt32 pointsCount,
voronoiPartition->ConvertToPolygons();
-#ifdef _WIN32
- dgControlFP(controlWorld, _MCW_PC);
-#endif
-
delete tree;
return voronoiPartition;
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp b/engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp
index a6a92b186ca..043da504ad4 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp
@@ -542,12 +542,6 @@ void dgWorld::UpdateCollision() {
m_inUpdate++;
NEWTON_ASSERT(m_numberOfTheads >= 1);
-#ifdef _WIN32
-#ifndef __USE_DOUBLE_PRECISION__
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-#endif
timestep = dgFloat32(0.0f);
@@ -566,12 +560,6 @@ void dgWorld::UpdateCollision() {
}
m_inUpdate--;
-#ifdef _WIN32
-#ifndef __USE_DOUBLE_PRECISION__
- dgControlFP(controlWorld, _MCW_PC);
-#endif
-#endif
-
m_perfomanceCounters[m_worldTicks] = m_getPerformanceCount() - ticks;
}
@@ -596,9 +584,6 @@ void dgWorld::Update(dgFloat32 timestep) {
// xxx ++;
// m_cpu = dgNoSimdPresent;
-#ifdef _LINUX_VER
-// m_cpu = dgNoSimdPresent;
-#endif
NEWTON_ASSERT(m_inUpdate == 0);
@@ -612,13 +597,6 @@ void dgWorld::Update(dgFloat32 timestep) {
m_inUpdate++;
NEWTON_ASSERT(m_numberOfTheads >= 1);
-#ifdef _WIN32
-#ifndef __USE_DOUBLE_PRECISION__
- dgUnsigned32 controlWorld = dgControlFP(0xffffffff, 0);
- dgControlFP(_PC_53, _MCW_PC);
-#endif
-#endif
-
if (m_cpu == dgSimdPresent) {
#ifdef DG_BUILD_SIMD_CODE
simd_env rounding = simd_get_ctrl();
@@ -635,13 +613,7 @@ void dgWorld::Update(dgFloat32 timestep) {
m_dynamicSolver.UpdateDynamics(this, 0, timestep);
}
m_inUpdate--;
-
-#ifdef _WIN32
-#ifndef __USE_DOUBLE_PRECISION__
- dgControlFP(controlWorld, _MCW_PC);
-#endif
-#endif
-
+
if (m_destroyBodyByExeciveForce) {
for (dgInt32 i = 0; i < m_destroyeddBodiesPool.m_count; i++) {
m_destroyBodyByExeciveForce(m_destroyeddBodiesPool.m_bodies[i],
More information about the Scummvm-git-logs
mailing list