commit 7bf0e9ef947f36b036a0d55d8db985d7fb33d08a
parent 132b7dc198713ce6d764f58170e093d50dafc5fa
Author: Christophe Coustet <christophe.coustet@meso-star.com>
Date: Wed, 19 Feb 2020 10:27:02 +0100
Add stuff to ease a possible change in API types
Diffstat:
15 files changed, 208 insertions(+), 197 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -113,6 +113,8 @@ add_library(senc3d SHARED
target_link_libraries(senc3d RSys Star3D ${MATH_LIB})
set_target_properties(senc3d PROPERTIES
+# C99 needed in case of printf %zu used
+# C_STANDARD 99
DEFINE_SYMBOL SENC3D_SHARED_BUILD
VERSION ${VERSION}
COMPILE_FLAGS ${OpenMP_C_FLAGS}
diff --git a/src/senc3d.h b/src/senc3d.h
@@ -87,7 +87,7 @@ struct senc3d_enclosure_header {
unsigned enclosed_media_count;
/* Is the enclosure open/infinite?
* Only the outermost enclosure is infinite. */
- char is_infinite;
+ int is_infinite;
};
/* We consider the geometrical normal Ng to a triangle V0 V1 V2
diff --git a/src/senc3d_descriptor.c b/src/senc3d_descriptor.c
@@ -26,34 +26,32 @@
*****************************************************************************/
res_T
senc3d_scene_get_max_medium
- (const struct senc3d_scene* scn, unsigned* max_medium_id)
+ (const struct senc3d_scene* scn, medium_id_t* max_medium_id)
{
if(!scn || !max_medium_id) return RES_BAD_ARG;
- ASSERT(scn->next_medium_idx < UINT_MAX); /* API type */
- *max_medium_id = (unsigned)scn->next_medium_idx - 1;
+ *max_medium_id = scn->next_medium_idx - 1;
return RES_OK;
}
res_T
senc3d_scene_get_enclosure_count
- (const struct senc3d_scene* scn, unsigned* count)
+ (const struct senc3d_scene* scn, enclosure_id_t* count)
{
- size_t tmp;
if(!scn || !count) return RES_BAD_ARG;
- tmp = darray_enclosure_size_get(&scn->analyze.enclosures);
- ASSERT(tmp < UINT_MAX); /* API type */
- ASSERT(scn->analyze.enclosures_count == tmp);
- *count = (unsigned)tmp;
+ ASSERT(scn->analyze.enclosures_count ==
+ darray_enclosure_size_get(&scn->analyze.enclosures));
+ *count = scn->analyze.enclosures_count;
return RES_OK;
}
res_T
senc3d_scene_get_enclosure_count_by_medium
(const struct senc3d_scene* scn,
- const unsigned imed,
- unsigned* count)
+ const medium_id_t imed,
+ enclosure_id_t* count)
{
- size_t tmp, m_idx;
+ size_t tmp;
+ size_t m_idx;
const struct darray_enc_id* enc_ids;
if(!scn || !count
|| (imed != SENC3D_UNSPECIFIED_MEDIUM && imed >= scn->next_medium_idx))
@@ -64,15 +62,15 @@ senc3d_scene_get_enclosure_count_by_medium
enc_ids = darray_enc_ids_array_cdata_get(&scn->analyze.enc_ids_array_by_medium)
+ m_idx;
tmp = darray_enc_id_size_get(enc_ids);
- ASSERT(tmp < UINT_MAX); /* API type */
- *count = (unsigned)tmp;
+ ASSERT(tmp <= ENCLOSURE_MAX__); /* API type */
+ *count = (enclosure_id_t)tmp;
return RES_OK;
}
FINLINE res_T
senc3d_scene_get_enclosure
(struct senc3d_scene* scn,
- const unsigned idx,
+ const enclosure_id_t idx,
struct senc3d_enclosure** out_enc)
{
struct senc3d_enclosure* enc;
@@ -88,13 +86,13 @@ senc3d_scene_get_enclosure
res_T
senc3d_scene_get_enclosure_by_medium
(struct senc3d_scene* scn,
- const unsigned imed,
- const unsigned idx,
+ const medium_id_t imed,
+ const enclosure_id_t idx,
struct senc3d_enclosure** out_enc)
{
size_t m_idx;
const struct darray_enc_id* enc_ids;
- unsigned index;
+ enclosure_id_t index;
if(!scn || !out_enc
|| (imed != SENC3D_UNSPECIFIED_MEDIUM && imed >= scn->next_medium_idx))
return RES_BAD_ARG;
@@ -111,8 +109,8 @@ senc3d_scene_get_enclosure_by_medium
res_T
senc3d_scene_get_triangle_enclosures
(const struct senc3d_scene* scn,
- const unsigned itri,
- unsigned enclosures[2])
+ const trg_id_t itri,
+ enclosure_id_t enclosures[2])
{
const struct triangle_enc* trg;
int i;
@@ -120,41 +118,38 @@ senc3d_scene_get_triangle_enclosures
|| itri >= darray_triangle_enc_size_get(&scn->analyze.triangles_enc))
return RES_BAD_ARG;
trg = darray_triangle_enc_cdata_get(&scn->analyze.triangles_enc) + itri;
- FOR_EACH(i, 0, 2) {
-#if (UINT_MAX < ENCLOSURE_MAX__)
- ASSERT(trg->enclosure[i] < UINT_MAX);
-#endif
- enclosures[i] = (unsigned)trg->enclosure[i]; /* Back to API type */
- }
+ FOR_EACH(i, 0, 2) enclosures[i] = trg->enclosure[i];
return RES_OK;
}
res_T
senc3d_scene_get_frontier_segments_count
(const struct senc3d_scene* scn,
- unsigned* count)
+ vrtx_id_t* count)
{
size_t tmp;
if(!scn || !count)
return RES_BAD_ARG;
tmp = darray_frontier_edge_size_get(&scn->analyze.frontiers);
- ASSERT(tmp < UINT_MAX);
- *count = (unsigned)tmp;
+ ASSERT(tmp <= VRTX_MAX__);
+ *count = (vrtx_id_t)tmp; /* Back to API type */
return RES_OK;
}
res_T
senc3d_scene_get_frontier_segment
(const struct senc3d_scene* scn,
- const unsigned iseg,
- unsigned vrtx_id[2])
+ const unsigned iseg, /* There is no defined type for segment IDs */
+ vrtx_id_t vrtx_id[2])
{
const struct trg_edge* edge;
if(!vrtx_id || !scn
|| iseg >= darray_frontier_edge_size_get(&scn->analyze.frontiers))
return RES_BAD_ARG;
edge = darray_frontier_edge_cdata_get(&scn->analyze.frontiers) + iseg;
- vrtx_id[0] = (unsigned)edge->vrtx0; /* Back to API type */
- vrtx_id[1] = (unsigned)edge->vrtx1; /* Back to API type */
+ ASSERT(edge->vrtx0 <= VRTX_MAX__);
+ ASSERT(edge->vrtx1 <= VRTX_MAX__);
+ vrtx_id[0] = edge->vrtx0;
+ vrtx_id[1] = edge->vrtx1;
return RES_OK;
}
diff --git a/src/senc3d_enclosure.c b/src/senc3d_enclosure.c
@@ -45,7 +45,7 @@ enclosure_release(ref_T * ref)
struct senc3d_enclosure*
enclosure_create
(struct senc3d_scene* scn,
- const unsigned idx)
+ const enclosure_id_t idx)
{
struct senc3d_enclosure* enc;
ASSERT(scn && idx < darray_enclosure_size_get(&scn->analyze.enclosures));
@@ -77,8 +77,8 @@ senc3d_enclosure_get_header
res_T
senc3d_enclosure_get_triangle
(const struct senc3d_enclosure* enclosure,
- const unsigned itri,
- unsigned indices[3])
+ const trg_id_t itri,
+ vrtx_id_t indices[3])
{
const struct side_enc* side;
int i;
@@ -88,17 +88,14 @@ senc3d_enclosure_get_triangle
ASSERT(darray_sides_enc_size_get(&enclosure->data->sides)
== enclosure->data->header.primitives_count);
side = darray_sides_enc_cdata_get(&enclosure->data->sides) + itri;
- FOR_EACH(i, 0, 3) {
- ASSERT(side->vertice_id[i] < UINT_MAX);
- indices[i] = (unsigned)side->vertice_id[i]; /* Back to API type */
- }
+ FOR_EACH(i, 0, 3) indices[i] = side->vertice_id[i];
return RES_OK;
}
res_T
senc3d_enclosure_get_vertex
(const struct senc3d_enclosure* enclosure,
- const unsigned ivert,
+ const vrtx_id_t ivert,
double coord[3])
{
if(!enclosure || !coord
@@ -119,8 +116,8 @@ senc3d_enclosure_get_vertex
res_T
senc3d_enclosure_get_triangle_id
(const struct senc3d_enclosure* enclosure,
- const unsigned itri,
- unsigned* gid,
+ const trg_id_t itri,
+ trg_id_t* gid,
enum senc3d_side* sde)
{
const struct side_enc* side;
@@ -130,7 +127,7 @@ senc3d_enclosure_get_triangle_id
ASSERT(darray_sides_enc_size_get(&enclosure->data->sides)
== enclosure->data->header.primitives_count);
side = darray_sides_enc_cdata_get(&enclosure->data->sides) + itri;
- *gid = (unsigned)TRGSIDE_2_TRG(side->side_id);
+ *gid = TRGSIDE_2_TRG(side->side_id);
*sde = TRGSIDE_2_SIDE(side->side_id);
return RES_OK;
}
@@ -138,8 +135,8 @@ senc3d_enclosure_get_triangle_id
res_T
senc3d_enclosure_get_medium
(const struct senc3d_enclosure* enclosure,
- const unsigned imed,
- unsigned* medium)
+ const medium_id_t imed,
+ medium_id_t* medium)
{
if(!enclosure || !medium
|| imed >= enclosure->data->header.enclosed_media_count)
diff --git a/src/senc3d_enclosure_c.h b/src/senc3d_enclosure_c.h
@@ -19,6 +19,7 @@
#include <rsys/ref_count.h>
#include "senc3d.h"
+#include "senc3d_internal_types.h"
struct enclosure_data;
struct senc3d_scene;
@@ -32,6 +33,6 @@ struct senc3d_enclosure {
struct senc3d_enclosure*
enclosure_create
(struct senc3d_scene* scene,
- const unsigned idx);
+ const enclosure_id_t idx);
#endif /* SENC3D_ENCLOSURE_C_H */
diff --git a/src/senc3d_enclosure_data.h b/src/senc3d_enclosure_data.h
@@ -46,10 +46,10 @@ struct side_enc {
#define DARRAY_DATA struct side_enc
#include <rsys/dynamic_array.h>
-/* unsigned char array with init to zero */
+/* uchar array with init to zero */
static FINLINE void
zero_init_uchar
- (struct mem_allocator* alloc, unsigned char* data)
+ (struct mem_allocator* alloc, uchar* data)
{
ASSERT(data); (void) alloc;
*data = 0;
@@ -76,19 +76,17 @@ init_header(struct senc3d_enclosure_header* header)
static FINLINE res_T
bool_array_of_media_merge
(struct darray_uchar* dst,
- const unsigned char* src,
+ const uchar* src,
const medium_id_t sz)
{
res_T res = RES_OK;
medium_id_t i;
- unsigned char* data_dst;
+ uchar* data_dst;
ASSERT(src && dst);
OK(darray_uchar_resize(dst, sz));
data_dst = darray_uchar_data_get(dst);
- ASSERT(sz <= MEDIUM_MAX__);
- if(res != RES_OK) goto error;
FOR_EACH(i, 0, sz) {
if(!src[i]) continue;
data_dst[i] = 1;
@@ -106,19 +104,21 @@ bool_array_of_media_to_darray_media
const medium_id_t next_medium_idx)
{
res_T res = RES_OK;
- unsigned m_idx;
- const unsigned char* data;
+ size_t m_idx;
+ const uchar* data;
ASSERT(src && dst);
data = darray_uchar_cdata_get(src);
ASSERT(next_medium_idx + 1 == darray_uchar_size_get(src));
- ASSERT(next_medium_idx < MEDIUM_MAX__);
darray_media_clear(dst);
if(res != RES_OK) goto error;
+ ASSERT(next_medium_idx <= MEDIUM_MAX__ + 1);
FOR_EACH(m_idx, 0, next_medium_idx + 1) {
- medium_id_t medium = m_idx ? (medium_id_t)(m_idx - 1) : SENC3D_UNSPECIFIED_MEDIUM;
+ medium_id_t medium;
+ size_t mm = m_idx ? (medium_id_t)(m_idx - 1) : SENC3D_UNSPECIFIED_MEDIUM;
if(!data[m_idx]) continue;
+ medium = (medium_id_t)mm;
res = darray_media_push_back(dst, &medium);
if(res != RES_OK) goto error;
}
diff --git a/src/senc3d_internal_types.h b/src/senc3d_internal_types.h
@@ -46,51 +46,60 @@
}
#endif
-/* Side IDs are uint32_t */
-typedef uint32_t side_id_t;
-#define SIDE_MAX__ (UINT32_MAX-1)
-#define SIDE_NULL__ UINT32_MAX
-
-/* Trg IDs use internally side_id_t */
-/* Cannot be larger than unsigned, as the API uses it. */
-typedef side_id_t trg_id_t;
-/* TRG_MAX__ is limited to allow to count sides */
-#define TRG_MAX__ (SIDE_MAX__ / 2)
-#define TRG_NULL__ UINT32_MAX
-
-/* Vertex IDs are internally uint32_t */
-/* Cannot be larger than unsigned, as the API uses it. */
-typedef uint32_t vrtx_id_t;
-#define VRTX_MAX__ (UINT32_MAX-1)
-#define VRTX_NULL__ UINT32_MAX
+/* Helper type */
+typedef unsigned char uchar;
+
+/* The following types must be defined accordingly with the types
+ * used in senc2d.h */
+
+/* Trg IDs use the same type than Side IDs */
+typedef unsigned trg_id_t;
+/* TRG_MAX__ is limited to half the max of the base type to allow to count
+ * sides */
+#define TRG_MAX__ (UINT_MAX/2)
+#define TRG_NULL__ UINT_MAX
+#define PRTF_TRG "%u"
+
+/* Side IDs type use the same base type than Trg IDs */
+typedef trg_id_t side_id_t;
+#define SIDE_MAX__ (2*TRG_MAX__)
+#define SIDE_NULL__ TRG_NULL__
+
+/* Vertex IDs type */
+typedef unsigned vrtx_id_t;
+#define VRTX_MAX__ (UINT_MAX-1)
+#define VRTX_NULL__ UINT_MAX
+#define PRTF_VRTX "%u"
/* Edge IDs use the same type than vertex IDs */
-/* Cannot be larger than unsigned, as the API uses it. */
typedef vrtx_id_t edge_id_t;
#define EDGE_MAX__ VRTX_MAX__
#define EDGE_NULL__ VRTX_NULL__
-/* Medium IDs are internally uint32_t */
-/* Should nnot be larger than unsigned, as the API uses it. */
-typedef uint32_t medium_id_t;
-#define MEDIUM_MAX__ INT32_MAX
-#define MEDIUM_NULL__ UINT32_MAX
+/* Medium IDs type */
+typedef unsigned medium_id_t;
+#define MEDIUM_MAX__ (UINT_MAX-1) /* MAX is for unspecified medium */
+#define MEDIUM_NULL__ UINT_MAX
+#define PRTF_MDM "%u"
-/* Enclosure IDs are internally uint32_t */
-/* Cannot be larger than unsigned, as the API uses it. */
-typedef uint32_t enclosure_id_t;
-#define ENCLOSURE_MAX__ UINT32_MAX
-#define ENCLOSURE_NULL__ UINT32_MAX
+/* Enclosure IDs type */
+typedef unsigned enclosure_id_t;
+#define ENCLOSURE_MAX__ (UINT_MAX-1)
+#define ENCLOSURE_NULL__ UINT_MAX
/* Component IDs use the same type than enclosure IDs */
typedef enclosure_id_t component_id_t;
-#define COMPONENT_MAX__ (UINT32_MAX - 2) /* To allow special values */
-#define COMPONENT_NULL__ UINT32_MAX
+#define COMPONENT_MAX__ (UINT_MAX-2) /* To allow special values */
+#define COMPONENT_NULL__ UINT_MAX
/* Special values */
-#define CC_GROUP_ROOT_NONE UINT32_MAX
-#define CC_GROUP_ROOT_INFINITE (UINT32_MAX - 1)
-#define CC_GROUP_ID_NONE UINT32_MAX
-#define CC_ID_NONE UINT32_MAX
+#define CC_GROUP_ROOT_NONE UINT_MAX
+#define CC_GROUP_ROOT_INFINITE (UINT_MAX-1)
+#define CC_GROUP_ID_NONE UINT_MAX
+#define CC_ID_NONE UINT_MAX
+
+#if (MEDIUM_MAX__+1 != SENC3D_UNSPECIFIED_MEDIUM)
+#error "Inconsistant values"
+#endif
/* This one is used as flag */
enum side_flag {
@@ -120,17 +129,19 @@ TRGSIDE_2_SIDEFLAG(side_id_t s) {
return (s & 1) ? FLAG_BACK : FLAG_FRONT;
}
-static FINLINE unsigned char
+static FINLINE uchar
SIDE_CANCELED_FLAG(enum side_flag f) {
ASSERT((f << 4) <= UCHAR_MAX);
- return (unsigned char)(f << 4);
+ return (uchar)(f << 4);
}
static FINLINE side_id_t
TRGIDxSIDE_2_TRGSIDE(trg_id_t t, enum senc3d_side i) {
- ASSERT((((size_t)t << 1) | (i == SENC3D_BACK)) < SIDE_MAX__);
+ size_t r;
ASSERT(i == SENC3D_FRONT || i == SENC3D_BACK);
- return (side_id_t)((t << 1) | (i == SENC3D_BACK));
+ r = (t << 1) | (i == SENC3D_BACK);
+ ASSERT(r <= SIDE_MAX__);
+ return (side_id_t)r;
}
static FINLINE side_id_t
diff --git a/src/senc3d_scene.c b/src/senc3d_scene.c
@@ -64,11 +64,11 @@ res_T
senc3d_scene_create
(struct senc3d_device* dev,
const int conv,
- const unsigned ntris,
- void(*indices)(const unsigned, unsigned*, void*),
- void(*media)(const unsigned, unsigned*, void*),
- const unsigned nverts,
- void(*position)(const unsigned, double*, void* ctx),
+ const trg_id_t ntris,
+ void(*indices)(const trg_id_t, vrtx_id_t*, void*),
+ void(*media)(const trg_id_t, medium_id_t*, void*),
+ const vrtx_id_t nverts,
+ void(*position)(const vrtx_id_t, double*, void* ctx),
void* ctx,
struct senc3d_scene** out_scn)
{
@@ -76,10 +76,11 @@ senc3d_scene_create
/* Tables to detect duplicates */
struct htable_vrtx unique_vertices;
struct htable_trg unique_triangles;
- unsigned i;
+ vrtx_id_t nv;
+ trg_id_t nt;
res_T res = RES_OK;
- if(!dev || !out_scn || !indices || !position
+ if(!dev || !out_scn || !indices || !position || !nverts || !ntris
/* Convention must be set both regarding FRONT/BACK and INSIDE/OUTSIDE */
|| !(conv & (SENC3D_CONVENTION_NORMAL_FRONT | SENC3D_CONVENTION_NORMAL_BACK))
|| !(conv & (SENC3D_CONVENTION_NORMAL_INSIDE | SENC3D_CONVENTION_NORMAL_OUTSIDE)))
@@ -113,48 +114,46 @@ senc3d_scene_create
OK(darray_enclosure_resize(&scn->analyze.enclosures, 1));
scn->analyze.enclosures_count = 1;
- if(!scn || !indices || !position || !nverts || !ntris) {
- res = RES_BAD_ARG;
- goto error;
- }
-
OK(darray_position_reserve(&scn->vertices, scn->nverts));
OK(darray_triangle_in_reserve(&scn->triangles_in, scn->ntris));
OK(htable_vrtx_reserve(&unique_vertices, scn->nverts));
OK(htable_trg_reserve(&unique_triangles, scn->ntris));
/* Get vertices */
- FOR_EACH(i, 0, nverts) {
+ FOR_EACH(nv, 0, nverts) {
vrtx_id_t* p_vrtx;
union double3 tmp;
- /* API: position needs an unsigned */
- position(i, tmp.vec, ctx);
+ /* API: position needs an api_t */
+ position(nv, tmp.vec, ctx);
p_vrtx = htable_vrtx_find(&unique_vertices, &tmp);
if(p_vrtx) {
/* Duplicate vertex */
- log_err(scn->dev, "%s: vertex %u is a duplicate.\n",
- FUNC_NAME, i);
+ log_err(scn->dev, "%s: vertex "PRTF_VRTX" is a duplicate.\n",
+ FUNC_NAME, nv);
res = RES_BAD_ARG;
goto error;
}
/* New vertex */
- ASSERT(i == htable_vrtx_size_get(&unique_vertices));
+ ASSERT(nv == htable_vrtx_size_get(&unique_vertices));
OK(darray_position_push_back(&scn->vertices, &tmp));
- OK(htable_vrtx_set(&unique_vertices, &tmp, &i));
+ OK(htable_vrtx_set(&unique_vertices, &tmp, &nv));
}
/* Get triangles */
- FOR_EACH(i, 0, ntris) {
+ FOR_EACH(nt, 0, ntris) {
int j;
- unsigned med[2] = { SENC3D_UNSPECIFIED_MEDIUM, SENC3D_UNSPECIFIED_MEDIUM };
- unsigned ind[3];
+ trg_id_t s;
+ medium_id_t med[2]
+ = { SENC3D_UNSPECIFIED_MEDIUM, SENC3D_UNSPECIFIED_MEDIUM };
+ vrtx_id_t ind[3];
union vrtx_id3 trg_key;
struct triangle_in tmp;
trg_id_t* p_trg;
- indices(i, ind, ctx); /* API: indices need unsigneds */
+ indices(nt, ind, ctx);
FOR_EACH(j, 0, 3) {
if(ind[j] >= nverts) {
- log_err(scn->dev, "%s: triangle %u uses invalid vertex id %u.\n",
- FUNC_NAME, i, ind[j]);
+ log_err(scn->dev,
+ "%s: triangle "PRTF_TRG" uses invalid vertex id "PRTF_VRTX".\n",
+ FUNC_NAME, nt, ind[j]);
res = RES_BAD_ARG;
goto error;
}
@@ -165,40 +164,50 @@ senc3d_scene_create
|| tmp.vertice_id[0] == tmp.vertice_id[2]
|| tmp.vertice_id[1] == tmp.vertice_id[2])
{
- log_err(scn->dev, "%s: triangle %u is degenerated.\n",
- FUNC_NAME, i);
+ log_err(scn->dev, "%s: triangle "PRTF_TRG" is degenerated.\n",
+ FUNC_NAME, nt);
res = RES_BAD_ARG;
goto error;
}
/* Get media */
- if(media) media(i, med, ctx); /* API: media needs an unsigned */
+ if(media) {
+ media(nt, med, ctx);
+ for(s = SENC3D_FRONT; s <= SENC3D_BACK; s += SENC3D_BACK - SENC3D_FRONT) {
+ if(med[s] == SENC3D_UNSPECIFIED_MEDIUM || med[s] <= MEDIUM_MAX__)
+ continue;
+ res = RES_BAD_ARG;
+ goto error;
+ }
+ }
trg_make_key(&trg_key, tmp.vertice_id);
p_trg = htable_trg_find(&unique_triangles, &trg_key);
if(p_trg) {
/* Duplicate triangle */
- log_err(scn->dev, "%s: triangle %u is a duplicate.\n",
- FUNC_NAME, i);
+ log_err(scn->dev, "%s: triangle "PRTF_TRG" is a duplicate.\n",
+ FUNC_NAME, nt);
res = RES_BAD_ARG;
goto error;
}
/* New triangle */
- ASSERT(i == htable_trg_size_get(&unique_triangles));
- OK(htable_trg_set(&unique_triangles, &trg_key, &i));
- FOR_EACH(j, 0, 2) {
+ ASSERT(nt == htable_trg_size_get(&unique_triangles));
+ OK(htable_trg_set(&unique_triangles, &trg_key, &nt));
+ for(s = SENC3D_FRONT; s <= SENC3D_BACK; s += SENC3D_BACK - SENC3D_FRONT) {
struct side_range* media_use;
- unsigned m_idx = (med[j] == SENC3D_UNSPECIFIED_MEDIUM) ? 0 : med[j] + 1;
- tmp.medium[j] = (medium_id_t)med[j];
+ size_t m_idx = (med[s] == SENC3D_UNSPECIFIED_MEDIUM) ? 0 : med[s] + 1;
+ tmp.medium[s] = med[s];
if(m_idx >= scn->next_medium_idx) {
- scn->next_medium_idx = m_idx;
+ medium_id_t medium;
+ medium = (medium_id_t)m_idx;
+ scn->next_medium_idx = medium;
darray_side_range_resize(&scn->media_use, 1 + m_idx);
}
/* media_use 0 is for SENC3D_UNSPECIFIED_MEDIUM */
media_use = darray_side_range_data_get(&scn->media_use) + m_idx;
media_use->first =
- MMIN(media_use->first, TRGIDxSIDE_2_TRGSIDE((trg_id_t)i, j));
+ MMIN(media_use->first, TRGIDxSIDE_2_TRGSIDE((trg_id_t)nt, s));
ASSERT(media_use->first < 2 * (scn->ntris + 1));
media_use->last =
- MMAX(media_use->last, TRGIDxSIDE_2_TRGSIDE((trg_id_t)i, j));
+ MMAX(media_use->last, TRGIDxSIDE_2_TRGSIDE((trg_id_t)nt, s));
ASSERT(media_use->last < 2 * (scn->ntris + 1));
ASSERT(media_use->first <= media_use->last);
}
@@ -237,7 +246,7 @@ senc3d_scene_get_convention
res_T
senc3d_scene_get_triangles_count
(const struct senc3d_scene* scn,
- unsigned* count)
+ trg_id_t* count)
{
if(!scn || !count) return RES_BAD_ARG;
*count = scn->ntris;
@@ -247,8 +256,8 @@ senc3d_scene_get_triangles_count
res_T
senc3d_scene_get_triangle
(const struct senc3d_scene* scn,
- const unsigned itri,
- unsigned indices[3])
+ const trg_id_t itri,
+ vrtx_id_t indices[3])
{
const struct triangle_in* trg;
int i;
@@ -256,19 +265,15 @@ senc3d_scene_get_triangle
|| itri >= darray_triangle_in_size_get(&scn->triangles_in))
return RES_BAD_ARG;
trg = darray_triangle_in_cdata_get(&scn->triangles_in) + itri;
-
- FOR_EACH(i, 0, 3) {
- ASSERT(trg->vertice_id[i] < UINT_MAX);
- indices[i] = (unsigned)trg->vertice_id[i]; /* Back to API type */
- }
+ FOR_EACH(i, 0, 3) indices[i] = trg->vertice_id[i];
return RES_OK;
}
res_T
senc3d_scene_get_triangle_media
(const struct senc3d_scene* scn,
- const unsigned itri,
- unsigned media[2])
+ const trg_id_t itri,
+ medium_id_t media[2])
{
const struct triangle_in* trg;
int i;
@@ -276,18 +281,14 @@ senc3d_scene_get_triangle_media
|| itri >= darray_triangle_in_size_get(&scn->triangles_in))
return RES_BAD_ARG;
trg = darray_triangle_in_cdata_get(&scn->triangles_in) + itri;
-
- FOR_EACH(i, 0, 2) {
- ASSERT(trg->vertice_id[i] < UINT_MAX);
- media[i] = (unsigned)trg->medium[i]; /* Back to API type */
- }
+ FOR_EACH(i, 0, 2) media[i] = trg->medium[i];
return RES_OK;
}
res_T
senc3d_scene_get_vertices_count
(const struct senc3d_scene* scn,
- unsigned* count)
+ vrtx_id_t* count)
{
if(!scn || !count) return RES_BAD_ARG;
*count = scn->nverts;
@@ -297,14 +298,13 @@ senc3d_scene_get_vertices_count
res_T
senc3d_scene_get_vertex
(const struct senc3d_scene* scn,
- const unsigned ivert,
+ const vrtx_id_t ivert,
double coord[3])
{
const union double3* v;
if(!scn || !coord
|| ivert >= darray_position_size_get(&scn->vertices))
return RES_BAD_ARG;
-
v = darray_position_cdata_get(&scn->vertices) + ivert;
d3_set(coord, v->vec);
return RES_OK;
diff --git a/src/senc3d_scene_analyze.c b/src/senc3d_scene_analyze.c
@@ -68,7 +68,7 @@ static side_id_t
get_side_not_in_connex_component
(const side_id_t last_side,
const struct trgside* trgsides,
- const unsigned char* processed,
+ const uchar* processed,
side_id_t* first_side_not_in_component,
const medium_id_t medium)
{
@@ -86,6 +86,7 @@ get_side_not_in_connex_component
}
}
+/* Here unsigned are required by s3d API */
static void
get_scn_indices(const unsigned itri, unsigned ids[3], void* ctx) {
int i;
@@ -94,10 +95,12 @@ get_scn_indices(const unsigned itri, unsigned ids[3], void* ctx) {
darray_triangle_in_cdata_get(&scene->triangles_in) + itri;
FOR_EACH(i, 0, 3) {
ASSERT(trg->vertice_id[i] < scene->nverts);
- ids[i] = (unsigned)trg->vertice_id[i]; /* Back to API type */
+ ASSERT(trg->vertice_id[i] <= UINT_MAX);
+ ids[i] = (unsigned)trg->vertice_id[i]; /* Back to s3d API type */
}
}
+/* Here unsigned are required by s3d API */
static void
get_scn_position(const unsigned ivert, float pos[3], void* ctx) {
const struct senc3d_scene* scene = ctx;
@@ -144,18 +147,18 @@ extract_connex_components
/* This function is called from an omp parallel block and executed
* concurrently. */
struct mem_allocator* alloc;
- int64_t m_idx;
+ int64_t m_idx; /* OpenMP requires a signed type for the for loop variable */
struct darray_side_id stack;
struct darray_side_id ids_of_sides_around_max_z_vertex;
const union double3* positions;
const struct triangle_tmp* triangles_tmp;
struct triangle_comp* triangles_comp;
/* An array to flag sides when processed */
- unsigned char* processed;
+ uchar* processed;
/* An array to store the component being processed */
struct darray_side_id current_component;
/* A bool array to store media of the component being processed */
- unsigned char* current_media = NULL;
+ uchar* current_media = NULL;
size_t sz, ii;
ASSERT(scn && trgsides && connex_components && triangles_tmp_array
@@ -167,7 +170,7 @@ extract_connex_components
darray_side_id_init(alloc, &stack);
darray_side_id_init(alloc, &ids_of_sides_around_max_z_vertex);
darray_side_id_init(alloc, ¤t_component);
- processed = MEM_CALLOC(alloc, scn->ntris, sizeof(unsigned char));
+ processed = MEM_CALLOC(alloc, scn->ntris, sizeof(uchar));
if(!processed) {
*p_res = RES_MEM_ERR;
return;
@@ -265,7 +268,7 @@ extract_connex_components
const trg_id_t crt_trg_id = TRGSIDE_2_TRG(crt_side_id);
const struct triangle_in* trg_in =
darray_triangle_in_cdata_get(&scn->triangles_in) + crt_trg_id;
- unsigned char* trg_used = processed + crt_trg_id;
+ uchar* trg_used = processed + crt_trg_id;
const struct triangle_tmp* const trg_tmp = triangles_tmp + crt_trg_id;
ASSERT(crt_trg_id < scn->ntris);
@@ -308,7 +311,7 @@ extract_connex_components
/* Record crt_side both as component and triangle level */
if((*trg_used & crt_side_flag) == 0) {
OK2(darray_side_id_push_back(¤t_component, &crt_side_id));
- *trg_used = *trg_used | (unsigned char)crt_side_flag;
+ *trg_used = *trg_used | (uchar)crt_side_flag;
}
/* Store neighbour's sides in a waiting stack */
@@ -316,7 +319,7 @@ extract_connex_components
side_id_t neighbour_id = crt_side->facing_side_id[i];
trg_id_t nbour_trg_id = TRGSIDE_2_TRG(neighbour_id);
enum side_flag nbour_side_id = TRGSIDE_2_SIDEFLAG(neighbour_id);
- unsigned char* nbour_used = processed + nbour_trg_id;
+ uchar* nbour_used = processed + nbour_trg_id;
const struct trgside* neighbour = trgsides + neighbour_id;
medium_id_t nbour_med_idx = (neighbour->medium == SENC3D_UNSPECIFIED_MEDIUM)
? 0 : neighbour->medium + 1;
@@ -342,8 +345,8 @@ extract_connex_components
trg_id_t used_trg_id = TRGSIDE_2_TRG(used_side);
enum side_flag used_side_flag
= TRGSIDE_2_SIDEFLAG(used_side);
- unsigned char* used = processed + used_trg_id;
- ASSERT(*used & (unsigned char)used_side_flag);
+ uchar* used = processed + used_trg_id;
+ ASSERT(*used & (uchar)used_side_flag);
/* Set the used flag for sides in cancelled component as leading
* to further cancellations */
*used |= SIDE_CANCELED_FLAG(used_side_flag);
@@ -353,7 +356,7 @@ extract_connex_components
}
if(*nbour_used & nbour_side_id) continue; /* Already processed */
/* Mark neighbour as processed and stack it */
- *nbour_used |= (unsigned char)nbour_side_id;
+ *nbour_used |= (uchar)nbour_side_id;
OK2(darray_side_id_push_back(&stack, &neighbour_id));
OK2(darray_side_id_push_back(¤t_component, &neighbour_id));
current_media[nbour_med_idx] = 1;
@@ -499,9 +502,9 @@ extract_connex_components
OK(s3d_scene_create(s3d, &s3d_scn));
OK(s3d_shape_create_mesh(s3d, &s3d_shp));
- /* Back to API type for ntris and nverts */
- ASSERT(scn->ntris < UINT_MAX);
- ASSERT(scn->nverts < UINT_MAX);
+ /* Back to s3d API type for ntris and nverts */
+ ASSERT(scn->ntris <= UINT_MAX);
+ ASSERT(scn->nverts <= UINT_MAX);
OK(s3d_mesh_setup_indexed_vertices(s3d_shp,
(unsigned)scn->ntris, get_scn_indices,
(unsigned)scn->nverts, &attribs, 1, scn));
@@ -532,7 +535,7 @@ extract_connex_components
ASSERT(trg_comp->component[SENC3D_FRONT] != COMPONENT_NULL__);
ASSERT(trg_comp->component[SENC3D_BACK] != COMPONENT_NULL__);
}
- FOR_EACH(c, 0, ATOMIC_GET(component_count)) {
+ FOR_EACH(c, 0, (component_id_t)ATOMIC_GET(component_count)) {
struct cc_descriptor** components =
darray_ptr_component_descriptor_data_get(connex_components);
ASSERT(components[c] != NULL && components[c]->cc_id == c);
@@ -634,14 +637,15 @@ group_connex_components
}
}
/* Implicit barrier here */
- ASSERT(ATOMIC_GET(next_enclosure_id) < ENCLOSURE_MAX__);
if(*res != RES_OK) return;
/* One thread post-processes links to group connex components */
#pragma omp single
{
res_T tmp_res = RES_OK;
- scn->analyze.enclosures_count = (enclosure_id_t)ATOMIC_GET(next_enclosure_id);
+ size_t ec = ATOMIC_GET(next_enclosure_id);
+ ASSERT(ec <= ENCLOSURE_MAX__);
+ scn->analyze.enclosures_count = (enclosure_id_t)ec;
tmp_res = darray_enclosure_resize(&scn->analyze.enclosures,
scn->analyze.enclosures_count);
if(tmp_res != RES_OK) {
@@ -649,7 +653,7 @@ group_connex_components
} else {
struct enclosure_data* enclosures
= darray_enclosure_data_get(&scn->analyze.enclosures);
- FOR_EACH(ccc, 0, cc_count) {
+ FOR_EACH(ccc, 0, (int64_t)cc_count) {
component_id_t c = (component_id_t)ccc;
struct cc_descriptor* const cc = descriptors[c];
const struct cc_descriptor* other_desc = cc;
@@ -741,7 +745,7 @@ collect_and_link_neighbours
* All threads considering all the edges and processing some */
FOR_EACH(t, 0, scn->ntris) {
struct trg_edge edge;
- unsigned char ee;
+ uchar ee;
FOR_EACH(ee, 0, 3) {
edge_id_t* p_id;
size_t n_sz;
@@ -818,7 +822,7 @@ collect_and_link_neighbours
struct neighbour_info* neighbour_info
= darray_neighbour_data_get(neighbour_list) + i;
const trg_id_t crt_id = neighbour_info->trg_id;
- const unsigned char crt_edge = neighbour_info->common_edge_rank;
+ const uchar crt_edge = neighbour_info->common_edge_rank;
const struct triangle_in* trg_in = triangles_in + crt_id;
struct triangle_tmp* neighbour = triangles_tmp + crt_id;
union double3 n; /* Geometrical normal to neighbour triangle */
@@ -869,11 +873,11 @@ collect_and_link_neighbours
const struct neighbour_info* ccw_neighbour
= darray_neighbour_cdata_get(neighbour_list) + (i + 1) % neighbour_count;
/* Rank of the edge of interest in triangles */
- const unsigned char crt_edge = current->common_edge_rank;
+ const uchar crt_edge = current->common_edge_rank;
/* Here ccw refers to the rotation around the common edge
* and has nothing to do with vertices order in triangle definition
* nor Front/Back side convention */
- const unsigned char ccw_edge = ccw_neighbour->common_edge_rank;
+ const uchar ccw_edge = ccw_neighbour->common_edge_rank;
/* User id of current triangles */
const trg_id_t crt_id = current->trg_id;
const trg_id_t ccw_id = ccw_neighbour->trg_id;
@@ -900,8 +904,8 @@ collect_and_link_neighbours
previous = darray_neighbour_cdata_get(neighbour_list) + i - 1;
prev_id = previous->trg_id;
log_err(scn->dev,
- "%s: found 2 overlying triangles (%u & %u).\n", FUNC_NAME,
- (unsigned)crt_id, (unsigned)prev_id);
+ "%s: found 2 overlying triangles ("PRTF_TRG" & "PRTF_TRG").\n",
+ FUNC_NAME, crt_id, prev_id);
tmp_res = RES_BAD_OP;
goto tmp_error;
}
@@ -931,8 +935,8 @@ collect_and_link_neighbours
{
struct trg_edge disc;
log_warn(scn->dev,
- "%s: found frontier involving triangle %lu.\n",
- FUNC_NAME, (unsigned long)crt_id);
+ "%s: found frontier involving triangle "PRTF_TRG".\n",
+ FUNC_NAME, crt_id);
disc.vrtx0 = v0;
disc.vrtx1 = v1;
darray_frontier_edge_push_back(frontiers, &disc);
@@ -1031,24 +1035,24 @@ build_result
== enc->first_component);
if(*res != RES_OK) continue;
- ASSERT(e <= UINT_MAX);
- enc->header.enclosure_id = (unsigned)e; /* Back to API type */
+ ASSERT(e <= ENCLOSURE_MAX__);
+ enc->header.enclosure_id = (enclosure_id_t)e; /* Back to API type */
ASSERT(cc_descriptors[enc->first_component]->enclosure_id
== enc->header.enclosure_id);
enc->header.is_infinite = (e == 0);
- ASSERT(darray_uchar_size_get(&enc->tmp_enclosed_media) <= UINT_MAX);
ASSERT(enc->header.enclosed_media_count < 1 + scn->next_medium_idx);
OK2(bool_array_of_media_to_darray_media
(&enc->enclosed_media, &enc->tmp_enclosed_media, scn->next_medium_idx));
+ ASSERT(darray_media_size_get(&enc->enclosed_media) <= MEDIUM_MAX__);
enc->header.enclosed_media_count
- = (unsigned)darray_media_size_get(&enc->enclosed_media);
+ = (medium_id_t)darray_media_size_get(&enc->enclosed_media);
darray_uchar_purge(&enc->tmp_enclosed_media);
/* Add this enclosure in relevant by-medium lists */
FOR_EACH(m, 0, enc->header.enclosed_media_count) {
medium_id_t medium = darray_media_cdata_get(&enc->enclosed_media)[m];
- unsigned m_idx = (medium == SENC3D_UNSPECIFIED_MEDIUM) ? 0 : medium + 1;
+ size_t m_idx = (medium == SENC3D_UNSPECIFIED_MEDIUM) ? 0 : medium + 1;
struct darray_enc_id* enc_ids_array_by_medium;
ASSERT(medium == SENC3D_UNSPECIFIED_MEDIUM || medium < scn->next_medium_idx);
ASSERT(darray_enc_ids_array_size_get(&scn->analyze.enc_ids_array_by_medium)
@@ -1082,7 +1086,7 @@ build_result
{
const struct triangle_in* trg_in = triangles_in + t;
struct side_enc* side_enc;
- unsigned vertice_id[3];
+ vrtx_id_t vertice_id[3];
int i;
if(triangles_enc[t].enclosure[SENC3D_FRONT] != e
&& triangles_enc[t].enclosure[SENC3D_BACK] != e)
diff --git a/src/senc3d_scene_analyze_c.h b/src/senc3d_scene_analyze_c.h
@@ -54,7 +54,7 @@ struct cc_descriptor {
/* Range of sides member of this component */
struct side_range side_range;
/* Media used by this component */
- unsigned char* media;
+ uchar* media;
};
extern const struct cc_descriptor CC_DESCRIPTOR_NULL;
@@ -113,7 +113,7 @@ custom_darray_ptr_component_descriptor_release
struct triangle_tmp {
/* Are the edges of the triangle defined in the same order than
* the edges they are linked to? */
- unsigned char reversed_edge[3];
+ uchar reversed_edge[3];
double max_z;
};
@@ -143,10 +143,10 @@ struct neighbour_info {
double angle;
trg_id_t trg_id;
/* Rank of the edge in the triangle (in [0 2]) */
- unsigned char common_edge_rank;
+ uchar common_edge_rank;
/* Does the geometrical normal point towards the next neighbour
* (if not, it points towards the previous one)? */
- unsigned char normal_toward_next_neighbour;
+ uchar normal_toward_next_neighbour;
};
#define DARRAY_NAME neighbour
#define DARRAY_DATA struct neighbour_info
diff --git a/src/senc3d_scene_c.h b/src/senc3d_scene_c.h
@@ -84,7 +84,7 @@ set_edge
(const vrtx_id_t vrtx0,
const vrtx_id_t vrtx1,
struct trg_edge* edge,
- unsigned char* reversed)
+ uchar* reversed)
{
ASSERT(edge && reversed && vrtx0 != vrtx1);
ASSERT(*reversed == UCHAR_MAX); /* Should not be already set. */
diff --git a/src/test_senc3d_cube_in_cube.c b/src/test_senc3d_cube_in_cube.c
@@ -295,7 +295,7 @@ main(int argc, char** argv)
if(header.enclosed_media_count == 2) {
/* A single internal enclosure has 2 media */
ASSERT(!header.is_infinite);
- ASSERT(e2 == ecount);
+ ASSERT(e2 == ecount); (void)e2;
e2 = e;
}
OK(senc3d_enclosure_ref_put(enclosure));
diff --git a/src/test_senc3d_sample_enclosure.c b/src/test_senc3d_sample_enclosure.c
@@ -69,8 +69,8 @@ main(int argc, char** argv)
S3D(scene_create(s3d, &s3d_scn));
S3D(shape_create_mesh(s3d, &s3d_shp));
S3D(mesh_setup_indexed_vertices(s3d_shp, header.primitives_count,
- senc3d_sXd_enclosure_get_indices, header.vertices_count, &vrtx_get, 1,
- enclosure));
+ senc3d_sXd_enclosure_get_indices, header.vertices_count,
+ &vrtx_get, 1, enclosure));
S3D(scene_attach_shape(s3d_scn, s3d_shp));
S3D(scene_view_create(s3d_scn, S3D_SAMPLE, &s3d_view));
diff --git a/src/test_senc3d_utils.h b/src/test_senc3d_utils.h
@@ -162,8 +162,8 @@ dump_global
FOR_EACH(i, 0, triangles_count) {
unsigned indices[3];
OK(senc3d_scene_get_triangle(scn, i, indices));
- fprintf(stream, "f %lu %lu %lu\n", (unsigned long)(1 + indices[0]),
- (unsigned long)(1 + indices[1]), (unsigned long)(1 + indices[2]));
+ fprintf(stream, "f %u %u %u\n",
+ 1 + indices[0], 1 + indices[1], 1 + indices[2]);
}
fclose(stream);
}
@@ -196,8 +196,8 @@ dump_enclosure
FOR_EACH(i, 0, header.primitives_count) {
unsigned indices[3];
OK(senc3d_enclosure_get_triangle(enclosure, i, indices));
- fprintf(stream, "f %lu %lu %lu\n", (unsigned long)(1+indices[0]),
- (unsigned long)(1+indices[1]), (unsigned long)(1+indices[2]));
+ fprintf(stream, "f %u %u %u\n",
+ 1+indices[0], 1+indices[1], 1+indices[2]);
}
OK(senc3d_enclosure_ref_put(enclosure));
fclose(stream);
diff --git a/src/test_senc3d_utils2.h b/src/test_senc3d_utils2.h
@@ -104,4 +104,5 @@ get_s3dut_media(const unsigned itri, unsigned medium[2], void* context)
medium[ctx->ctx.reverse_med ? SENC3D_BACK : SENC3D_FRONT] = (unsigned)k;
medium[ctx->ctx.reverse_med ? SENC3D_FRONT : SENC3D_BACK] = (unsigned)(k + 1);
}
+
#endif /* TEST_UTILS2_H */
