senc3d_enclosure_data.h (6655B)
1 /* Copyright (C) 2018-2020, 2023, 2024 |Méso|Star> (contact@meso-star.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 3 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 15 16 #ifndef SENC3D_ENCLOSURE_DATA_H 17 #define SENC3D_ENCLOSURE_DATA_H 18 19 #include "senc3d.h" 20 #include "senc3d_internal_types.h" 21 #include "senc3d_side_range.h" 22 23 #include <rsys/rsys.h> 24 #include <rsys/ref_count.h> 25 #include <rsys/hash_table.h> 26 #include <rsys/dynamic_array.h> 27 #include <rsys/hash_table.h> 28 29 #include <limits.h> 30 31 #define DARRAY_NAME vrtx_id 32 #define DARRAY_DATA vrtx_id_t 33 #include <rsys/dynamic_array.h> 34 35 #define HTABLE_NAME vrtx_id 36 #define HTABLE_KEY vrtx_id_t 37 #define HTABLE_DATA vrtx_id_t 38 #include <rsys/hash_table.h> 39 40 struct side_enc { 41 vrtx_id_t vertice_id[3]; 42 side_id_t side_id; 43 }; 44 45 #define DARRAY_NAME sides_enc 46 #define DARRAY_DATA struct side_enc 47 #include <rsys/dynamic_array.h> 48 49 /* uchar array with init to zero */ 50 static FINLINE void 51 zero_init_uchar 52 (struct mem_allocator* alloc, uchar* data) 53 { 54 ASSERT(data); (void) alloc; 55 *data = 0; 56 } 57 #define DARRAY_FUNCTOR_INIT zero_init_uchar 58 #include <rsys/dynamic_array_uchar.h> 59 60 static void 61 init_header(struct senc3d_enclosure_header* header) 62 { 63 ASSERT(header); 64 header->enclosure_id = ENCLOSURE_NULL__; 65 header->primitives_count = 0; 66 header->unique_primitives_count = 0; 67 header->vertices_count = 0; 68 header->enclosed_media_count = 0; 69 header->is_infinite = INT_MAX; 70 header->volume = 0; 71 header->area = 0; 72 } 73 74 #define DARRAY_NAME media 75 #define DARRAY_DATA medium_id_t 76 #include <rsys/dynamic_array.h> 77 78 static FINLINE res_T 79 bool_array_of_media_merge 80 (struct darray_uchar* dst, 81 const uchar* src, 82 const unsigned count, 83 const size_t sz) 84 { 85 res_T res = RES_OK; 86 size_t i; 87 uchar* data_dst; 88 unsigned c = 0; 89 90 ASSERT(src && dst); 91 92 OK(darray_uchar_resize(dst, sz)); 93 data_dst = darray_uchar_data_get(dst); 94 FOR_EACH(i, 0, sz) { 95 if(!src[i]) continue; 96 data_dst[i] = 1; 97 if(++c == count) break; 98 } 99 end: 100 return res; 101 error: 102 goto end; 103 } 104 105 static FINLINE res_T 106 bool_array_of_media_to_darray_media 107 (struct darray_media* dst, 108 const struct darray_uchar* src, 109 const size_t sz) 110 { 111 res_T res = RES_OK; 112 int64_t m_idx; 113 const uchar* data; 114 115 ASSERT(src && dst && sz < INT64_MAX); 116 117 data = darray_uchar_cdata_get(src); 118 ASSERT(sz == darray_uchar_size_get(src)); 119 darray_media_clear(dst); 120 if(res != RES_OK) goto error; 121 FOR_EACH(m_idx, 0, (int64_t)sz) { 122 medium_id_t medium = medium_idx_2_medium_id(m_idx); 123 if(!data[m_idx]) continue; 124 res = darray_media_push_back(dst, &medium); 125 if(res != RES_OK) goto error; 126 } 127 end: 128 return res; 129 error: 130 goto end; 131 } 132 133 struct enclosure_data { 134 struct senc3d_enclosure_header header; 135 /* Same triangle can appear twice if both sides */ 136 struct darray_sides_enc sides; 137 /* Index of vertices in scene's unique vertices */ 138 struct darray_vrtx_id vertices; 139 /* List of the enclosed media */ 140 struct darray_uchar tmp_enclosed_media; 141 struct darray_media enclosed_media; 142 /* Number of components involved in this enclosure */ 143 component_id_t cc_count; 144 /* Linked list of the components */ 145 component_id_t first_component; 146 /* Range of triangles member of the enclosure */ 147 struct side_range side_range; 148 /* Counts */ 149 side_id_t side_count; 150 }; 151 152 static FINLINE void 153 enclosure_data_init(struct mem_allocator* alloc, struct enclosure_data* enc) { 154 ASSERT(enc); 155 init_header(&enc->header); 156 enc->cc_count = 0; 157 enc->first_component = COMPONENT_NULL__; 158 enc->side_range.first = SIDE_NULL__; 159 enc->side_range.last = 0; 160 enc->side_count = 0; 161 darray_sides_enc_init(alloc, &enc->sides); 162 darray_vrtx_id_init(alloc, &enc->vertices); 163 darray_uchar_init(alloc, &enc->tmp_enclosed_media); 164 darray_media_init(alloc, &enc->enclosed_media); 165 } 166 167 static FINLINE res_T 168 enclosure_data_copy 169 (struct enclosure_data* dst, 170 const struct enclosure_data* src) 171 { 172 res_T res = RES_OK; 173 ASSERT(src && dst); 174 dst->header = src->header; 175 dst->cc_count = src->cc_count; 176 dst->first_component = src->first_component; 177 dst->side_range = src->side_range; 178 dst->side_count = src->side_count; 179 OK(darray_sides_enc_copy(&dst->sides, &src->sides)); 180 OK(darray_vrtx_id_copy(&dst->vertices, &src->vertices)); 181 OK(darray_uchar_copy(&dst->tmp_enclosed_media, &src->tmp_enclosed_media)); 182 OK(darray_media_copy(&dst->enclosed_media, &src->enclosed_media)); 183 error: 184 return res; 185 } 186 187 static FINLINE void 188 enclosure_data_release(struct enclosure_data* n) { 189 ASSERT(n); 190 darray_sides_enc_release(&n->sides); 191 darray_vrtx_id_release(&n->vertices); 192 darray_uchar_release(&n->tmp_enclosed_media); 193 darray_media_release(&n->enclosed_media); 194 } 195 196 static FINLINE res_T 197 enclosure_data_copy_and_release 198 (struct enclosure_data* dst, 199 struct enclosure_data* src) 200 { 201 res_T res = RES_OK; 202 ASSERT(src && dst); 203 dst->header = src->header; 204 dst->cc_count = src->cc_count; 205 dst->first_component = src->first_component; 206 dst->side_range = src->side_range; 207 dst->side_count = src->side_count; 208 OK(darray_sides_enc_copy_and_release(&dst->sides, &src->sides)); 209 OK(darray_vrtx_id_copy_and_release(&dst->vertices, &src->vertices)); 210 OK(darray_uchar_copy_and_release(&dst->tmp_enclosed_media, 211 &src->tmp_enclosed_media)); 212 OK(darray_media_copy_and_release(&dst->enclosed_media, &src->enclosed_media)); 213 error: 214 return res; 215 } 216 217 #define DARRAY_NAME enclosure 218 #define DARRAY_DATA struct enclosure_data 219 #define DARRAY_FUNCTOR_INIT enclosure_data_init 220 #define DARRAY_FUNCTOR_COPY enclosure_data_copy 221 #define DARRAY_FUNCTOR_RELEASE enclosure_data_release 222 #define DARRAY_FUNCTOR_COPY_AND_RELEASE enclosure_data_copy_and_release 223 #include <rsys/dynamic_array.h> 224 225 #define DARRAY_NAME enc_id 226 #define DARRAY_DATA enclosure_id_t 227 #include <rsys/dynamic_array.h> 228 229 #define DARRAY_NAME enc_ids_array 230 #define DARRAY_DATA struct darray_enc_id 231 #define DARRAY_FUNCTOR_INIT darray_enc_id_init 232 #define DARRAY_FUNCTOR_COPY darray_enc_id_copy 233 #define DARRAY_FUNCTOR_RELEASE darray_enc_id_release 234 #define DARRAY_FUNCTOR_COPY_AND_RELEASE darray_enc_id_copy_and_release 235 #include <rsys/dynamic_array.h> 236 237 #endif /* SENC3D_ENCLOSURE_DATA_H */