hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity
6834d23fab
yuzu/externals/vcpkg/ports/triangle/enable_64bit_architecture.patch

419 lines
18 KiB
Diff
Raw Normal View History

early-access version 2853
2022-07-23 05:01:36 +04:00
triangle.c | 116 ++++++++++++++++++++++++++-----------------------------------
triangle.h | 29 +++++++++-------
2 files changed, 66 insertions(+), 79 deletions(-)
diff --git a/triangle.c b/triangle.c
index f7a5700..084902e 100644
--- a/triangle.c
+++ b/triangle.c
@@ -194,27 +194,8 @@
/* */
/*****************************************************************************/
-/* For single precision (which will save some memory and reduce paging), */
-/* define the symbol SINGLE by using the -DSINGLE compiler switch or by */
-/* writing "#define SINGLE" below. */
-/* */
-/* For double precision (which will allow you to refine meshes to a smaller */
-/* edge length), leave SINGLE undefined. */
-/* */
-/* Double precision uses more memory, but improves the resolution of the */
-/* meshes you can generate with Triangle. It also reduces the likelihood */
-/* of a floating exception due to overflow. Finally, it is much faster */
-/* than single precision on 64-bit architectures like the DEC Alpha. I */
-/* recommend double precision unless you want to generate a mesh for which */
-/* you do not have enough memory. */
-
-/* #define SINGLE */
-
-#ifdef SINGLE
-#define REAL float
-#else /* not SINGLE */
#define REAL double
-#endif /* not SINGLE */
+#define VOID void
/* If yours is not a Unix system, define the NO_TIMER compiler switch to */
/* remove the Unix-specific timing code. */
@@ -308,12 +289,6 @@
#define DEADVERTEX -32768
#define UNDEADVERTEX -32767
-/* The next line is used to outsmart some very stupid compilers. If your */
-/* compiler is smarter, feel free to replace the "int" with "void". */
-/* Not that it matters. */
-
-#define VOID int
-
/* Two constants for algorithms based on random sampling. Both constants */
/* have been chosen empirically to optimize their respective algorithms. */
@@ -340,6 +315,7 @@
#define ONETHIRD 0.333333333333333333333333333333333333333333333333333333333333
+#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -938,16 +914,16 @@ int minus1mod3[3] = {2, 0, 1};
/* extracted from the two least significant bits of the pointer. */
#define decode(ptr, otri) \
- (otri).orient = (int) ((unsigned long) (ptr) & (unsigned long) 3l); \
+ (otri).orient = (int) ((uintptr_t) (ptr) & (uintptr_t) 3l); \
(otri).tri = (triangle *) \
- ((unsigned long) (ptr) ^ (unsigned long) (otri).orient)
+ ((uintptr_t) (ptr) ^ (uintptr_t) (otri).orient)
/* encode() compresses an oriented triangle into a single pointer. It */
/* relies on the assumption that all triangles are aligned to four-byte */
/* boundaries, so the two least significant bits of (otri).tri are zero. */
#define encode(otri) \
- (triangle) ((unsigned long) (otri).tri | (unsigned long) (otri).orient)
+ (triangle) ((uintptr_t) (otri).tri | (uintptr_t) (otri).orient)
/* The following handle manipulation primitives are all described by Guibas */
/* and Stolfi. However, Guibas and Stolfi use an edge-based data */
@@ -1111,16 +1087,16 @@ int minus1mod3[3] = {2, 0, 1};
#define infect(otri) \
(otri).tri[6] = (triangle) \
- ((unsigned long) (otri).tri[6] | (unsigned long) 2l)
+ ((uintptr_t) (otri).tri[6] | (uintptr_t) 2l)
#define uninfect(otri) \
(otri).tri[6] = (triangle) \
- ((unsigned long) (otri).tri[6] & ~ (unsigned long) 2l)
+ ((uintptr_t) (otri).tri[6] & ~ (uintptr_t) 2l)
/* Test a triangle for viral infection. */
#define infected(otri) \
- (((unsigned long) (otri).tri[6] & (unsigned long) 2l) != 0l)
+ (((uintptr_t) (otri).tri[6] & (uintptr_t) 2l) != 0l)
/* Check or set a triangle's attributes. */
@@ -1158,16 +1134,16 @@ int minus1mod3[3] = {2, 0, 1};
/* are masked out to produce the real pointer. */
#define sdecode(sptr, osub) \
- (osub).ssorient = (int) ((unsigned long) (sptr) & (unsigned long) 1l); \
+ (osub).ssorient = (int) ((uintptr_t) (sptr) & (uintptr_t) 1l); \
(osub).ss = (subseg *) \
- ((unsigned long) (sptr) & ~ (unsigned long) 3l)
+ ((uintptr_t) (sptr) & ~ (uintptr_t) 3l)
/* sencode() compresses an oriented subsegment into a single pointer. It */
/* relies on the assumption that all subsegments are aligned to two-byte */
/* boundaries, so the least significant bit of (osub).ss is zero. */
#define sencode(osub) \
- (subseg) ((unsigned long) (osub).ss | (unsigned long) (osub).ssorient)
+ (subseg) ((uintptr_t) (osub).ss | (uintptr_t) (osub).ssorient)
/* ssym() toggles the orientation of a subsegment. */
@@ -3891,7 +3867,7 @@ struct memorypool *pool;
#endif /* not ANSI_DECLARATORS */
{
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
pool->items = 0;
pool->maxitems = 0;
@@ -3899,11 +3875,11 @@ struct memorypool *pool;
/* Set the currently active block. */
pool->nowblock = pool->firstblock;
/* Find the first item in the pool. Increment by the size of (VOID *). */
- alignptr = (unsigned long) (pool->nowblock + 1);
+ alignptr = (uintptr_t) (pool->nowblock + 1);
/* Align the item on an `alignbytes'-byte boundary. */
pool->nextitem = (VOID *)
- (alignptr + (unsigned long) pool->alignbytes -
- (alignptr % (unsigned long) pool->alignbytes));
+ (alignptr + (uintptr_t) pool->alignbytes -
+ (alignptr % (uintptr_t) pool->alignbytes));
/* There are lots of unallocated items left in this block. */
pool->unallocateditems = pool->itemsfirstblock;
/* The stack of deallocated items is empty. */
@@ -4008,7 +3984,7 @@ struct memorypool *pool;
{
VOID *newitem;
VOID **newblock;
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
/* First check the linked list of dead items. If the list is not */
/* empty, allocate an item from the list rather than a fresh one. */
@@ -4033,11 +4009,11 @@ struct memorypool *pool;
pool->nowblock = (VOID **) *(pool->nowblock);
/* Find the first item in the block. */
/* Increment by the size of (VOID *). */
- alignptr = (unsigned long) (pool->nowblock + 1);
+ alignptr = (uintptr_t) (pool->nowblock + 1);
/* Align the item on an `alignbytes'-byte boundary. */
pool->nextitem = (VOID *)
- (alignptr + (unsigned long) pool->alignbytes -
- (alignptr % (unsigned long) pool->alignbytes));
+ (alignptr + (uintptr_t) pool->alignbytes -
+ (alignptr % (uintptr_t) pool->alignbytes));
/* There are lots of unallocated items left in this block. */
pool->unallocateditems = pool->itemsperblock;
}
@@ -4092,16 +4068,16 @@ struct memorypool *pool;
#endif /* not ANSI_DECLARATORS */
{
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
/* Begin the traversal in the first block. */
pool->pathblock = pool->firstblock;
/* Find the first item in the block. Increment by the size of (VOID *). */
- alignptr = (unsigned long) (pool->pathblock + 1);
+ alignptr = (uintptr_t) (pool->pathblock + 1);
/* Align with item on an `alignbytes'-byte boundary. */
pool->pathitem = (VOID *)
- (alignptr + (unsigned long) pool->alignbytes -
- (alignptr % (unsigned long) pool->alignbytes));
+ (alignptr + (uintptr_t) pool->alignbytes -
+ (alignptr % (uintptr_t) pool->alignbytes));
/* Set the number of items left in the current block. */
pool->pathitemsleft = pool->itemsfirstblock;
}
@@ -4129,7 +4105,7 @@ struct memorypool *pool;
{
VOID *newitem;
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
/* Stop upon exhausting the list of items. */
if (pool->pathitem == pool->nextitem) {
@@ -4141,11 +4117,11 @@ struct memorypool *pool;
/* Find the next block. */
pool->pathblock = (VOID **) *(pool->pathblock);
/* Find the first item in the block. Increment by the size of (VOID *). */
- alignptr = (unsigned long) (pool->pathblock + 1);
+ alignptr = (uintptr_t) (pool->pathblock + 1);
/* Align with item on an `alignbytes'-byte boundary. */
pool->pathitem = (VOID *)
- (alignptr + (unsigned long) pool->alignbytes -
- (alignptr % (unsigned long) pool->alignbytes));
+ (alignptr + (uintptr_t) pool->alignbytes -
+ (alignptr % (uintptr_t) pool->alignbytes));
/* Set the number of items left in the current block. */
pool->pathitemsleft = pool->itemsperblock;
}
@@ -4197,16 +4173,16 @@ int subsegbytes;
#endif /* not ANSI_DECLARATORS */
{
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
/* Set up `dummytri', the `triangle' that occupies "outer space." */
m->dummytribase = (triangle *) trimalloc(trianglebytes +
m->triangles.alignbytes);
/* Align `dummytri' on a `triangles.alignbytes'-byte boundary. */
- alignptr = (unsigned long) m->dummytribase;
+ alignptr = (uintptr_t) m->dummytribase;
m->dummytri = (triangle *)
- (alignptr + (unsigned long) m->triangles.alignbytes -
- (alignptr % (unsigned long) m->triangles.alignbytes));
+ (alignptr + (uintptr_t) m->triangles.alignbytes -
+ (alignptr % (uintptr_t) m->triangles.alignbytes));
/* Initialize the three adjoining triangles to be "outer space." These */
/* will eventually be changed by various bonding operations, but their */
/* values don't really matter, as long as they can legally be */
@@ -4226,10 +4202,10 @@ int subsegbytes;
m->dummysubbase = (subseg *) trimalloc(subsegbytes +
m->subsegs.alignbytes);
/* Align `dummysub' on a `subsegs.alignbytes'-byte boundary. */
- alignptr = (unsigned long) m->dummysubbase;
+ alignptr = (uintptr_t) m->dummysubbase;
m->dummysub = (subseg *)
- (alignptr + (unsigned long) m->subsegs.alignbytes -
- (alignptr % (unsigned long) m->subsegs.alignbytes));
+ (alignptr + (uintptr_t) m->subsegs.alignbytes -
+ (alignptr % (uintptr_t) m->subsegs.alignbytes));
/* Initialize the two adjoining subsegments to be the omnipresent */
/* subsegment. These will eventually be changed by various bonding */
/* operations, but their values don't really matter, as long as they */
@@ -4586,7 +4562,7 @@ int number;
{
VOID **getblock;
char *foundvertex;
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
int current;
getblock = m->vertices.firstblock;
@@ -4603,9 +4579,9 @@ int number;
}
/* Now find the right vertex. */
- alignptr = (unsigned long) (getblock + 1);
- foundvertex = (char *) (alignptr + (unsigned long) m->vertices.alignbytes -
- (alignptr % (unsigned long) m->vertices.alignbytes));
+ alignptr = (uintptr_t) (getblock + 1);
+ foundvertex = (char *) (alignptr + (uintptr_t) m->vertices.alignbytes -
+ (alignptr % (uintptr_t) m->vertices.alignbytes));
return (vertex) (foundvertex + m->vertices.itembytes * (number - current));
}
@@ -4883,6 +4859,7 @@ struct osub *newsubseg;
/* */
/*****************************************************************************/
+static
void exactinit()
{
REAL half;
@@ -4956,6 +4933,7 @@ void exactinit()
/* */
/*****************************************************************************/
+static
#ifdef ANSI_DECLARATORS
int fast_expansion_sum_zeroelim(int elen, REAL *e, int flen, REAL *f, REAL *h)
#else /* not ANSI_DECLARATORS */
@@ -5050,6 +5028,7 @@ REAL *h;
/* */
/*****************************************************************************/
+static
#ifdef ANSI_DECLARATORS
int scale_expansion_zeroelim(int elen, REAL *e, REAL b, REAL *h)
#else /* not ANSI_DECLARATORS */
@@ -5106,6 +5085,7 @@ REAL *h;
/* */
/*****************************************************************************/
+static
#ifdef ANSI_DECLARATORS
REAL estimate(int elen, REAL *e)
#else /* not ANSI_DECLARATORS */
@@ -5303,6 +5283,7 @@ vertex pc;
/* */
/*****************************************************************************/
+static
#ifdef ANSI_DECLARATORS
REAL incircleadapt(vertex pa, vertex pb, vertex pc, vertex pd, REAL permanent)
#else /* not ANSI_DECLARATORS */
@@ -5882,6 +5863,7 @@ REAL permanent;
return finnow[finlength - 1];
}
+static
#ifdef ANSI_DECLARATORS
REAL incircle(struct mesh *m, struct behavior *b,
vertex pa, vertex pb, vertex pc, vertex pd)
@@ -5964,6 +5946,7 @@ vertex pd;
/* */
/*****************************************************************************/
+static
#ifdef ANSI_DECLARATORS
REAL orient3dadapt(vertex pa, vertex pb, vertex pc, vertex pd,
REAL aheight, REAL bheight, REAL cheight, REAL dheight,
@@ -6389,6 +6372,7 @@ REAL permanent;
return finnow[finlength - 1];
}
+static
#ifdef ANSI_DECLARATORS
REAL orient3d(struct mesh *m, struct behavior *b,
vertex pa, vertex pb, vertex pc, vertex pd,
@@ -7649,7 +7633,7 @@ struct otri *searchtri;
char *firsttri;
struct otri sampletri;
vertex torg, tdest;
- unsigned long alignptr;
+ uintptr_t alignptr = 0;
REAL searchdist, dist;
REAL ahead;
long samplesperblock, totalsamplesleft, samplesleft;
@@ -7721,11 +7705,11 @@ struct otri *searchtri;
population = totalpopulation;
}
/* Find a pointer to the first triangle in the block. */
- alignptr = (unsigned long) (sampleblock + 1);
+ alignptr = (uintptr_t) (sampleblock + 1);
firsttri = (char *) (alignptr +
- (unsigned long) m->triangles.alignbytes -
+ (uintptr_t) m->triangles.alignbytes -
(alignptr %
- (unsigned long) m->triangles.alignbytes));
+ (uintptr_t) m->triangles.alignbytes));
/* Choose `samplesleft' randomly sampled triangles in this block. */
do {
diff --git a/triangle.h b/triangle.h
index 9df1f39..8d9c754 100644
--- a/triangle.h
+++ b/triangle.h
@@ -248,16 +248,20 @@
/* */
/*****************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
struct triangulateio {
- REAL *pointlist; /* In / out */
- REAL *pointattributelist; /* In / out */
+ double *pointlist; /* In / out */
+ double *pointattributelist; /* In / out */
int *pointmarkerlist; /* In / out */
int numberofpoints; /* In / out */
int numberofpointattributes; /* In / out */
int *trianglelist; /* In / out */
- REAL *triangleattributelist; /* In / out */
- REAL *trianglearealist; /* In only */
+ double *triangleattributelist; /* In / out */
+ double *trianglearealist; /* In only */
int *neighborlist; /* Out only */
int numberoftriangles; /* In / out */
int numberofcorners; /* In / out */
@@ -267,23 +271,22 @@ struct triangulateio {
int *segmentmarkerlist; /* In / out */
int numberofsegments; /* In / out */
- REAL *holelist; /* In / pointer to array copied out */
+ double *holelist; /* In / pointer to array copied out */
int numberofholes; /* In / copied out */
- REAL *regionlist; /* In / pointer to array copied out */
+ double *regionlist; /* In / pointer to array copied out */
int numberofregions; /* In / copied out */
int *edgelist; /* Out only */
int *edgemarkerlist; /* Not used with Voronoi diagram; out only */
- REAL *normlist; /* Used only with Voronoi diagram; out only */
+ double *normlist; /* Used only with Voronoi diagram; out only */
int numberofedges; /* Out only */
};
-#ifdef ANSI_DECLARATORS
void triangulate(char *, struct triangulateio *, struct triangulateio *,
struct triangulateio *);
-void trifree(VOID *memptr);
-#else /* not ANSI_DECLARATORS */
-void triangulate();
-void trifree();
-#endif /* not ANSI_DECLARATORS */
+void trifree(void *memptr);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
Reference in New Issue Copy Permalink