Revision: 65507
http://sourceforge.net/p/brlcad/code/65507
Author: ejno
Date: 2015-07-01 13:39:40 +0000 (Wed, 01 Jul 2015)
Log Message:
-----------
fixes
Modified Paths:
--------------
brlcad/trunk/src/librt/primitives/bot/gct_decimation/meshdecimation.c
Modified: brlcad/trunk/src/librt/primitives/bot/gct_decimation/meshdecimation.c
===================================================================
--- brlcad/trunk/src/librt/primitives/bot/gct_decimation/meshdecimation.c
2015-06-30 21:20:15 UTC (rev 65506)
+++ brlcad/trunk/src/librt/primitives/bot/gct_decimation/meshdecimation.c
2015-07-01 13:39:40 UTC (rev 65507)
@@ -35,7 +35,6 @@
#include <math.h>
#include <float.h>
-
#include "auxiliary/cpuconfig.h"
#include "auxiliary/cpuinfo.h"
#include "auxiliary/cc.h"
@@ -49,13 +48,6 @@
#include "bu/log.h"
#include "vmath.h"
-#if defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) &&
!defined(__clang__)
-# pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-#if defined(__clang__)
-# pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
#ifdef __SSE__
#include <xmmintrin.h>
#endif
@@ -75,6 +67,12 @@
#include <smmintrin.h>
#endif
+#if defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) &&
!defined(__clang__)
+# pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
/* Define to use double floating point precision */
/*
@@ -183,14 +181,20 @@
#ifdef MD_CONFIG_SSE_SUPPORT
extern int mdPathSSE4p1;
-float mdEdgeCollapsePenaltyTriangleSSE4p1f(float *newpoint, float *oldpoint,
float *leftpoint, float *rightpoint, int *denyflag, float compactnesstarget);
-double mdEdgeCollapsePenaltyTriangleSSE4p1d(double *newpoint, double
*oldpoint, double *leftpoint, double *rightpoint, int *denyflag, double
compactnesstarget);
+float mdEdgeCollapsePenaltyTriangleSSE4p1f(float *newpoint, float *oldpoint,
+ float *leftpoint, float *rightpoint, int *denyflag, float
compactnesstarget);
+double mdEdgeCollapsePenaltyTriangleSSE4p1d(double *newpoint, double *oldpoint,
+ double *leftpoint, double *rightpoint, int *denyflag, double
compactnesstarget);
extern int mdPathSSE3;
-float mdEdgeCollapsePenaltyTriangleSSE3f(float *newpoint, float *oldpoint,
float *leftpoint, float *rightpoint, int *denyflag, float compactnesstarget);
-double mdEdgeCollapsePenaltyTriangleSSE3d(double *newpoint, double *oldpoint,
double *leftpoint, double *rightpoint, int *denyflag, double compactnesstarget);
+float mdEdgeCollapsePenaltyTriangleSSE3f(float *newpoint, float *oldpoint,
+ float *leftpoint, float *rightpoint, int *denyflag, float
compactnesstarget);
+double mdEdgeCollapsePenaltyTriangleSSE3d(double *newpoint, double *oldpoint,
+ double *leftpoint, double *rightpoint, int *denyflag, double
compactnesstarget);
extern int mdPathSSE2;
-float mdEdgeCollapsePenaltyTriangleSSE2f(float *newpoint, float *oldpoint,
float *leftpoint, float *rightpoint, int *denyflag, float compactnesstarget);
-double mdEdgeCollapsePenaltyTriangleSSE2d(double *newpoint, double *oldpoint,
double *leftpoint, double *rightpoint, int *denyflag, double compactnesstarget);
+float mdEdgeCollapsePenaltyTriangleSSE2f(float *newpoint, float *oldpoint,
+ float *leftpoint, float *rightpoint, int *denyflag, float
compactnesstarget);
+double mdEdgeCollapsePenaltyTriangleSSE2d(double *newpoint, double *oldpoint,
+ double *leftpoint, double *rightpoint, int *denyflag, double
compactnesstarget);
#endif
@@ -224,13 +228,13 @@
#define mdfacos(x) acos(x)
#else
typedef float mdf;
-#define mdfmin(x,y) fminf((x),(y))
-#define mdfmax(x,y) fmaxf((x),(y))
-#define mdffloor(x) floorf(x)
-#define mdfceil(x) ceilf(x)
-#define mdfround(x) roundf(x)
+#define mdfmin(x,y) FMIN((x),(y))
+#define mdfmax(x,y) FMAX((x),(y))
+#define mdffloor(x) floor(x)
+#define mdfceil(x) ceil(x)
+#define mdfround(x) round(x)
#define mdfsqrt(x) sqrt(x)
-#define mdfcbrt(x) cbrtf(x)
+#define mdfcbrt(x) cbrt(x)
#define mdfabs(x) fabs(x)
#define mdflog2(x) log2(x)
#define mdfacos(x) acos(x)
@@ -276,7 +280,8 @@
#endif
} mathQuadric;
-static void mathQuadricInit(mathQuadric *q, mdqf a, mdqf b, mdqf c, mdqf d,
mdqf area)
+static void mathQuadricInit(mathQuadric *q, mdqf a, mdqf b, mdqf c, mdqf d,
+ mdqf area)
{
q->area = area;
@@ -296,7 +301,9 @@
#endif
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Q Init %f ; %f %f %f %f %f %f %f %f %f %f\n", (double)q->area,
(double)q->a2, (double)q->ab, (double)q->ac, (double)q->ad, (double)q->b2,
(double)q->bc, (double)q->bd, (double)q->c2, (double)q->cd, (double)q->d2);
+ printf(" Q Init %f ; %f %f %f %f %f %f %f %f %f %f\n", (double)q->area,
+ (double)q->a2, (double)q->ab, (double)q->ac, (double)q->ad,
(double)q->b2,
+ (double)q->bc, (double)q->bd, (double)q->c2, (double)q->cd,
(double)q->d2);
#endif
return;
@@ -309,9 +316,12 @@
static mdqf mathMatrix3x3Determinant(mdqf *m)
{
mdqf det;
- det = m[0 * 3 + 0] * (m[2 * 3 + 2] * m[1 * 3 + 1] - m[2 * 3 + 1] * m[1 *
3 + 2]);
- det -= m[1 * 3 + 0] * (m[2 * 3 + 2] * m[0 * 3 + 1] - m[2 * 3 + 1] * m[0 *
3 + 2]);
- det += m[2 * 3 + 0] * (m[1 * 3 + 2] * m[0 * 3 + 1] - m[1 * 3 + 1] * m[0 *
3 + 2]);
+ det = m[0 * 3 + 0] * (m[2 * 3 + 2] * m[1 * 3 + 1] - m[2 * 3 + 1] * m[1 *
3 +
+ 2]);
+ det -= m[1 * 3 + 0] * (m[2 * 3 + 2] * m[0 * 3 + 1] - m[2 * 3 + 1] * m[0 *
3 +
+ 2]);
+ det += m[2 * 3 + 0] * (m[1 * 3 + 2] * m[0 * 3 + 1] - m[1 * 3 + 1] * m[0 *
3 +
+ 2]);
return det;
}
@@ -343,15 +353,24 @@
{
mdf detinv;
detinv = 1.0 / det;
- mdst[0 * 3 + 0] = (m[2 * 3 + 2] * m[1 * 3 + 1] - m[2 * 3 + 1] * m[1 * 3 +
2]) * detinv;
- mdst[0 * 3 + 1] = -(m[2 * 3 + 2] * m[0 * 3 + 1] - m[2 * 3 + 1] * m[0 * 3 +
2]) * detinv;
- mdst[0 * 3 + 2] = (m[1 * 3 + 2] * m[0 * 3 + 1] - m[1 * 3 + 1] * m[0 * 3 +
2]) * detinv;
- mdst[1 * 3 + 0] = -(m[2 * 3 + 2] * m[1 * 3 + 0] - m[2 * 3 + 0] * m[1 * 3 +
2]) * detinv;
- mdst[1 * 3 + 1] = (m[2 * 3 + 2] * m[0 * 3 + 0] - m[2 * 3 + 0] * m[0 * 3 +
2]) * detinv;
- mdst[1 * 3 + 2] = -(m[1 * 3 + 2] * m[0 * 3 + 0] - m[1 * 3 + 0] * m[0 * 3 +
2]) * detinv;
- mdst[2 * 3 + 0] = (m[2 * 3 + 1] * m[1 * 3 + 0] - m[2 * 3 + 0] * m[1 * 3 +
1]) * detinv;
- mdst[2 * 3 + 1] = -(m[2 * 3 + 1] * m[0 * 3 + 0] - m[2 * 3 + 0] * m[0 * 3 +
1]) * detinv;
- mdst[2 * 3 + 2] = (m[1 * 3 + 1] * m[0 * 3 + 0] - m[1 * 3 + 0] * m[0 * 3 +
1]) * detinv;
+ mdst[0 * 3 + 0] = (m[2 * 3 + 2] * m[1 * 3 + 1] - m[2 * 3 + 1] * m[1 * 3 +
2]) *
+ detinv;
+ mdst[0 * 3 + 1] = -(m[2 * 3 + 2] * m[0 * 3 + 1] - m[2 * 3 + 1] * m[0 * 3 +
2]) *
+ detinv;
+ mdst[0 * 3 + 2] = (m[1 * 3 + 2] * m[0 * 3 + 1] - m[1 * 3 + 1] * m[0 * 3 +
2]) *
+ detinv;
+ mdst[1 * 3 + 0] = -(m[2 * 3 + 2] * m[1 * 3 + 0] - m[2 * 3 + 0] * m[1 * 3 +
2]) *
+ detinv;
+ mdst[1 * 3 + 1] = (m[2 * 3 + 2] * m[0 * 3 + 0] - m[2 * 3 + 0] * m[0 * 3 +
2]) *
+ detinv;
+ mdst[1 * 3 + 2] = -(m[1 * 3 + 2] * m[0 * 3 + 0] - m[1 * 3 + 0] * m[0 * 3 +
2]) *
+ detinv;
+ mdst[2 * 3 + 0] = (m[2 * 3 + 1] * m[1 * 3 + 0] - m[2 * 3 + 0] * m[1 * 3 +
1]) *
+ detinv;
+ mdst[2 * 3 + 1] = -(m[2 * 3 + 1] * m[0 * 3 + 0] - m[2 * 3 + 0] * m[0 * 3 +
1]) *
+ detinv;
+ mdst[2 * 3 + 2] = (m[1 * 3 + 1] * m[0 * 3 + 0] - m[1 * 3 + 0] * m[0 * 3 +
1]) *
+ detinv;
return;
}
@@ -383,7 +402,8 @@
v[2] = vres[2];
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Vector : %f %f %f : %f %f %f\n", (double)vector[0],
(double)vector[1], (double)vector[2], (double)v[0], (double)v[1], (double)v[2]);
+ printf(" Vector : %f %f %f : %f %f %f\n", (double)vector[0],
+ (double)vector[1], (double)vector[2], (double)v[0], (double)v[1],
(double)v[2]);
#endif
return 1;
@@ -406,12 +426,17 @@
}
-static void mathQuadricAddStoreQuadric(mathQuadric *qdst, mathQuadric *q0,
mathQuadric *q1)
+static void mathQuadricAddStoreQuadric(mathQuadric *qdst, mathQuadric *q0,
+ mathQuadric *q1)
{
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" QAdd Sr0 %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q0->area, (double)q0->a2, (double)q0->ab, (double)q0->ac,
(double)q0->ad, (double)q0->b2, (double)q0->bc, (double)q0->bd, (double)q0->c2,
(double)q0->cd, (double)q0->d2);
- printf(" QAdd Sr1 %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q1->area, (double)q1->a2, (double)q1->ab, (double)q1->ac,
(double)q1->ad, (double)q1->b2, (double)q1->bc, (double)q1->bd, (double)q1->c2,
(double)q1->cd, (double)q1->d2);
+ printf(" QAdd Sr0 %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q0->area,
+ (double)q0->a2, (double)q0->ab, (double)q0->ac, (double)q0->ad,
(double)q0->b2,
+ (double)q0->bc, (double)q0->bd, (double)q0->c2, (double)q0->cd,
(double)q0->d2);
+ printf(" QAdd Sr1 %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q1->area,
+ (double)q1->a2, (double)q1->ab, (double)q1->ac, (double)q1->ad,
(double)q1->b2,
+ (double)q1->bc, (double)q1->bd, (double)q1->c2, (double)q1->cd,
(double)q1->d2);
#endif
qdst->area = q0->area + q1->area;
@@ -427,7 +452,10 @@
qdst->d2 = q0->d2 + q1->d2;
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" QSum %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area, (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad, (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2, (double)qdst->cd, (double)qdst->d2);
+ printf(" QSum %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area,
+ (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad,
+ (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2,
+ (double)qdst->cd, (double)qdst->d2);
#endif
return;
@@ -437,8 +465,13 @@
{
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" QAdd Src %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q->area, (double)q->a2, (double)q->ab, (double)q->ac, (double)q->ad,
(double)q->b2, (double)q->bc, (double)q->bd, (double)q->c2, (double)q->cd,
(double)q->d2);
- printf(" QAdd Dst %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area, (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad, (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2, (double)qdst->cd, (double)qdst->d2);
+ printf(" QAdd Src %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)q->area,
+ (double)q->a2, (double)q->ab, (double)q->ac, (double)q->ad,
(double)q->b2,
+ (double)q->bc, (double)q->bd, (double)q->c2, (double)q->cd,
(double)q->d2);
+ printf(" QAdd Dst %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area,
+ (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad,
+ (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2,
+ (double)qdst->cd, (double)qdst->d2);
#endif
qdst->area += q->area;
@@ -454,7 +487,10 @@
qdst->d2 += q->d2;
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" QSum %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area, (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad, (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2, (double)qdst->cd, (double)qdst->d2);
+ printf(" QSum %f ; %f %f %f %f %f %f %f %f %f %f\n",
(double)qdst->area,
+ (double)qdst->a2, (double)qdst->ab, (double)qdst->ac,
(double)qdst->ad,
+ (double)qdst->b2, (double)qdst->bc, (double)qdst->bd,
(double)qdst->c2,
+ (double)qdst->cd, (double)qdst->d2);
#endif
return;
@@ -470,9 +506,12 @@
vh[1] = v[1];
vh[2] = v[2];
- d = vh[0] * vh[0] * (mdqfhigh)q->a2 + vh[1] * vh[1] * (mdqfhigh)q->b2 +
vh[2] * vh[2] * (mdqfhigh)q->c2;
- d += 2.0 * (vh[0] * vh[1] * (mdqfhigh)q->ab + vh[0] * vh[2] *
(mdqfhigh)q->ac + vh[1] * vh[2] * (mdqfhigh)q->bc);
- d += 2.0 * (vh[0] * (mdqfhigh)q->ad + vh[1] * (mdqfhigh)q->bd + vh[2] *
(mdqfhigh)q->cd);
+ d = vh[0] * vh[0] * (mdqfhigh)q->a2 + vh[1] * vh[1] * (mdqfhigh)q->b2 +
vh[2] *
+ vh[2] * (mdqfhigh)q->c2;
+ d += 2.0 * (vh[0] * vh[1] * (mdqfhigh)q->ab + vh[0] * vh[2] *
+ (mdqfhigh)q->ac + vh[1] * vh[2] * (mdqfhigh)q->bc);
+ d += 2.0 * (vh[0] * (mdqfhigh)q->ad + vh[1] * (mdqfhigh)q->bd + vh[2] *
+ (mdqfhigh)q->cd);
d += q->d2;
#else
volatile mdqf d;
@@ -482,13 +521,17 @@
vd[2] = v[2];
d = vd[0] * vd[0] * q->a2 + vd[1] * vd[1] * q->b2 + vd[2] * vd[2] * q->c2;
- d += 2.0 * (vd[0] * vd[1] * q->ab + vd[0] * vd[2] * q->ac + vd[1] * vd[2]
* q->bc);
+ d += 2.0 * (vd[0] * vd[1] * q->ab + vd[0] * vd[2] * q->ac + vd[1] * vd[2] *
+ q->bc);
d += 2.0 * (vd[0] * q->ad + vd[1] * q->bd + vd[2] * q->cd);
d += q->d2;
#endif
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Q Eval %f ; %f %f %f %f %f %f %f %f %f %f : %.12f\n",
(double)q->area, (double)q->a2, (double)q->ab, (double)q->ac, (double)q->ad,
(double)q->b2, (double)q->bc, (double)q->bd, (double)q->c2, (double)q->cd,
(double)q->d2, (double)d);
+ printf(" Q Eval %f ; %f %f %f %f %f %f %f %f %f %f : %.12f\n",
+ (double)q->area, (double)q->a2, (double)q->ab, (double)q->ac,
(double)q->ad,
+ (double)q->b2, (double)q->bc, (double)q->bd, (double)q->c2,
(double)q->cd,
+ (double)q->d2, (double)d);
#endif
return (mdf)d;
@@ -674,7 +717,8 @@
void *edgehashtable;
/* Collapse penalty function */
- mdf(*collapsepenalty)(mdf *newpoint, mdf *oldpoint, mdf *leftpoint, mdf
*rightpoint, int *denyflag, mdf compactnesstarget);
+ mdf(*collapsepenalty)(mdf *newpoint, mdf *oldpoint, mdf *leftpoint,
+ mdf *rightpoint, int *denyflag, mdf
compactnesstarget);
/* Custom vertex attributes besides point position */
int attribcount;
@@ -781,7 +825,7 @@
static void mdVertexFloatToNative(mdf *dst, void *src)
{
- float *s = (mdf *)src;
+ float *s = (float *)src;
dst[0] = s[0];
dst[1] = s[1];
dst[2] = s[2];
@@ -799,7 +843,7 @@
static void mdVertexNativeToFloat(void *dst, mdf *src)
{
- float *d = (mdf *)dst;
+ float *d = (float *)dst;
d[0] = src[0];
d[1] = src[1];
d[2] = src[2];
@@ -816,7 +860,8 @@
}
-static void mdTriangleComputeQuadric(mdMesh *mesh, mdTriangle *tri,
mathQuadric *q)
+static void mdTriangleComputeQuadric(mdMesh *mesh, mdTriangle *tri,
+ mathQuadric *q)
{
mdf area, norm, norminv, vecta[3], vectb[3], plane[4];
mdVertex *vertex0, *vertex1, *vertex2;
@@ -831,7 +876,7 @@
norm = mdfsqrt(M3D_VectorDotProduct(plane, plane));
- if (ZERO(norm)) {
+ if (!ZERO(norm)) {
area = 0.5 * norm;
#ifdef MD_CONFIG_AREA_QUADRICS
norminv = 0.5;
@@ -851,7 +896,8 @@
}
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Plane %f %f %f %f : Area %f\n", plane[0], plane[1], plane[2],
plane[3], area);
+ printf(" Plane %f %f %f %f : Area %f\n", plane[0], plane[1], plane[2],
+ plane[3], area);
#endif
mathQuadricInit(q, plane[0], plane[1], plane[2], plane[3], area);
@@ -878,14 +924,16 @@
bestcost = mathQuadricEvaluate(&q, midpoint);
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" MidCost %f %f %f : %f\n", midpoint[0], midpoint[1],
midpoint[2], bestcost);
+ printf(" MidCost %f %f %f : %f\n", midpoint[0], midpoint[1],
midpoint[2],
+ bestcost);
#endif
bestpoint = midpoint;
cost = mathQuadricEvaluate(&q, vertex0->point);
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Vx0Cost %f %f %f : %f\n", vertex0->point[0],
vertex0->point[1], vertex0->point[2], cost);
+ printf(" Vx0Cost %f %f %f : %f\n", vertex0->point[0],
vertex0->point[1],
+ vertex0->point[2], cost);
#endif
if (cost < bestcost) {
@@ -896,7 +944,8 @@
cost = mathQuadricEvaluate(&q, vertex1->point);
#ifdef DEBUG_VERBOSE_QUADRIC
- printf(" Vx1Cost %f %f %f : %f\n", vertex1->point[0],
vertex1->point[1], vertex1->point[2], cost);
+ printf(" Vx1Cost %f %f %f : %f\n", vertex1->point[0],
vertex1->point[1],
+ vertex1->point[2], cost);
#endif
if (cost < bestcost) {
@@ -914,7 +963,8 @@
/****/
-static void mdMeshAccumulateBoundary(mdVertex *vertex0, mdVertex *vertex1,
mdVertex *vertex2)
+static void mdMeshAccumulateBoundary(mdVertex *vertex0, mdVertex *vertex1,
+ mdVertex *vertex2)
{
mdf normal[3], sideplane[4], vecta[3], vectb[3], norm, norminv, area;
mathQuadric q;
@@ -922,7 +972,8 @@
M3D_VectorSubStore(vecta, vertex1->point, vertex0->point);
M3D_VectorSubStore(vectb, vertex2->point, vertex0->point);
M3D_VectorCrossProduct(normal, vectb, vecta);
- norm = mdfsqrt(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] *
normal[2]);
+ norm = mdfsqrt(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] *
+ normal[2]);
area = 0.5 * norm;
norminv = 1.0 / norm;
M3D_VectorMulScalar(normal, norminv);
@@ -938,10 +989,12 @@
#ifdef DEBUG_VERBOSE_BOUNDARY
printf(" Area %f\n", area);
- printf(" Boundary %f %f %f %f\n", sideplane[0], sideplane[1],
sideplane[2], sideplane[3]);
+ printf(" Boundary %f %f %f %f\n", sideplane[0], sideplane[1],
sideplane[2],
+ sideplane[3]);
#endif
- mathQuadricInit(&q, sideplane[0], sideplane[1], sideplane[2],
sideplane[3], area);
+ mathQuadricInit(&q, sideplane[0], sideplane[1], sideplane[2], sideplane[3],
+ area);
mathQuadricMul(&q, MD_BOUNDARY_WEIGHT);
/*
mathQuadricMul( &q, area * MD_BOUNDARY_WEIGHT );
@@ -1056,7 +1109,8 @@
NULL
};
-static int mdMeshHashInit(mdMesh *mesh, size_t trianglecount, mdf
hashextrabits, uint32_t lockpageshift, size_t maxmemorysize)
+static int mdMeshHashInit(mdMesh *mesh, size_t trianglecount, mdf
hashextrabits,
+ uint32_t lockpageshift, size_t maxmemorysize)
{
size_t edgecount, hashmemsize, meshmemsize, totalmemorysize;
uint32_t hashbits, hashbitsmin, hashbitsmax;
@@ -1087,7 +1141,8 @@
else if (lockpageshift > 16)
lockpageshift = 16;
- meshmemsize = (mesh->tricount * sizeof(mdTriangle)) + (mesh->vertexcount *
sizeof(mdVertex));
+ meshmemsize = (mesh->tricount * sizeof(mdTriangle)) + (mesh->vertexcount *
+ sizeof(mdVertex));
for (; ; hashbits--) {
if (hashbits < hashbitsmin)
@@ -1101,8 +1156,10 @@
#ifdef DEBUG_VERBOSE_MEMORY
printf(" Hash bits : %d (%d)\n", hashbits, hashbitsmin);
- printf(" Estimated Memory Requirements : %lld bytes (%lld MB)\n",
(long long)totalmemorysize, (long long)totalmemorysize >> 20);
- printf(" Memory Hard Limit : %lld bytes (%lld MB)\n", (long
long)maxmemorysize, (long long)maxmemorysize >> 20);
+ printf(" Estimated Memory Requirements : %lld bytes (%lld MB)\n",
+ (long long)totalmemorysize, (long long)totalmemorysize >> 20);
+ printf(" Memory Hard Limit : %lld bytes (%lld MB)\n",
+ (long long)maxmemorysize, (long long)maxmemorysize >> 20);
#endif
if (totalmemorysize > maxmemorysize)
@@ -1114,7 +1171,8 @@
break;
}
- mmHashInit(mesh->edgehashtable, &mdEdgeHashEdge, sizeof(mdEdge), hashbits,
lockpageshift, MM_HASH_FLAGS_NO_COUNT);
+ mmHashInit(mesh->edgehashtable, &mdEdgeHashEdge, sizeof(mdEdge), hashbits,
+ lockpageshift, MM_HASH_FLAGS_NO_COUNT);
return 1;
}
@@ -1215,7 +1273,8 @@
return;
}
-static void mdUpdateBufferAdd(mdUpdateBuffer *updatebuffer, mdOp *op, int
orflags)
+static void mdUpdateBufferAdd(mdUpdateBuffer *updatebuffer, mdOp *op,
+ int orflags)
{
int32_t flags;
@@ -1231,7 +1290,8 @@
return;
}
- if (mmAtomicCmpReplace32(&op->flags, flags, flags | orflags |
MD_OP_FLAGS_UPDATE_QUEUED | MD_OP_FLAGS_UPDATE_NEEDED))
+ if (mmAtomicCmpReplace32(&op->flags, flags,
+ flags | orflags | MD_OP_FLAGS_UPDATE_QUEUED |
MD_OP_FLAGS_UPDATE_NEEDED))
break;
}
@@ -1240,7 +1300,8 @@
if (updatebuffer->opcount >= updatebuffer->opalloc) {
updatebuffer->opalloc <<= 1;
- updatebuffer->opbuffer = (void **)realloc(updatebuffer->opbuffer,
updatebuffer->opalloc * sizeof(mdOp *));
+ updatebuffer->opbuffer = (void **)realloc(updatebuffer->opbuffer,
+ updatebuffer->opalloc * sizeof(mdOp *));
}
updatebuffer->opbuffer[ updatebuffer->opcount++ ] = op;
@@ -1266,7 +1327,8 @@
if (updatebuffer->opcount >= updatebuffer->opalloc) {
updatebuffer->opalloc <<= 1;
- updatebuffer->opbuffer = realloc(updatebuffer->opbuffer,
updatebuffer->opalloc * sizeof(mdOp *));
+ updatebuffer->opbuffer = realloc(updatebuffer->opbuffer,
+ updatebuffer->opalloc * sizeof(mdOp
*));
}
updatebuffer->opbuffer[ updatebuffer->opcount++ ] = op;
@@ -1283,10 +1345,12 @@
#define MD_COMPACTNESS_NORMALIZATION_FACTOR (0.5*4.0*1.732050808)
-static mdf mdEdgeCollapsePenaltyTriangle(mdf *newpoint, mdf *oldpoint, mdf
*leftpoint, mdf *rightpoint, int *denyflag, mdf compactnesstarget)
+static mdf mdEdgeCollapsePenaltyTriangle(mdf *newpoint, mdf *oldpoint,
+ mdf *leftpoint, mdf *rightpoint, int *denyflag, mdf compactnesstarget)
{
mdf penalty, compactness, oldcompactness, newcompactness, vecta2, norm;
- mdf vecta[3], oldvectb[3], oldvectc[3], newvectb[3], newvectc[3],
oldnormal[3], newnormal[3];
+ mdf vecta[3], oldvectb[3], oldvectc[3], newvectb[3], newvectc[3],
oldnormal[3],
+ newnormal[3];
/* Normal of old triangle */
M3D_VectorSubStore(vecta, rightpoint, leftpoint);
@@ -1307,13 +1371,18 @@
penalty = 0.0;
vecta2 = M3D_VectorDotProduct(vecta, vecta);
M3D_VectorSubStore(newvectc, newpoint, rightpoint);
- newcompactness = MD_COMPACTNESS_NORMALIZATION_FACTOR *
mdfsqrt(M3D_VectorDotProduct(newnormal, newnormal));
- norm = vecta2 + M3D_VectorDotProduct(newvectb, newvectb) +
M3D_VectorDotProduct(newvectc, newvectc);
+ newcompactness = MD_COMPACTNESS_NORMALIZATION_FACTOR * mdfsqrt(
+ M3D_VectorDotProduct(newnormal, newnormal));
+ norm = vecta2 + M3D_VectorDotProduct(newvectb,
+ newvectb) +
M3D_VectorDotProduct(newvectc, newvectc);
if (newcompactness < (compactnesstarget * norm)) {
newcompactness /= norm;
M3D_VectorSubStore(oldvectc, oldpoint, rightpoint);
- oldcompactness = (MD_COMPACTNESS_NORMALIZATION_FACTOR *
mdfsqrt(M3D_VectorDotProduct(oldnormal, oldnormal))) / (vecta2 +
M3D_VectorDotProduct(oldvectb, oldvectb) + M3D_VectorDotProduct(oldvectc,
oldvectc));
+ oldcompactness = (MD_COMPACTNESS_NORMALIZATION_FACTOR * mdfsqrt(
+ M3D_VectorDotProduct(oldnormal,
+ oldnormal))) / (vecta2 +
M3D_VectorDotProduct(oldvectb,
+ oldvectb) +
M3D_VectorDotProduct(oldvectc, oldvectc));
compactness = FMIN(compactnesstarget, oldcompactness) - newcompactness;
if (compactness > 0.0)
@@ -1324,13 +1393,16 @@
}
-static mdf mdEdgeCollapsePenaltyAll(mdMesh *mesh, mdThreadData *UNUSED(tdata),
mdi *trireflist, mdi trirefcount, mdi pivotindex, mdi skipindex, mdf
*collapsepoint, int *denyflag)
+static mdf mdEdgeCollapsePenaltyAll(mdMesh *mesh, mdThreadData *UNUSED(tdata),
+ mdi *trireflist, mdi trirefcount, mdi
pivotindex, mdi skipindex,
+ mdf *collapsepoint, int *denyflag)
{
int vindex;
mdf penalty;
mdi triindex;
mdTriangle *tri;
- mdf(*collapsepenalty)(mdf * newpoint, mdf * oldpoint, mdf * leftpoint, mdf
* rightpoint, int *denyflag, mdf compactnesstarget);
+ mdf(*collapsepenalty)(mdf * newpoint, mdf * oldpoint, mdf * leftpoint,
+ mdf * rightpoint, int *denyflag, mdf
compactnesstarget);
collapsepenalty = mesh->collapsepenalty;
penalty = 0.0;
@@ -1346,7 +1418,8 @@
continue;
#ifdef DEBUG_VERBOSE_PENALTY
- printf(" Penalty Tri %d,%d,%d ( Pivot %d ; Skip %d )\n", tri->v[0],
tri->v[1], tri->v[2], pivotindex, skipindex);
+ printf(" Penalty Tri %d,%d,%d ( Pivot %d ; Skip %d )\n", tri->v[0],
+ tri->v[1], tri->v[2], pivotindex, skipindex);
#endif
#ifdef DEBUG_DEBUG
@@ -1360,17 +1433,23 @@
if ((tri->v[1] == skipindex) || (tri->v[2] == skipindex))
continue;
- penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[0] ].point, mesh->vertexlist[ tri->v[2] ].point, mesh->vertexlist[
tri->v[1] ].point, denyflag, mesh->compactnesstarget);
+ penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[0] ].point,
+ mesh->vertexlist[ tri->v[2] ].point,
mesh->vertexlist[ tri->v[1] ].point,
+ denyflag, mesh->compactnesstarget);
} else if (tri->v[1] == pivotindex) {
if ((tri->v[2] == skipindex) || (tri->v[0] == skipindex))
continue;
- penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[1] ].point, mesh->vertexlist[ tri->v[0] ].point, mesh->vertexlist[
tri->v[2] ].point, denyflag, mesh->compactnesstarget);
+ penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[1] ].point,
+ mesh->vertexlist[ tri->v[0] ].point,
mesh->vertexlist[ tri->v[2] ].point,
+ denyflag, mesh->compactnesstarget);
} else if (tri->v[2] == pivotindex) {
if ((tri->v[0] == skipindex) || (tri->v[1] == skipindex))
continue;
- penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[2] ].point, mesh->vertexlist[ tri->v[1] ].point, mesh->vertexlist[
tri->v[0] ].point, denyflag, mesh->compactnesstarget);
+ penalty += collapsepenalty(collapsepoint, mesh->vertexlist[
tri->v[2] ].point,
+ mesh->vertexlist[ tri->v[1] ].point,
mesh->vertexlist[ tri->v[0] ].point,
+ denyflag, mesh->compactnesstarget);
} else {
#ifdef DEBUG_DEBUG
bu_bomb("SHOULD NOT HAPPEN");
@@ -1395,7 +1474,8 @@
}
-static mdf mdEdgeCollapsePenalty(mdMesh *mesh, mdThreadData *tdata, mdi v0,
mdi v1, mdf *collapsepoint, int *denyflag)
+static mdf mdEdgeCollapsePenalty(mdMesh *mesh, mdThreadData *tdata, mdi v0,
+ mdi v1, mdf *collapsepoint, int *denyflag)
{
mdf penalty, collapsearea, penaltyfactor;
mdVertex *vertex0, *vertex1;
@@ -1404,18 +1484,24 @@
vertex1 = &mesh->vertexlist[ v1 ];
collapsearea = vertex0->quadric.area + vertex1->quadric.area;
- penaltyfactor = collapsearea * collapsearea / (vertex0->trirefcount +
vertex1->trirefcount);
+ penaltyfactor = collapsearea * collapsearea / (vertex0->trirefcount +
+ vertex1->trirefcount);
#ifdef DEBUG_VERBOSE_PENALTY
printf(" Compute Penalty Edge %d,%d\n", v0, v1);
#endif
*denyflag = 0;
- penalty = mdEdgeCollapsePenaltyAll(mesh, tdata, &mesh->trireflist[
vertex0->trirefbase ], vertex0->trirefcount, v0, v1, collapsepoint, denyflag);
- penalty += mdEdgeCollapsePenaltyAll(mesh, tdata, &mesh->trireflist[
vertex1->trirefbase ], vertex1->trirefcount, v1, v0, collapsepoint, denyflag);
+ penalty = mdEdgeCollapsePenaltyAll(mesh, tdata,
+ &mesh->trireflist[ vertex0->trirefbase
], vertex0->trirefcount, v0, v1,
+ collapsepoint, denyflag);
+ penalty += mdEdgeCollapsePenaltyAll(mesh, tdata,
+ &mesh->trireflist[ vertex1->trirefbase
], vertex1->trirefcount, v1, v0,
+ collapsepoint, denyflag);
#ifdef DEBUG_VERBOSE_PENALTY
- printf(" Penalty Total : %f * %f -> %f\n", penalty, penaltyfactor,
penalty * penaltyfactor);
+ printf(" Penalty Total : %f * %f -> %f\n", penalty, penaltyfactor,
+ penalty * penaltyfactor);
#endif
penalty *= penaltyfactor;
@@ -1454,11 +1540,13 @@
op->updatebuffer = tdata->updatebuffer;
op->v0 = v0;
op->v1 = v1;
- op->value = mdEdgeSolvePoint(&mesh->vertexlist[v0], &mesh->vertexlist[v1],
op->collapsepoint);
+ op->value = mdEdgeSolvePoint(&mesh->vertexlist[v0], &mesh->vertexlist[v1],
+ op->collapsepoint);
#ifdef MD_CONFIG_SSE_SUPPORT
op->collapsepoint[3] = 0.0;
#endif
- op->penalty = mdEdgeCollapsePenalty(mesh, tdata, v0, v1,
op->collapsepoint, &denyflag);
+ op->penalty = mdEdgeCollapsePenalty(mesh, tdata, v0, v1, op->collapsepoint,
+ &denyflag);
op->collapsecost = op->value + op->penalty;
if ((denyflag) || (op->collapsecost > mesh->maxcollapsecost))
@@ -1477,17 +1565,21 @@
edge.v[0] = v0;
edge.v[1] = v1;
- if (mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
mdMeshEdgeOpCallback, op, 0) != MM_HASH_SUCCESS)
+ if (mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ mdMeshEdgeOpCallback, op, 0) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Solve Edge %d,%d ; Point %f %f %f ; Value %f ; Penalty %f ; Cost
%f\n", (int)op->v0, (int)op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2], op->value, op->penalty, op->collapsecost);
+ printf(" Solve Edge %d,%d ; Point %f %f %f ; Value %f ; Penalty %f ; Cost
%f\n",
+ (int)op->v0, (int)op->v1, op->collapsepoint[0], op->collapsepoint[1],
+ op->collapsepoint[2], op->value, op->penalty, op->collapsecost);
#endif
return;
}
-static void mdMeshPopulateOpList(mdMesh *mesh, mdThreadData *tdata, mdi
tribase, mdi tricount)
+static void mdMeshPopulateOpList(mdMesh *mesh, mdThreadData *tdata, mdi
tribase,
+ mdi tricount)
{
mdTriangle *tri, *tristart, *triend;
long populatecount;
@@ -1523,7 +1615,8 @@
/* Merge vertex attributes of v0 and v1, write to v0 */
-static void mdEdgeCollapseAttrib(mdMesh *mesh, mdThreadData *UNUSED(tdata),
mdi v0, mdi v1, mdf *collapsepoint)
+static void mdEdgeCollapseAttrib(mdMesh *mesh, mdThreadData *UNUSED(tdata),
+ mdi v0, mdi v1, mdf *collapsepoint)
{
int vindex;
mdVertex *vertex0, *vertex1;
@@ -1569,19 +1662,20 @@
attr0pf = (float *)attr0p;
attr1pf = (float *)attr1p;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
- attr0pf[vindex] = (attr0pf[vindex] * (float)weight0) +
(attr1pf[vindex] * (float)weight1);
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
+ attr0pf[vindex] = (attr0pf[vindex] * (float)weight0) +
(attr1pf[vindex] *
+ (float)weight1);
if (attrib->flags & MD_ATTRIB_FLAGS_NORMALIZE) {
sumf = 0.0;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
sumf += attr0pf[vindex] * attr0pf[vindex];
if (!ZERO(sumf)) {
suminvf = 1.0 / sumf;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
attr0pf[vindex] *= suminvf;
}
}
@@ -1589,19 +1683,20 @@
attr0pd = (double *)attr0p;
attr1pd = (double *)attr1p;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
- attr0pd[vindex] = (attr0pd[vindex] * (double)weight0) +
(attr1pd[vindex] * (double)weight1);
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
+ attr0pd[vindex] = (attr0pd[vindex] * (double)weight0) +
(attr1pd[vindex] *
+ (double)weight1);
if (attrib->flags & MD_ATTRIB_FLAGS_NORMALIZE) {
sumd = 0.0;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
sumd += attr0pd[vindex] * attr0pd[vindex];
if (!ZERO(sumd)) {
suminvd = 1.0 / sumd;
- for (vindex = 0 ; vindex < (mdi)attrib->count ; vindex++)
+ for (vindex = 0 ; vindex < (int)attrib->count ; vindex++)
attr0pd[vindex] *= suminvd;
}
}
@@ -1613,7 +1708,8 @@
/* Delete triangle and return outer vertex */
-static mdi mdEdgeCollapseDeleteTriangle(mdMesh *mesh, mdThreadData *tdata, mdi
v0, mdi v1, int *retdelflags)
+static mdi mdEdgeCollapseDeleteTriangle(mdMesh *mesh, mdThreadData *tdata,
+ mdi v0, mdi v1, int *retdelflags)
{
int delflags = 0;
mdi outer = 0;
@@ -1627,13 +1723,15 @@
edge.v[0] = v0;
edge.v[1] = v1;
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge, 1)
!= MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
return -1;
op = (mdOp *)edge.op;
if (op)
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, MD_OP_FLAGS_DELETION_PENDING);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
MD_OP_FLAGS_DELETION_PENDING);
tri = &mesh->trilist[ edge.triindex ];
@@ -1645,39 +1743,45 @@
edge.v[0] = tri->v[0];
edge.v[1] = tri->v[1];
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
op = (mdOp *)edge.op;
if (op)
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, MD_OP_FLAGS_DELETION_PENDING);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
MD_OP_FLAGS_DELETION_PENDING);
}
if (tri->v[1] != v0) {
edge.v[0] = tri->v[1];
edge.v[1] = tri->v[2];
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
op = (mdOp *)edge.op;
if (op)
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, MD_OP_FLAGS_DELETION_PENDING);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
MD_OP_FLAGS_DELETION_PENDING);
}
if (tri->v[2] != v0) {
edge.v[0] = tri->v[2];
edge.v[1] = tri->v[0];
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
op = (mdOp *)edge.op;
if (op)
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, MD_OP_FLAGS_DELETION_PENDING);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
MD_OP_FLAGS_DELETION_PENDING);
}
/* Determine outer vertex */
@@ -1721,33 +1825,38 @@
}
-static void mdEdgeCollapseUpdateTriangle(mdMesh *mesh, mdThreadData *tdata,
mdTriangle *tri, mdi newv, int pivot, int left, int right)
+static void mdEdgeCollapseUpdateTriangle(mdMesh *mesh, mdThreadData *tdata,
+ mdTriangle *tri, mdi newv, int pivot, int left, int right)
{
mdEdge edge;
mdOp *op;
- /* 2012-10-22 ch3: vertex set but never used, so commented */
- /*mdVertex *vertex;*/
+ /* 2012-10-22 ch3: vertex set but never used, so commented
+ /mdVertex *vertex; */
- memset(&edge, 0, sizeof(mdEdge)); /* DRH added so it's initialized */
+ memset(&edge, 0, sizeof(mdEdge)); /*DRH added so it's initialized*/
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Collapse Update %d : Tri %d,%d,%d\n", newv, tri->v[pivot],
tri->v[right], tri->v[left]);
+ printf(" Collapse Update %d : Tri %d,%d,%d\n", newv, tri->v[pivot],
+ tri->v[right], tri->v[left]);
#endif
- /* vertex = &mesh->vertexlist[ tri->v[right] ]; */
+ /*vertex = &mesh->vertexlist[ tri->v[right] ]; */
edge.v[0] = tri->v[pivot];
edge.v[1] = tri->v[right];
if (edge.v[0] == newv) {
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) !=
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
} else {
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
edge.v[0] = newv;
- if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge, 1)
!= MM_HASH_SUCCESS)
+ if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
}
@@ -1755,27 +1864,36 @@
if (op) {
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Update Edge %d,%d Before ; Point %f %f %f ; Cost %f\n",
op->v0, op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2], op->collapsecost);
+ printf(" Update Edge %d,%d Before ; Point %f %f %f ; Cost %f\n",
op->v0,
+ op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2],
+ op->collapsecost);
#endif
#ifdef MD_CONFIG_DELAYED_OP_REDIRECT
- op->value = mdEdgeSolvePoint(&mesh->vertexlist[edge.v[0]],
&mesh->vertexlist[edge.v[1]], op->collapsepoint);
+ op->value = mdEdgeSolvePoint(&mesh->vertexlist[edge.v[0]],
+ &mesh->vertexlist[edge.v[1]],
op->collapsepoint);
#ifdef MD_CONFIG_SSE_SUPPORT
op->collapsepoint[3] = 0.0;
#endif
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, 0x0);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
0x0);
#else
op->v0 = newv;
- op->value = mdEdgeSolvePoint(&mesh->vertexlist[op->v0],
&mesh->vertexlist[op->v1], op->collapsepoint);
+ op->value = mdEdgeSolvePoint(&mesh->vertexlist[op->v0],
+ &mesh->vertexlist[op->v1],
op->collapsepoint);
#ifdef MD_CONFIG_SSE_SUPPORT
op->collapsepoint[3] = 0.0;
#endif
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, 0x0);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
0x0);
#endif
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Update Edge %d,%d After ; Point %f %f %f ; Cost %f\n",
op->v0, op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2], op->collapsecost);
- printf(" Edge %d,%d ; Value %f ; Penalty %f ; Cost %f\n", op->v0,
op->v1, op->value, op->penalty, op->collapsecost);
+ printf(" Update Edge %d,%d After ; Point %f %f %f ; Cost %f\n",
op->v0,
+ op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2],
+ op->collapsecost);
+ printf(" Edge %d,%d ; Value %f ; Penalty %f ; Cost %f\n", op->v0,
op->v1,
+ op->value, op->penalty, op->collapsecost);
#endif
}
@@ -1784,15 +1902,18 @@
edge.v[1] = tri->v[pivot];
if (edge.v[1] == newv) {
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) !=
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
} else {
- if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockDeleteEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
edge.v[1] = newv;
- if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge, 1)
!= MM_HASH_SUCCESS)
+ if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
}
@@ -1800,27 +1921,36 @@
if (op) {
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Update Edge %d,%d Before ; Point %f %f %f ; Cost %f\n",
op->v0, op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2], op->collapsecost);
+ printf(" Update Edge %d,%d Before ; Point %f %f %f ; Cost %f\n",
op->v0,
+ op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2],
+ op->collapsecost);
#endif
#ifdef MD_CONFIG_DELAYED_OP_REDIRECT
- op->value = mdEdgeSolvePoint(&mesh->vertexlist[edge.v[0]],
&mesh->vertexlist[edge.v[1]], op->collapsepoint);
+ op->value = mdEdgeSolvePoint(&mesh->vertexlist[edge.v[0]],
+ &mesh->vertexlist[edge.v[1]],
op->collapsepoint);
#ifdef MD_CONFIG_SSE_SUPPORT
op->collapsepoint[3] = 0.0;
#endif
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, 0x0);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
0x0);
#else
op->v1 = newv;
- op->value = mdEdgeSolvePoint(&mesh->vertexlist[op->v0],
&mesh->vertexlist[op->v1], op->collapsepoint);
+ op->value = mdEdgeSolvePoint(&mesh->vertexlist[op->v0],
+ &mesh->vertexlist[op->v1],
op->collapsepoint);
#ifdef MD_CONFIG_SSE_SUPPORT
op->collapsepoint[3] = 0.0;
#endif
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, 0x0);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op,
0x0);
#endif
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Update Edge %d,%d After ; Point %f %f %f ; Cost %f\n",
op->v0, op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2], op->collapsecost);
- printf(" Edge %d,%d ; Value %f ; Penalty %f ; Cost %f\n", op->v0,
op->v1, op->value, op->penalty, op->collapsecost);
+ printf(" Update Edge %d,%d After ; Point %f %f %f ; Cost %f\n",
op->v0,
+ op->v1, op->collapsepoint[0], op->collapsepoint[1],
op->collapsepoint[2],
+ op->collapsecost);
+ printf(" Edge %d,%d ; Value %f ; Penalty %f ; Cost %f\n", op->v0,
op->v1,
+ op->value, op->penalty, op->collapsecost);
#endif
}
@@ -1835,7 +1965,8 @@
- Update cost of collapse for other edges of triangles
- Build up the updated list of triangle references for new vertex
*/
-static mdi *mdEdgeCollapseUpdateAll(mdMesh *mesh, mdThreadData *tdata, mdi
*trireflist, mdi trirefcount, mdi oldv, mdi newv, mdi *trirefstore)
+static mdi *mdEdgeCollapseUpdateAll(mdMesh *mesh, mdThreadData *tdata,
+ mdi *trireflist, mdi trirefcount, mdi oldv,
mdi newv, mdi *trirefstore)
{
int vindex;
mdi triindex;
@@ -1869,16 +2000,18 @@
}
-static void mdVertexInvalidateTri(mdMesh *mesh, mdThreadData *tdata, mdi v0,
mdi v1)
+static void mdVertexInvalidateTri(mdMesh *mesh, mdThreadData *tdata, mdi v0,
+ mdi v1)
{
mdEdge edge;
mdOp *op;
- memset(&edge, 0, sizeof(mdEdge)); /* DRH added so it's initialized */
+ memset(&edge, 0, sizeof(mdEdge)); /*DRH added so it's initialized*/
edge.v[0] = v0;
edge.v[1] = v1;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) !=
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
op = (mdOp *)edge.op;
@@ -1886,12 +2019,14 @@
if (!(op))
return;
- mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
mesh->updatebuffershift ], op, 0x0);
+ mdUpdateBufferAdd(&op->updatebuffer[ tdata->threadid >>
+ mesh->updatebuffershift ], op, 0x0);
return;
}
-static void mdVertexInvalidate(mdMesh *mesh, mdThreadData *tdata, mdi
vertexindex)
+static void mdVertexInvalidate(mdMesh *mesh, mdThreadData *tdata,
+ mdi vertexindex)
{
mdi vindex, triindex, trirefcount;
mdi *trireflist;
@@ -1926,7 +2061,8 @@
return;
}
-static void mdVertexInvalidateAll(mdMesh *mesh, mdThreadData *tdata, mdi
*trireflist, mdi trirefcount, mdi pivotindex)
+static void mdVertexInvalidateAll(mdMesh *mesh, mdThreadData *tdata,
+ mdi *trireflist, mdi trirefcount, mdi
pivotindex)
{
int vindex;
mdi triindex;
@@ -1956,7 +2092,8 @@
}
-static void mdEdgeCollapseLinkOuter(mdMesh *mesh, mdThreadData *tdata, mdi
newv, mdi outer)
+static void mdEdgeCollapseLinkOuter(mdMesh *mesh, mdThreadData *tdata, mdi
newv,
+ mdi outer)
{
int sideflags;
mdEdge edge;
@@ -1970,7 +2107,8 @@
edge.v[0] = newv;
edge.v[1] = outer;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) ==
MM_HASH_SUCCESS) {
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) == MM_HASH_SUCCESS) {
sideflags |= 0x1;
op = (mdOp *)edge.op;
@@ -1981,7 +2119,8 @@
edge.v[0] = outer;
edge.v[1] = newv;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) ==
MM_HASH_SUCCESS) {
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) == MM_HASH_SUCCESS) {
sideflags |= 0x2;
op = (mdOp *)edge.op;
@@ -2007,13 +2146,15 @@
edge.v[0] = v1;
edge.v[1] = v0;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) ==
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) == MM_HASH_SUCCESS)
return;
edge.v[0] = v0;
edge.v[1] = v1;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) !=
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) != MM_HASH_SUCCESS)
return;
tri = &mesh->trilist[ edge.triindex ];
@@ -2088,7 +2229,8 @@
return;
}
-void mdLockBufferUnlockAll(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer
*buffer)
+void mdLockBufferUnlockAll(mdMesh *mesh, mdThreadData *tdata,
+ mdLockBuffer *buffer)
{
int vindex;
mdVertex *vertex;
@@ -2115,7 +2257,8 @@
}
/* If it fails, release all locks */
-int mdLockBufferTryLock(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer
*buffer, mdi vertexindex)
+int mdLockBufferTryLock(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer
*buffer,
+ mdi vertexindex)
{
int32_t owner;
mdVertex *vertex;
@@ -2127,7 +2270,8 @@
if (owner == tdata->threadid)
return 1;
- if ((owner != -1) || !(mmAtomicCmpReplace32(&vertex->atomicowner, -1,
tdata->threadid))) {
+ if ((owner != -1)
+ || !(mmAtomicCmpReplace32(&vertex->atomicowner, -1, tdata->threadid))) {
mdLockBufferUnlockAll(mesh, tdata, buffer);
return 0;
}
@@ -2156,7 +2300,8 @@
}
/* If it fails, release all locks then wait for the desired lock to become
available */
-int mdLockBufferLock(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer *buffer,
mdi vertexindex)
+int mdLockBufferLock(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer *buffer,
+ mdi vertexindex)
{
int32_t owner;
mdVertex *vertex;
@@ -2168,7 +2313,8 @@
if (owner == tdata->threadid)
return 1;
- if ((owner == -1) && mmAtomicCmpReplace32(&vertex->atomicowner, -1,
tdata->threadid)) {
+ if ((owner == -1)
+ && mmAtomicCmpReplace32(&vertex->atomicowner, -1, tdata->threadid)) {
buffer->vertexlist[buffer->vertexcount++] = vertexindex;
return 1;
}
@@ -2216,7 +2362,8 @@
}
-static int mdPivotLockRefs(mdMesh *mesh, mdThreadData *tdata, mdLockBuffer
*buffer, mdi vertexindex)
+static int mdPivotLockRefs(mdMesh *mesh, mdThreadData *tdata,
+ mdLockBuffer *buffer, mdi vertexindex)
{
int vindex;
mdi triindex, iav = 0, ibv = 0, trirefcount;
@@ -2258,7 +2405,8 @@
}
-static void mdOpResolveLockEdge(mdMesh *mesh, mdThreadData *tdata,
mdLockBuffer *lockbuffer, mdOp *op)
+static void mdOpResolveLockEdge(mdMesh *mesh, mdThreadData *tdata,
+ mdLockBuffer *lockbuffer, mdOp *op)
{
int failcount, globalflag;
mdVertex *vertex0, *vertex1;
@@ -2277,7 +2425,8 @@
globalflag = 1;
}
- if (!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v0)) ||
!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v1))) {
+ if (!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v0))
+ || !(mdLockBufferLock(mesh, tdata, lockbuffer, op->v1))) {
failcount++;
continue;
}
@@ -2313,12 +2462,14 @@
return;
}
-static int mdOpResolveLockEdgeTry(mdMesh *mesh, mdThreadData *tdata,
mdLockBuffer *lockbuffer, mdOp *op)
+static int mdOpResolveLockEdgeTry(mdMesh *mesh, mdThreadData *tdata,
+ mdLockBuffer *lockbuffer, mdOp *op)
{
mdVertex *vertex0, *vertex1;
for (; ;) {
- if (!(mdLockBufferTryLock(mesh, tdata, lockbuffer, op->v0)) ||
!(mdLockBufferTryLock(mesh, tdata, lockbuffer, op->v1)))
+ if (!(mdLockBufferTryLock(mesh, tdata, lockbuffer, op->v0))
+ || !(mdLockBufferTryLock(mesh, tdata, lockbuffer, op->v1)))
return 0;
vertex0 = &mesh->vertexlist[ op->v0 ];
@@ -2340,7 +2491,8 @@
return 1;
}
-static void mdOpResolveLockFull(mdMesh *mesh, mdThreadData *tdata,
mdLockBuffer *lockbuffer, mdOp *op)
+static void mdOpResolveLockFull(mdMesh *mesh, mdThreadData *tdata,
+ mdLockBuffer *lockbuffer, mdOp *op)
{
int failcount, globalflag;
mdVertex *vertex0, *vertex1;
@@ -2359,7 +2511,8 @@
globalflag = 1;
}
- if (!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v0)) ||
!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v1))) {
+ if (!(mdLockBufferLock(mesh, tdata, lockbuffer, op->v0))
+ || !(mdLockBufferLock(mesh, tdata, lockbuffer, op->v1))) {
failcount++;
continue;
}
@@ -2373,9 +2526,11 @@
else if (vertex1->redirectindex != -1)
op->v1 = vertex1->redirectindex;
else {
- mdLockBufferResize(lockbuffer, 2 + ((vertex0->trirefcount +
vertex1->trirefcount) << 1));
+ mdLockBufferResize(lockbuffer,
+ 2 + ((vertex0->trirefcount +
vertex1->trirefcount) << 1));
- if (!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v0)) ||
!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v1))) {
+ if (!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v0))
+ || !(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v1))) {
failcount++;
continue;
}
@@ -2384,9 +2539,11 @@
}
#else
- mdLockBufferResize(lockbuffer, 2 + ((vertex0->trirefcount +
vertex1->trirefcount) << 1));
+ mdLockBufferResize(lockbuffer,
+ 2 + ((vertex0->trirefcount + vertex1->trirefcount)
<< 1));
- if (!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v0)) ||
!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v1))) {
+ if (!(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v0))
+ || !(mdPivotLockRefs(mesh, tdata, lockbuffer, op->v1))) {
failcount++;
continue;
}
@@ -2413,7 +2570,8 @@
#define MD_EDGE_COLLAPSE_TRIREF_STATIC (512)
-static void mdEdgeCollapse(mdMesh *mesh, mdThreadData *tdata, mdi v0, mdi v1,
mdf *collapsepoint)
+static void mdEdgeCollapse(mdMesh *mesh, mdThreadData *tdata, mdi v0, mdi v1,
+ mdf *collapsepoint)
{
int vindex, delflags0, delflags1;
long deletioncount;
@@ -2430,7 +2588,9 @@
mdEdgeCollapseAttrib(mesh, tdata, v0, v1, collapsepoint);
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf("Collapse %d,%d ; Point %f %f %f ( Overwrite %d ; Delete %d )\n",
(int)v0, (int)v1, collapsepoint[0], collapsepoint[1], collapsepoint[2],
(int)v0, (int)v1);
+ printf("Collapse %d,%d ; Point %f %f %f ( Overwrite %d ; Delete %d )\n",
+ (int)v0, (int)v1, collapsepoint[0], collapsepoint[1],
collapsepoint[2], (int)v0,
+ (int)v1);
#endif
/* New vertex overwriting v0 */
@@ -2452,11 +2612,14 @@
tdata->statusdeletioncount = deletioncount;
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Redirect %d -> %d ; %d -> %d\n", (int)v0,
(int)vertex0->redirectindex, (int)v1, (int)vertex1->redirectindex);
+ printf(" Redirect %d -> %d ; %d -> %d\n", (int)v0,
(int)vertex0->redirectindex,
+ (int)v1, (int)vertex1->redirectindex);
#endif
#ifdef DEBUG_VERBOSE_COLLAPSE
- printf(" Move Point %f %f %f ( %f %f %f ) -> %f %f %f\n",
vertex0->point[0], vertex0->point[1], vertex0->point[2], vertex1->point[0],
vertex1->point[1], vertex1->point[2], collapsepoint[0], collapsepoint[1],
collapsepoint[2]);
+ printf(" Move Point %f %f %f ( %f %f %f ) -> %f %f %f\n",
vertex0->point[0],
+ vertex0->point[1], vertex0->point[2], vertex1->point[0],
vertex1->point[1],
+ vertex1->point[2], collapsepoint[0], collapsepoint[1],
collapsepoint[2]);
#endif
/* Set up new vertex over v0 */
@@ -2494,8 +2657,12 @@
/* Update all triangles connected to vertex0 and vertex1 */
trirefstore = trireflist;
- trirefstore = mdEdgeCollapseUpdateAll(mesh, tdata, &mesh->trireflist[
vertex0->trirefbase ], vertex0->trirefcount, v0, newv, trirefstore);
- trirefstore = mdEdgeCollapseUpdateAll(mesh, tdata, &mesh->trireflist[
vertex1->trirefbase ], vertex1->trirefcount, v1, newv, trirefstore);
+ trirefstore = mdEdgeCollapseUpdateAll(mesh, tdata,
+ &mesh->trireflist[
vertex0->trirefbase ], vertex0->trirefcount, v0, newv,
+ trirefstore);
+ trirefstore = mdEdgeCollapseUpdateAll(mesh, tdata,
+ &mesh->trireflist[
vertex1->trirefbase ], vertex1->trirefcount, v1, newv,
+ trirefstore);
/* Find where to store the trirefs */
trirefcount = (int)(trirefstore - trireflist);
@@ -2574,7 +2741,8 @@
mdi triright;
} mdEdgeCollisionData;
-static void mdEdgeCollisionCallback(void *opaque, void *entry, int
UNUSED(newflag))
+static void mdEdgeCollisionCallback(void *opaque, void *entry,
+ int UNUSED(newflag))
{
mdEdge *edge;
mdEdgeCollisionData *ecd;
@@ -2594,7 +2762,8 @@
Check all triangles attached to v1 that would have to attach back to v0
If any of the edge is already present in the hash table, deny the collapse
*/
-static int mdEdgeCollisionCheck(mdMesh *mesh, mdThreadData *UNUSED(tdata), mdi
v0, mdi v1)
+static int mdEdgeCollisionCheck(mdMesh *mesh, mdThreadData *UNUSED(tdata),
+ mdi v0, mdi v1)
{
int vindex, trirefcount, left, right;
mdi triindex, vsrc, vdst;
@@ -2631,14 +2800,16 @@
edge.v[0] = v0;
edge.v[1] = v1;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) ==
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) == MM_HASH_SUCCESS)
ecd.trileft = edge.triindex;
ecd.triright = -1;
edge.v[0] = v1;
edge.v[1] = v0;
- if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge) ==
MM_HASH_SUCCESS)
+ if (mmHashLockReadEntry(mesh->edgehashtable, &mdEdgeHashEdge,
+ &edge) == MM_HASH_SUCCESS)
ecd.triright = edge.triindex;
/* Check all trirefs for collision */
@@ -2673,14 +2844,16 @@
edge.v[0] = vdst;
edge.v[1] = tri->v[right];
- mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
mdEdgeCollisionCallback, &ecd, 0);
+ mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ mdEdgeCollisionCallback, &ecd, 0);
if (ecd.collisionflag)
return 0;
edge.v[0] = tri->v[left];
edge.v[1] = vdst;
- mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
mdEdgeCollisionCallback, &ecd, 0);
+ mmHashLockCallEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ mdEdgeCollisionCallback, &ecd, 0);
if (ecd.collisionflag)
return 0;
@@ -2699,7 +2872,8 @@
int retval;
/* Allocate vertices, no extra room for vertices, we overwrite existing
ones as we decimate */
- mesh->vertexlist = (mdVertex *)mmAlignAlloc(mesh->vertexalloc *
sizeof(mdVertex), 0x40);
+ mesh->vertexlist = (mdVertex *)mmAlignAlloc(mesh->vertexalloc * sizeof(
+ mdVertex), 0x40);
/* Allocate space for per-vertex lists of face references, including
future vertices */
mesh->trirefcount = 0;
@@ -2732,7 +2906,8 @@
/* Mesh init step 1, initialize vertices, threaded */
-static void mdMeshInitVertices(mdMesh *mesh, mdThreadData *tdata, int
threadcount)
+static void mdMeshInitVertices(mdMesh *mesh, mdThreadData *tdata,
+ int threadcount)
{
int vertexindex, vertexindexmax, vertexperthread;
mdVertex *vertex;
@@ -2771,7 +2946,8 @@
/* Mesh init step 2, initialize triangles, threaded */
-static void mdMeshInitTriangles(mdMesh *mesh, mdThreadData *tdata, int
threadcount)
+static void mdMeshInitTriangles(mdMesh *mesh, mdThreadData *tdata,
+ int threadcount)
{
int i, triperthread, triindex, triindexmax;
long buildtricount;
@@ -2781,7 +2957,7 @@
mdEdge edge;
mathQuadric q;
- memset(&edge, 0, sizeof(mdEdge)); /* DRH added so it's initialized */
+ memset(&edge, 0, sizeof(mdEdge)); /*DRH added so it's initialized*/
triperthread = (mesh->tricount / threadcount) + 1;
triindex = tdata->threadid * triperthread;
triindexmax = triindex + triperthread;
@@ -2795,7 +2971,8 @@
tri = &mesh->trilist[triindex];
edge.op = 0;
- for (; triindex < triindexmax ; triindex++, indices = ADDRESS(indices,
mesh->indicesstride), tri++) {
+ for (; triindex < triindexmax ;
+ triindex++, indices = ADDRESS(indices, mesh->indicesstride), tri++) {
mesh->indicesUserToNative(tri->v, indices);
#ifdef DEBUG_VERBOSE_QUADRIC
printf("Triangle %d,%d,%d\n", (int)tri->v[0], (int)tri->v[1],
(int)tri->v[2]);
@@ -2822,19 +2999,22 @@
edge.v[0] = tri->v[0];
edge.v[1] = tri->v[1];
- if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
edge.v[0] = tri->v[1];
edge.v[1] = tri->v[2];
- if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
edge.v[0] = tri->v[2];
edge.v[1] = tri->v[0];
- if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
1) != MM_HASH_SUCCESS)
+ if (mmHashLockAddEntry(mesh->edgehashtable, &mdEdgeHashEdge, &edge,
+ 1) != MM_HASH_SUCCESS)
bu_bomb("SHOULD NOT HAPPEN");
}
@@ -2856,7 +3036,8 @@
trirefcount = 0;
vertex = mesh->vertexlist;
- for (vertexindex = 0 ; vertexindex < mesh->vertexcount ; vertexindex++,
vertex++) {
+ for (vertexindex = 0 ; vertexindex < mesh->vertexcount ;
+ vertexindex++, vertex++) {
vertex->trirefbase = trirefcount;
trirefcount += vertex->trirefcount;
vertex->trirefcount = 0;
@@ -2869,7 +3050,8 @@
/* Mesh init step 4, store vertex trirefs and accumulate boundary quadrics,
threaded */
-static void mdMeshBuildTrirefs(mdMesh *mesh, mdThreadData *tdata, int
threadcount)
+static void mdMeshBuildTrirefs(mdMesh *mesh, mdThreadData *tdata,
+ int threadcount)
{
int i, triperthread, triindex, triindexmax;
long buildrefcount;
@@ -3021,7 +3203,8 @@
}
-static void mdUpdateOp(mdMesh *mesh, mdThreadData *tdata, mdOp *op, int32_t
opflagsmask)
+static void mdUpdateOp(mdMesh *mesh, mdThreadData *tdata, mdOp *op,
+ int32_t opflagsmask)
{
int denyflag, flags;
#ifdef MD_CONFIG_ATOMIC_SUPPORT
@@ -3062,14 +3245,16 @@
mtSpinUnlock(&op->spinlock);
#endif
} else {
- op->penalty = mdEdgeCollapsePenalty(mesh, tdata, op->v0, op->v1,
op->collapsepoint, &denyflag);
+ op->penalty = mdEdgeCollapsePenalty(mesh, tdata, op->v0, op->v1,
+ op->collapsepoint, &denyflag);
mdSortOp(mesh, tdata, op, denyflag);
}
return;
}
-static void mdUpdateBufferOps(mdMesh *mesh, mdThreadData *tdata,
mdUpdateBuffer *updatebuffer, mdLockBuffer *lockbuffer)
+static void mdUpdateBufferOps(mdMesh *mesh, mdThreadData *tdata,
+ mdUpdateBuffer *updatebuffer, mdLockBuffer
*lockbuffer)
{
int vindex;
mdOp *op;
@@ -3084,7 +3269,8 @@
op = (mdOp *)updatebuffer->opbuffer[vindex];
if (mdOpResolveLockEdgeTry(mesh, tdata, lockbuffer, op)) {
- mdUpdateOp(mesh, tdata, op, ~(MD_OP_FLAGS_UPDATE_QUEUED |
MD_OP_FLAGS_UPDATE_NEEDED));
+ mdUpdateOp(mesh, tdata, op,
+ ~(MD_OP_FLAGS_UPDATE_QUEUED |
MD_OP_FLAGS_UPDATE_NEEDED));
mdLockBufferUnlockAll(mesh, tdata, lockbuffer);
} else {
#ifdef MD_CONFIG_ATOMIC_SUPPORT
@@ -3093,7 +3279,8 @@
mtSpinUnlock(&updatebuffer->spinlock);
#endif
mdOpResolveLockEdge(mesh, tdata, lockbuffer, op);
- mdUpdateOp(mesh, tdata, op, ~(MD_OP_FLAGS_UPDATE_QUEUED |
MD_OP_FLAGS_UPDATE_NEEDED));
+ mdUpdateOp(mesh, tdata, op,
+ ~(MD_OP_FLAGS_UPDATE_QUEUED |
MD_OP_FLAGS_UPDATE_NEEDED));
mdLockBufferUnlockAll(mesh, tdata, lockbuffer);
#ifdef MD_CONFIG_ATOMIC_SUPPORT
mmAtomicSpin32(&updatebuffer->atomlock, 0x0, 0x1);
@@ -3159,7 +3346,10 @@
}
#ifdef DEBUG_VERBOSE
- printf("Op %p ; Edge %d,%d (0x%x) ; Point %f %f %f ; Value %f ; Penalty
%f ; Cost %f\n", op, op->v0, op->v1, mmAtomicRead32(&op->flags),
op->collapsepoint[0], op->collapsepoint[1], op->collapsepoint[2], op->value,
op->penalty, op->collapsecost);
+ printf("Op %p ; Edge %d,%d (0x%x) ; Point %f %f %f ; Value %f ; Penalty
%f ; Cost %f\n",
+ op, op->v0, op->v1, mmAtomicRead32(&op->flags),
op->collapsepoint[0],
+ op->collapsepoint[1], op->collapsepoint[2], op->value,
op->penalty,
+ op->collapsecost);
#endif
/* Acquire lock for op edge and all trirefs vertices */
@@ -3183,7 +3373,8 @@
#if defined(DEBUG_PENALTY_CHECK) && DEBUG_PENALTY_CHECK
int denyflag;
mdf penalty;
- penalty = mdEdgeCollapsePenalty(mesh, tdata, op->v0, op->v1,
op->collapsepoint, &denyflag);
+ penalty = mdEdgeCollapsePenalty(mesh, tdata, op->v0, op->v1,
op->collapsepoint,
+ &denyflag);
if (fabs(penalty - op->penalty) > 0.001 * fmax(penalty, op->penalty))
printf("CRAP : %f %f\n", penalty, op->penalty);
@@ -3275,10 +3466,10 @@
else if (dotangle <= -1.0)
factor = 0.5 * M_PI;
else {
- if (0.0 < dotangle && dotangle < 1.0)
+ if (0.0 <= dotangle && dotangle <= 1.0)
+ factor = mdfacos(dotangle);
+ else
factor = 0.0;
- else
- factor = mdfacos(dotangle);
}
return factor;
@@ -3288,7 +3479,8 @@
{
mdTriangle *tri, *triend;
mdVertex *vertex0, *vertex1, *vertex2;
- mdf vecta[3], vectb[3], vectc[3], normalfactor, magna, magnb, magnc, norm,
norminv;
+ mdf vecta[3], vectb[3], vectc[3], normalfactor, magna, magnb, magnc, norm,
+ norminv;
mdTriNormal *trinormal;
trinormal = (mdTriNormal *)mesh->trinormal;
@@ -3326,9 +3518,12 @@
magna = M3D_VectorMagnitude(vecta);
magnb = M3D_VectorMagnitude(vectb);
magnc = M3D_VectorMagnitude(vectc);
- trinormal->factor[0] = norm *
mdMeshAngleFactor(M3D_VectorDotProduct(vecta, vectb) / (magna * magnb));
- trinormal->factor[1] = norm *
mdMeshAngleFactor(-M3D_VectorDotProduct(vecta, vectc) / (magna * magnc));
- trinormal->factor[2] = norm *
mdMeshAngleFactor(M3D_VectorDotProduct(vectb, vectc) / (magnb * magnc));
+ trinormal->factor[0] = norm *
mdMeshAngleFactor(M3D_VectorDotProduct(vecta,
+ vectb) / (magna * magnb));
+ trinormal->factor[1] = norm *
mdMeshAngleFactor(-M3D_VectorDotProduct(vecta,
+ vectc) / (magna * magnc));
+ trinormal->factor[2] = norm *
mdMeshAngleFactor(M3D_VectorDotProduct(vectb,
+ vectc) / (magnb * magnc));
trinormal++;
}
@@ -3337,7 +3532,8 @@
}
-static int mdMeshVertexComputeNormal(mdMesh *mesh, mdi vertexindex, mdi
*trireflist, int trirefcount, mdf *normal)
+static int mdMeshVertexComputeNormal(mdMesh *mesh, mdi vertexindex,
+ mdi *trireflist, int trirefcount, mdf
*normal)
{
int vindex, pivot, validflag;
mdi triindex;
@@ -3402,7 +3598,8 @@
retindex = -1;
vertex = &mesh->vertexlist[ mesh->clonesearchindex ];
- for (vertexindex = mesh->clonesearchindex ; vertexindex <
mesh->vertexalloc ; vertexindex++, vertex++) {
+ for (vertexindex = mesh->clonesearchindex ; vertexindex <
mesh->vertexalloc ;
+ vertexindex++, vertex++) {
if ((vertexindex < mesh->vertexcount) && (vertex->trirefcount))
continue;
@@ -3440,15 +3637,16 @@
}
-static void mdMeshVertexRedirectTriRefs(mdMesh *mesh, mdi vertexindex, mdi
newvertexindex, mdi *trireflist, int trirefcount)
+static void mdMeshVertexRedirectTriRefs(mdMesh *mesh, mdi vertexindex,
+ mdi newvertexindex, mdi *trireflist,
int trirefcount)
{
int vindex;
mdi triindex;
mdTriangle *tri;
- /* 2012-10-22 ch3: trinormal set but never used, so commented*/
- /*mdTriNormal *trinormal;*/
+ /* 2012-10-22 ch3: trinormal set but never used, so commented
+ mdTriNormal *trinormal;
- /*trinormal = mesh->trinormal;*/
+ trinormal = mesh->trinormal; */
for (vindex = 0 ; vindex < trirefcount ; vindex++) {
triindex = trireflist[ vindex ];
@@ -3476,7 +3674,8 @@
/* Find a target normal */
-static int mdMeshVertexFindTarget(mdMesh *mesh, mdi *trireflist, int
trirefcount, mdf **targetnormal)
+static int mdMeshVertexFindTarget(mdMesh *mesh, mdi *trireflist,
+ int trirefcount, mdf **targetnormal)
{
int i0, i1;
mdi triindex0, triindex1;
@@ -3531,7 +3730,8 @@
#define MD_MESH_TRIREF_MAX (256)
-static int mdMeshVertexBuildNormal(mdMesh *mesh, mdi vertexindex, mdi
*trireflist, int trirefcount, mdf *point, mdf *normal)
+static int mdMeshVertexBuildNormal(mdMesh *mesh, mdi vertexindex,
+ mdi *trireflist, int trirefcount, mdf
*point, mdf *normal)
{
int vindex, trirefbuffercount;
mdi triindex, newvertexindex;
@@ -3549,7 +3749,8 @@
for (; ;) {
/* Compute normal for vertex */
- if (!(mdMeshVertexComputeNormal(mesh, vertexindex, trireflist,
trirefcount, normal)))
+ if (!(mdMeshVertexComputeNormal(mesh, vertexindex, trireflist,
trirefcount,
+ normal)))
return 0;
/* If user doesn't allow vertex splitting, take the normal as it is */
@@ -3599,11 +3800,14 @@
break;
/* Correct all trirefs to new vertex */
- mdMeshVertexRedirectTriRefs(mesh, vertexindex, newvertexindex,
trirefbuffer, trirefbuffercount);
+ mdMeshVertexRedirectTriRefs(mesh, vertexindex, newvertexindex,
trirefbuffer,
+ trirefbuffercount);
/* Spawn a new vertex */
- newnormal = (mdf *)ADDRESS(mesh->vertexnormal, newvertexindex * 3 *
sizeof(mdf));
- mdMeshVertexBuildNormal(mesh, newvertexindex, trirefbuffer,
trirefbuffercount, point, newnormal);
+ newnormal = (mdf *)ADDRESS(mesh->vertexnormal,
+ newvertexindex * 3 * sizeof(mdf));
+ mdMeshVertexBuildNormal(mesh, newvertexindex, trirefbuffer,
trirefbuffercount,
+ point, newnormal);
}
return 1;
@@ -3635,7 +3839,8 @@
}
-static void mdMeshWriteVertices(mdMesh *mesh, mdOpAttrib *normalattrib, mdf
*vertexnormal)
+static void mdMeshWriteVertices(mdMesh *mesh, mdOpAttrib *normalattrib,
+ mdf *vertexnormal)
{
mdi vertexindex, writeindex;
mdf *point, *normal;
@@ -3659,7 +3864,8 @@
attrib = mesh->attrib;
attribend = &mesh->attrib[mesh->attribcount];
- for (vertexindex = 0 ; vertexindex < mesh->vertexcount ; vertexindex++,
vertex++) {
+ for (vertexindex = 0 ; vertexindex < mesh->vertexcount ;
+ vertexindex++, vertex++) {
if (!(mesh->operationflags & MD_FLAGS_NO_VERTEX_PACKING)) {
if (vertex->redirectindex != -1)
continue;
@@ -3668,7 +3874,9 @@
continue;
/* The whole mdMeshRecomputeNormals() process already strips unused
vertices */
- if (!(vertexnormal) && (vertex->trirefcount != -1) &&
!(mdMeshVertexCheckUse(mesh, &mesh->trireflist[ vertex->trirefbase ],
vertex->trirefcount)))
+ if (!(vertexnormal) && (vertex->trirefcount != -1)
+ && !(mdMeshVertexCheckUse(mesh, &mesh->trireflist[
vertex->trirefbase ],
+ vertex->trirefcount)))
continue;
}
@@ -3755,16 +3963,19 @@
mdMeshBuildTriangleNormals(mesh);
/* Build each vertex normal */
- /*vertexcount = 0;*/
+ /* vertexcount = 0; */
vertex = mesh->vertexlist;
- for (vertexindex = 0 ; vertexindex < mesh->vertexcount ; vertexindex++,
vertex++) {
+ for (vertexindex = 0 ; vertexindex < mesh->vertexcount ;
+ vertexindex++, vertex++) {
if (!(vertex->trirefcount) || (vertex->trirefcount == -1))
continue;
normal = (mdf *)ADDRESS(mesh->vertexnormal, vertexindex * 3 *
sizeof(mdf));
- if (!(mdMeshVertexBuildNormal(mesh, vertexindex, &mesh->trireflist[
vertex->trirefbase ], vertex->trirefcount, vertex->point, normal)))
+ if (!(mdMeshVertexBuildNormal(mesh, vertexindex,
+ &mesh->trireflist[ vertex->trirefbase ],
vertex->trirefcount, vertex->point,
+ normal)))
vertex->trirefcount = 0;
}
@@ -3833,7 +4044,9 @@
} else
mmBlockInit(&tdata.opblock, sizeof(mdOp), 16384, 16384, 0x10);
- tdata.binsort = mmBinSortInit(offsetof(mdOp, list), 64, 16, -0.2 *
mesh->maxcollapsecost, 1.2 * mesh->maxcollapsecost, groupthreshold,
mdMeshOpValueCallback, 6, nodeindex);
+ tdata.binsort = mmBinSortInit(offsetof(mdOp, list), 64, 16,
+ -0.2 * mesh->maxcollapsecost, 1.2 *
mesh->maxcollapsecost, groupthreshold,
+ mdMeshOpValueCallback, 6, nodeindex);
for (vindex = 0 ; vindex < mesh->updatebuffercount ; vindex++)
mdUpdateBufferInit(&tdata.updatebuffer[vindex], 4096);
@@ -3936,7 +4149,8 @@
0.0
};
-static void mdUpdateStatus(mdMesh *mesh, mdThreadInit *threadinit, int stage,
mdStatus *status)
+static void mdUpdateStatus(mdMesh *mesh, mdThreadInit *threadinit, int stage,
+ mdStatus *status)
{
int threadid, stageindex;
long buildtricount, buildrefcount, populatecount, deletioncount;
@@ -4037,10 +4251,11 @@
op->syncstepcount = 32;
op->normalsearchangle = 45.0;
mmInit();
- op->maxmemorysize = ((size_t)2) * 1024 * 1024 * 1024;
+ op->maxmemorysize = ((long long)2) * 1024 * 1024 * 1024;
if (mmcontext.sysmemory) {
- op->maxmemorysize = (mmcontext.sysmemory >> 1) + (mmcontext.sysmemory
>> 2); /* By default, allow to allocate up to 75% of system memory */
+ op->maxmemorysize = (mmcontext.sysmemory >> 1) + (mmcontext.sysmemory >>
+ 2); /* By default, allow to allocate up to 75%
of system memory */
if (op->maxmemorysize < 1024 * 1024 * 1024)
op->maxmemorysize = 1024 * 1024 * 1024;
@@ -4049,7 +4264,9 @@
return;
}
-void mdOperationData(mdOperation *op, size_t vertexcount, void *vertex, int
vertexwidth, size_t vertexstride, size_t tricount, void *indices, int
indiceswidth, size_t indicesstride)
+void mdOperationData(mdOperation *op, size_t vertexcount, void *vertex,
+ int vertexwidth, size_t vertexstride, size_t tricount,
void *indices,
+ int indiceswidth, size_t indicesstride)
{
op->vertexcount = vertexcount;
op->vertex = vertex;
@@ -4062,7 +4279,8 @@
return;
}
-int mdOperationAddAttrib(mdOperation *op, void *base, int width, size_t count,
size_t stride, int flags)
+int mdOperationAddAttrib(mdOperation *op, void *base, int width, size_t count,
+ size_t stride, int flags)
{
mdOpAttrib *attrib;
@@ -4093,7 +4311,9 @@
return;
}
-void mdOperationStatusCallback(mdOperation *op, void (*statuscallback)(void
*opaquepointer, const mdStatus *status), void *opaquepointer, long miliseconds)
+void mdOperationStatusCallback(mdOperation *op,
+ void (*statuscallback)(void *opaquepointer,
const mdStatus *status),
+ void *opaquepointer, long miliseconds)
{
op->statusmiliseconds = miliseconds;
op->statusopaquepointer = opaquepointer;
@@ -4219,7 +4439,8 @@
if (mesh.syncstepcount > 1024)
mesh.syncstepcount = 1024;
- mesh.normalsearchangle = cos(1.0 * operation->normalsearchangle * (M_PI /
180.0));
+ mesh.normalsearchangle = cos(1.0 * operation->normalsearchangle *
+ (M_PI / 180.0));
if (mesh.normalsearchangle > 0.9)
mesh.normalsearchangle = 0.9;
@@ -4229,7 +4450,9 @@
mdBarrierInit(&mesh.globalbarrier, threadcount + 1);
/* Determine update buffer shift required, find the count of updatebuffers
*/
- for (mesh.updatebuffershift = 0 ; (threadcount >> mesh.updatebuffershift)
> MD_THREAD_UPDATE_BUFFER_COUNTMAX ; mesh.updatebuffershift++);
+ for (mesh.updatebuffershift = 0 ;
+ (threadcount >> mesh.updatebuffershift) >
MD_THREAD_UPDATE_BUFFER_COUNTMAX ;
+ mesh.updatebuffershift++);
mesh.updatebuffercount = ((threadcount - 1) >> mesh.updatebuffershift) + 1;
@@ -4238,8 +4461,9 @@
#ifdef MD_CONFIG_SSE_SUPPORT
#ifndef MD_CONF_DOUBLE_PRECISION
-#if defined(__SSE_4_1__) && __SSE_4_1__
+#if defined(__SSE4_1__) && __SSE4_1__
+
if ((mdCpuInfo.capsse4p1) && (mdPathSSE4p1 & 0x1)) {
#ifdef DEBUG_VERBOSE
printf("PATH : SSE4.1 Float\n");
@@ -4266,8 +4490,9 @@
{}
#else
-#if defined(__SSE_4_1__) && __SSE_4_1__
+#if defined(__SSE4_1__) && __SSE4_1__
+
if ((mdCpuInfo.capsse4p1) && (mdPathSSE4p1 & 0x2)) {
#ifdef DEBUG_VERBOSE
printf("PATH : SSE4.1 Double\n");
@@ -4308,7 +4533,8 @@
mesh.updatestatusflag = 0;
status.progress = 0.0;
- statuswait = (operation->statusmiliseconds > 10 ?
operation->statusmiliseconds : 10);
+ statuswait = (operation->statusmiliseconds > 10 ?
operation->statusmiliseconds :
+ 10);
status.trianglecount = 0;
if (operation->statuscallback) {
@@ -4324,7 +4550,8 @@
tinit->threadid = threadid;
tinit->mesh = &mesh;
tinit->stage = MD_STATUS_STAGE_INIT;
- mtThreadCreate(&thread[threadid], mdThreadMain, tinit,
MT_THREAD_FLAGS_JOINABLE, 0, 0);
+ mtThreadCreate(&thread[threadid], mdThreadMain, tinit,
MT_THREAD_FLAGS_JOINABLE,
+ 0, 0);
}
/* Wait until all threads have properly initialized */
@@ -4415,7 +4642,8 @@
long accesscount, collisioncount, relocationcount;
long entrycount, entrycountmax, hashsizemax;
- mmHashStatistics(mesh.edgehashtable, &accesscount, &collisioncount,
&relocationcount, &entrycount, &entrycountmax, &hashsizemax);
+ mmHashStatistics(mesh.edgehashtable, &accesscount, &collisioncount,
+ &relocationcount, &entrycount, &entrycountmax,
&hashsizemax);
printf("Hash Access : %ld\n", accesscount);
printf("Hash Collision : %ld\n", collisioncount);
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
Don't Limit Your Business. Reach for the Cloud.
GigeNET's Cloud Solutions provide you with the tools and support that
you need to offload your IT needs and focus on growing your business.
Configured For All Businesses. Start Your Cloud Today.
https://www.gigenetcloud.com/
_______________________________________________
BRL-CAD Source Commits mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/brlcad-commits
