senc2d_enclosure_data.h (6710B)
1 /* Copyright (C) 2018-2021, 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 SENC2D_ENCLOSURE_DATA_H 17 #define SENC2D_ENCLOSURE_DATA_H 18 19 #include "senc2d.h" 20 #include "senc2d_internal_types.h" 21 #include "senc2d_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[2]; 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) 55 alloc; 56 *data = 0; 57 } 58 #define DARRAY_FUNCTOR_INIT zero_init_uchar 59 #include <rsys/dynamic_array_uchar.h> 60 61 static void 62 init_header(struct senc2d_enclosure_header* header) 63 { 64 ASSERT(header); 65 header->enclosure_id = ENCLOSURE_NULL__; 66 header->primitives_count = 0; 67 header->unique_primitives_count = 0; 68 header->vertices_count = 0; 69 header->enclosed_media_count = 0; 70 header->is_infinite = INT_MAX; 71 header->volume = 0; 72 header->area = 0; 73 } 74 75 #define DARRAY_NAME media 76 #define DARRAY_DATA medium_id_t 77 #include <rsys/dynamic_array.h> 78 79 static FINLINE res_T 80 bool_array_of_media_merge 81 (struct darray_uchar* dst, 82 const uchar* src, 83 const medium_id_t sz) 84 { 85 res_T res = RES_OK; 86 medium_id_t i; 87 uchar* data_dst; 88 89 ASSERT(src && dst); 90 91 OK(darray_uchar_resize(dst, sz)); 92 data_dst = darray_uchar_data_get(dst); 93 if(res != RES_OK) goto error; 94 FOR_EACH(i, 0, sz) { 95 if(!src[i]) continue; 96 data_dst[i] = 1; 97 } 98 end: 99 return res; 100 error: 101 goto end; 102 } 103 104 static FINLINE res_T 105 bool_array_of_media_to_darray_media 106 (struct darray_media* dst, 107 const struct darray_uchar* src, 108 const medium_id_t next_medium_idx) 109 { 110 res_T res = RES_OK; 111 int64_t m_idx; 112 const uchar* data; 113 114 ASSERT(src && dst); 115 116 data = darray_uchar_cdata_get(src); 117 ASSERT(next_medium_idx + 1 == darray_uchar_size_get(src)); 118 darray_media_clear(dst); 119 if(res != RES_OK) goto error; 120 ASSERT(next_medium_idx <= MEDIUM_MAX__ + 1); 121 FOR_EACH(m_idx, 0, 1 + (int64_t)next_medium_idx) { 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 senc2d_enclosure_header header; 135 /* Same segments 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 segments 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 /* SENC2D_ENCLOSURE_DATA_H */