Visual Computing Library  devel
Loading...
Searching...
No Matches
face_components.h
1/*****************************************************************************
2 * VCLib *
3 * Visual Computing Library *
4 * *
5 * Copyright(C) 2021-2025 *
6 * Visual Computing Lab *
7 * ISTI - Italian National Research Council *
8 * *
9 * All rights reserved. *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the Mozilla Public License Version 2.0 as published *
13 * by the Mozilla Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * Mozilla Public License Version 2.0 *
20 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details. *
21 ****************************************************************************/
22
23#ifndef VCL_MESH_ELEMENTS_FACE_COMPONENTS_H
24#define VCL_MESH_ELEMENTS_FACE_COMPONENTS_H
25
26#include "../components/adjacent_edges.h"
27#include "../components/adjacent_faces.h"
28#include "../components/bit_flags.h"
29#include "../components/color.h"
30#include "../components/custom_components.h"
31#include "../components/mark.h"
32#include "../components/material_index.h"
33#include "../components/normal.h"
34#include "../components/parent_mesh_pointer.h"
35#include "../components/polygon_bit_flags.h"
36#include "../components/principal_curvature.h"
37#include "../components/quality.h"
38#include "../components/triangle_bit_flags.h"
39#include "../components/vertex_references.h"
40#include "../components/wedge_colors.h"
41#include "../components/wedge_tex_coords.h"
42
60namespace vcl::face {
61
67/* Port concepts into the face namespace */
68template<typename T>
69concept HasAdjacentEdges = comp::HasAdjacentEdges<T>;
70template<typename T>
71concept HasOptionalAdjacentEdges = comp::HasOptionalAdjacentEdges<T>;
72template<typename T>
73concept HasAdjacentFaces = comp::HasAdjacentFaces<T>;
74template<typename T>
75concept HasOptionalAdjacentFaces = comp::HasOptionalAdjacentFaces<T>;
76template<typename T>
77concept HasBitFlags = comp::HasBitFlags<T>;
78template<typename T>
79concept HasColor = comp::HasColor<T>;
80template<typename T>
81concept HasOptionalColor = comp::HasOptionalColor<T>;
82template<typename T>
83concept HasCustomComponents = comp::HasCustomComponents<T>;
84template<typename T>
85concept HasFaceBitFlags = comp::HasFaceBitFlags<T>;
86template<typename T>
87concept HasMark = comp::HasMark<T>;
88template<typename T>
89concept HasOptionalMark = comp::HasOptionalMark<T>;
90template<typename T>
91concept HasMaterialIndex = comp::HasMaterialIndex<T>;
92template<typename T>
93concept HasOptionalMaterialIndex = comp::HasOptionalMaterialIndex<T>;
94template<typename T>
95concept HasNormal = comp::HasNormal<T>;
96template<typename T>
97concept HasOptionalNormal = comp::HasOptionalNormal<T>;
98template<typename T>
99concept HasPolygonBitFlags = comp::HasPolygonBitFlags<T>;
100template<typename T>
101concept HasPrincipalCurvature = comp::HasPrincipalCurvature<T>;
102template<typename T>
103concept HasOptionalPrincipalCurvature = comp::HasOptionalPrincipalCurvature<T>;
104template<typename T>
105concept HasQuality = comp::HasQuality<T>;
106template<typename T>
107concept HasOptionalQuality = comp::HasOptionalQuality<T>;
108template<typename T>
109concept HasTriangleBitFlags = comp::HasTriangleBitFlags<T>;
110template<typename T>
111concept HasVertexReferences = comp::HasVertexReferences<T>;
112template<typename T>
113concept HasWedgeColors = comp::HasWedgeColors<T>;
114template<typename T>
115concept HasOptionalWedgeColors = comp::HasOptionalWedgeColors<T>;
116template<typename T>
117concept HasWedgeTexCoords = comp::HasWedgeTexCoords<T>;
118template<typename T>
119concept HasOptionalWedgeTexCoords = comp::HasOptionalWedgeTexCoords<T>;
120
// end of group
122
128/* Port AdjacentEdges class into face namespace */
129template<bool INDEXED, typename EdgeType>
130using AdjacentEdges = comp::AdjacentEdges<INDEXED, EdgeType, -1, false>;
131
132template<bool INDEXED, typename EdgeType, typename ParentFaceType>
133using AdjacentPolygonEdges =
134 comp::AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType>;
135
136template<bool INDEXED, typename EdgeType, typename ParentFaceType>
137using AdjacentTriangleEdges =
138 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType>;
139
140template<bool INDEXED, typename EdgeType, typename ParentFaceType>
141using VerticalAdjacentEdges =
142 comp::AdjacentEdges<INDEXED, EdgeType, -1, false, ParentFaceType, true>;
143
144template<bool INDEXED, typename EdgeType, typename ParentFaceType>
145using VerticalAdjacentPolygonEdges =
146 comp::AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType, true>;
147
148template<bool INDEXED, typename EdgeType, typename ParentFaceType>
149using VerticalAdjacentTriangleEdges =
150 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType, true>;
151
152template<bool INDEXED, typename EdgeType, typename ParentFaceType>
153using OptionalAdjacentEdges = comp::
154 AdjacentEdges<INDEXED, EdgeType, -1, false, ParentFaceType, true, true>;
155
156template<bool INDEXED, typename EdgeType, typename ParentFaceType>
157using OptionalAdjacentPolygonEdges = comp::
158 AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType, true, true>;
159
160template<bool INDEXED, typename EdgeType, typename ParentFaceType>
161using OptionalAdjacentTriangleEdges =
162 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType, true, true>;
163
164template<typename EdgeType>
165using AdjacentEdgeIndices = comp::AdjacentEdges<true, EdgeType, -1, false>;
166
167template<typename EdgeType, typename ParentFaceType>
168using AdjacentPolygonEdgeIndices =
169 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType>;
170
171template<typename EdgeType, typename ParentFaceType>
172using AdjacentTriangleEdgeIndices =
173 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType>;
174
175template<typename EdgeType, typename ParentFaceType>
176using VerticalAdjacentEdgeIndices =
177 comp::AdjacentEdges<true, EdgeType, -1, false, ParentFaceType, true>;
178
179template<typename EdgeType, typename ParentFaceType>
180using VerticalAdjacentPolygonEdgeIndices =
181 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType, true>;
182
183template<typename EdgeType, typename ParentFaceType>
184using VerticalAdjacentTriangleEdgeIndices =
185 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType, true>;
186
187template<typename EdgeType, typename ParentFaceType>
188using OptionalAdjacentEdgeIndices =
189 comp::AdjacentEdges<true, EdgeType, -1, false, ParentFaceType, true, true>;
190
191template<typename EdgeType, typename ParentFaceType>
192using OptionalAdjacentPolygonEdgeIndices =
193 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType, true, true>;
194
195template<typename EdgeType, typename ParentFaceType>
196using OptionalAdjacentTriangleEdgeIndices =
197 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType, true, true>;
198
199template<typename EdgeType>
200using AdjacentEdgePointers = comp::AdjacentEdges<false, EdgeType, -1, false>;
201
202template<typename EdgeType, typename ParentFaceType>
203using AdjacentPolygonEdgePointers =
204 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType>;
205
206template<typename EdgeType, typename ParentFaceType>
207using AdjacentTriangleEdgePointers =
208 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType>;
209
210template<typename EdgeType, typename ParentFaceType>
211using VerticalAdjacentEdgePointers =
212 comp::AdjacentEdges<false, EdgeType, -1, false, ParentFaceType, true>;
213
214template<typename EdgeType, typename ParentFaceType>
215using VerticalAdjacentPolygonEdgePointers =
216 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType, true>;
217
218template<typename EdgeType, typename ParentFaceType>
219using VerticalAdjacentTriangleEdgePointers =
220 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType, true>;
221
222template<typename EdgeType, typename ParentFaceType>
223using OptionalAdjacentEdgePointers =
224 comp::AdjacentEdges<false, EdgeType, -1, false, ParentFaceType, true, true>;
225
226template<typename EdgeType, typename ParentFaceType>
227using OptionalAdjacentPolygonEdgePointers =
228 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType, true, true>;
229
230template<typename EdgeType, typename ParentFaceType>
231using OptionalAdjacentTriangleEdgePointers =
232 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType, true, true>;
233
234/* Port AdjacentFaces class into face namespace */
235template<bool INDEXED, typename ParentFaceType>
236using AdjacentPolygons =
237 comp::AdjacentFaces<INDEXED, ParentFaceType, -1, true, ParentFaceType>;
238
239template<bool INDEXED, typename ParentFaceType>
240using AdjacentTriangles =
241 comp::AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType>;
242
243template<bool INDEXED, typename ParentFaceType>
244using VerticalAdjacentPolygons = comp::
245 AdjacentFaces<INDEXED, ParentFaceType, -1, true, ParentFaceType, true>;
246
247template<bool INDEXED, typename ParentFaceType>
248using VerticalAdjacentTriangles =
249 comp::AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType, true>;
250
251template<bool INDEXED, typename ParentFaceType>
252using OptionalAdjacentPolygons = comp::AdjacentFaces<
253 INDEXED,
254 ParentFaceType,
255 -1,
256 true,
257 ParentFaceType,
258 true,
259 true>;
260
261template<bool INDEXED, typename ParentFaceType>
262using OptionalAdjacentTriangles = comp::
263 AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType, true, true>;
264
265template<typename ParentFaceType>
266using AdjacentPolygonIndices =
267 comp::AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType>;
268
269template<typename ParentFaceType>
270using AdjacentTriangleIndices =
271 comp::AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType>;
272
273template<typename ParentFaceType>
274using VerticalAdjacentPolygonIndices =
275 comp::AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType, true>;
276
277template<typename ParentFaceType>
278using VerticalAdjacentTriangleIndices =
279 comp::AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType, true>;
280
281template<typename ParentFaceType>
282using OptionalAdjacentPolygonIndices = comp::
283 AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType, true, true>;
284
285template<typename ParentFaceType>
286using OptionalAdjacentTriangleIndices = comp::
287 AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType, true, true>;
288
289template<typename ParentFaceType>
290using AdjacentPolygonPointers =
291 comp::AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType>;
292
293template<typename ParentFaceType>
294using AdjacentTrianglePointers =
295 comp::AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType>;
296
297template<typename ParentFaceType>
298using VerticalAdjacentPolygonPointers =
299 comp::AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType, true>;
300
301template<typename ParentFaceType>
302using VerticalAdjacentTrianglePointers =
303 comp::AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType, true>;
304
305template<typename ParentFaceType>
306using OptionalAdjacentPolygonPointers = comp::
307 AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType, true, true>;
308
309template<typename ParentFaceType>
310using OptionalAdjacentTrianglePointers = comp::
311 AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType, true, true>;
312
313/* Port BitFlags class into face namespace */
314using BitFlags = comp::BitFlags<>;
315
316template<typename ParentFaceType>
317using VerticalBitFlags = comp::BitFlags<ParentFaceType>;
318
319/* Port Color class into face namespace */
320using Color = comp::Color<>;
321
322template<typename VertexType>
323using VerticalColor = comp::Color<VertexType>;
324
325template<typename ParentFaceType>
326using OptionalColor = comp::Color<ParentFaceType, true>;
327
328/* Port CustomComponents class into face namespace */
329template<typename ParentFaceType>
330using CustomComponents = comp::CustomComponents<ParentFaceType>;
331
332/* Port Mark class into face namespace */
333using Mark = comp::Mark<>;
334
335template<typename ParentFaceType>
336using VerticalMark = comp::Mark<ParentFaceType>;
337
338template<typename ParentFaceType>
339using OptionalMark = comp::Mark<ParentFaceType, true>;
340
341/* Port MaterialIndex class into face namespace */
342using MaterialIndex = comp::MaterialIndex<>;
343
344template<typename ParentFaceType>
345using VerticalMaterialIndex = comp::MaterialIndex<ParentFaceType>;
346
347template<typename ParentFaceType>
348using OptionalMaterialIndex = comp::MaterialIndex<ParentFaceType, true>;
349
350/* Port Normal classes into face namespace */
351template<typename ScalarType, int N>
352using Normal = comp::Normal<Point<ScalarType, N>>;
353
354template<typename ScalarType>
355using Normal3 = comp::Normal3<ScalarType>;
356
357using Normal3f = comp::Normal3f<>;
358using Normal3d = comp::Normal3d<>;
359
360template<typename ScalarType, int N, typename VertexType>
361using VerticalNormal = comp::Normal<Point<ScalarType, N>, VertexType>;
362
363template<typename ScalarType, typename VertexType>
364using VerticalNormal3 = comp::Normal3<ScalarType, VertexType>;
365
366template<typename VertexType>
367using VerticalNormal3f = comp::Normal3f<VertexType>;
368
369template<typename VertexType>
370using VerticalNormal3d = comp::Normal3d<VertexType>;
371
372template<typename ScalarType, int N, typename ParentFaceType>
373using OptionalNormal = comp::Normal<Point<ScalarType, N>, ParentFaceType, true>;
374
375template<typename ScalarType, typename ParentFaceType>
376using OptionalNormal3 = comp::Normal3<ScalarType, ParentFaceType, true>;
377
378template<typename ParentFaceType>
379using OptionalNormal3f = comp::Normal3f<ParentFaceType, true>;
380
381template<typename ParentFaceType>
382using OptionalNormal3d = comp::Normal3d<ParentFaceType, true>;
383
384/* Port ParentMeshPointer class into vert namespace */
385template<typename MeshType>
386using ParentMeshPointer = comp::ParentMeshPointer<MeshType>;
387
388/* Port PolygonBitFlags class into face namespace */
389using PolygonBitFlags = comp::PolygonBitFlags<-1>;
390
391template<typename ParentFaceType>
392using VerticalPolygonBitFlags = comp::PolygonBitFlags<-1, ParentFaceType>;
393
394/* Port PrincipalCurvature class into face namespace */
395template<typename ParentFaceType>
396using PrincipalCurvature = comp::PrincipalCurvature<ParentFaceType>;
397
398using PrincipalCurvaturef = comp::PrincipalCurvaturef<>;
399using PrincipalCurvatured = comp::PrincipalCurvatured<>;
400
401template<typename ScalarType, typename ParentFaceType>
402using VerticalPrincipalCurvature =
403 comp::PrincipalCurvature<ScalarType, ParentFaceType>;
404
405template<typename ParentFaceType>
406using VerticalPrincipalCurvaturef = comp::PrincipalCurvaturef<ParentFaceType>;
407template<typename ParentFaceType>
408using VerticalPrincipalCurvatured = comp::PrincipalCurvatured<ParentFaceType>;
409
410template<typename ScalarType, typename ParentFaceType>
411using OptionalPrincipalCurvature =
412 comp::PrincipalCurvature<ScalarType, ParentFaceType, true>;
413
414template<typename ParentFaceType>
415using OptionalPrincipalCurvaturef =
416 comp::PrincipalCurvaturef<ParentFaceType, true>;
417template<typename ParentFaceType>
418using OptionalPrincipalCurvatured =
419 comp::PrincipalCurvatured<ParentFaceType, true>;
420
421/* Port Quality class into face namespace */
422template<typename QualityType>
423using Quality = comp::Quality<QualityType>;
424
425using Qualityf = comp::Qualityf<>;
426using Qualityd = comp::Qualityd<>;
427
428template<typename QualityType, typename ParentFaceType>
429using VerticalQuality = comp::Quality<QualityType, ParentFaceType>;
430
431template<typename ParentFaceType>
432using VerticalQualityf = comp::Quality<float, ParentFaceType>;
433
434template<typename ParentFaceType>
435using VerticalQualityd = comp::Quality<double, ParentFaceType>;
436
437template<typename QualityType, typename ParentFaceType>
438using OptionalQuality = comp::Quality<QualityType, ParentFaceType, true>;
439
440template<typename ParentFaceType>
441using OptionalQualityf = comp::Quality<float, ParentFaceType, true>;
442
443template<typename ParentFaceType>
444using OptionalQualityd = comp::Quality<double, ParentFaceType, true>;
445
446/* Port TriangleBitFlags class into face namespace */
447using TriangleBitFlags = comp::TriangleBitFlags<>;
448
449template<typename ParentFaceType>
450using VerticalTriangleBitFlags = comp::TriangleBitFlags<ParentFaceType>;
451
452/* Port VertexReferences alias into face namespace */
453template<bool INDEXED, typename Vertex, int N, typename FaceType>
454using VertexReferences = comp::VertexReferences<INDEXED, Vertex, N, FaceType>;
455
456template<bool INDEXED, typename Vertex, typename FaceType>
457using TriangleVertexRefs = comp::VertexReferences<INDEXED, Vertex, 3, FaceType>;
458
459template<bool INDEXED, typename Vertex, typename FaceType>
460using PolygonVertexRefs = comp::VertexReferences<INDEXED, Vertex, -1, FaceType>;
461
462template<typename Vertex, int N, typename FaceType>
463using VertexIndices = comp::VertexReferences<true, Vertex, N, FaceType>;
464
465template<typename Vertex, typename FaceType>
466using TriangleVertexInds = comp::VertexReferences<true, Vertex, 3, FaceType>;
467
468template<typename Vertex, typename FaceType>
469using PolygonVertexInds = comp::VertexReferences<true, Vertex, -1, FaceType>;
470
471template<typename Vertex, int N, typename FaceType>
472using VertexPointers = comp::VertexReferences<false, Vertex, N, FaceType>;
473
474template<typename Vertex, typename FaceType>
475using TriangleVertexPtrs = comp::VertexReferences<false, Vertex, 3, FaceType>;
476
477template<typename Vertex, typename FaceType>
478using PolygonVertexPtrs = comp::VertexReferences<false, Vertex, -1, FaceType>;
479
480/* Port WedgeColors class into face namespace */
481using PolygonWedgeColors = comp::WedgeColors<-1>;
482
483using TriangleWedgeColors = comp::WedgeColors<3>;
484
485template<typename ParentFaceType>
486using VerticalPolygonWedgeColors = comp::WedgeColors<-1, ParentFaceType>;
487
488template<typename ParentFaceType>
489using VerticalTriangleWedgeColors = comp::WedgeColors<3, ParentFaceType>;
490
491template<typename ParentFaceType>
492using OptionalPolygonWedgeColors = comp::WedgeColors<-1, ParentFaceType, true>;
493
494template<typename ParentFaceType>
495using OptionalTriangleWedgeColors = comp::WedgeColors<3, ParentFaceType, true>;
496
497/* Port WedgeTexCoords class into face namespace */
498template<typename ScalarType>
499using PolygonWedgeTexCoords = comp::WedgeTexCoords<ScalarType, -1>;
500
501template<typename ScalarType>
502using TriangleWedgeTexCoords = comp::WedgeTexCoords<ScalarType, 3>;
503
504using PolygonWedgeTexCoordsf = PolygonWedgeTexCoords<float>;
505using PolygonWedgeTexCoordsd = PolygonWedgeTexCoords<double>;
506using TriangleWedgeTexCoordsf = TriangleWedgeTexCoords<float>;
507using TriangleWedgeTexCoordsd = TriangleWedgeTexCoords<double>;
508
509template<typename ScalarType, typename ParentFaceType>
510using VerticalPolygonWedgeTexCoords =
511 comp::WedgeTexCoords<ScalarType, -1, ParentFaceType, true>;
512
513template<typename ScalarType, typename ParentFaceType>
514using VerticalTriangleWedgeTexCoords =
515 comp::WedgeTexCoords<ScalarType, 3, ParentFaceType, true>;
516
517template<typename ParentFaceType>
518using VerticalPolygonWedgeTexCoordsf =
519 comp::WedgeTexCoords<float, -1, ParentFaceType>;
520template<typename ParentFaceType>
521using VerticalPolygonWedgeTexCoordsd =
522 comp::WedgeTexCoords<double, -1, ParentFaceType>;
523template<typename ParentFaceType>
524using VerticalTriangleWedgeTexCoordsf =
525 comp::WedgeTexCoords<float, 3, ParentFaceType>;
526template<typename ParentFaceType>
527using VerticalTriangleWedgeTexCoordsd =
528 comp::WedgeTexCoords<double, 3, ParentFaceType>;
529
530template<typename ScalarType, typename ParentFaceType>
531using OptionalPolygonWedgeTexCoords =
532 comp::WedgeTexCoords<ScalarType, -1, ParentFaceType, true>;
533
534template<typename ScalarType, typename ParentFaceType>
535using OptionalTriangleWedgeTexCoords =
536 comp::WedgeTexCoords<ScalarType, 3, ParentFaceType, true>;
537
538template<typename ParentFaceType>
539using OptionalPolygonWedgeTexCoordsf =
540 comp::WedgeTexCoords<float, -1, ParentFaceType, true>;
541template<typename ParentFaceType>
542using OptionalPolygonWedgeTexCoordsd =
543 comp::WedgeTexCoords<double, -1, ParentFaceType, true>;
544template<typename ParentFaceType>
545using OptionalTriangleWedgeTexCoordsf =
546 comp::WedgeTexCoords<float, 3, ParentFaceType, true>;
547template<typename ParentFaceType>
548using OptionalTriangleWedgeTexCoordsd =
549 comp::WedgeTexCoords<double, 3, ParentFaceType, true>;
550
// end of face_components group
552
553} // namespace vcl::face
554
555#endif // VCL_MESH_ELEMENTS_FACE_COMPONENTS_H
vcl::comp::HasAdjacentEdges
A concept that checks whether a type T (that should be a Element) has the AdjacentEdges component (in...
Definition adjacent_edges.h:668
vcl::comp::HasAdjacentFaces
A concept that checks whether a type T (that should be a Element) has the AdjacentFaces component (in...
Definition adjacent_faces.h:672
vcl::comp::HasBitFlags
A concept that checks whether a type T (that should be an Element) has the one of the BitFlags compon...
Definition bit_flags.h:101
vcl::comp::HasColor
A concept that checks whether a type T (that should be a Element or a Mesh) has the Color component (...
Definition color.h:132
vcl::comp::HasCustomComponents
A concept that checks whether a type T (that should be an Element or a Mesh) has the CustomComponents...
Definition custom_components.h:316
vcl::comp::HasFaceBitFlags
A concept that checks whether a type T (that should be a Face Element) has either the PolygonBitFlags...
Definition bit_flags.h:86
vcl::comp::HasMark
A concept that checks whether a type T (that should be a Element or a Mesh) has the Mark component (i...
Definition mark.h:198
vcl::comp::HasMaterialIndex
A concept that checks whether a type T (that should be a Element or a Mesh) has the MaterialIndex com...
Definition material_index.h:142
vcl::comp::HasNormal
A concept that checks whether a type T (that should be a Element) has the Normal component (inherits ...
Definition normal.h:133
vcl::comp::HasOptionalAdjacentEdges
A concept that checks whether a type T (that should be a Element) has the AdjacentEdges component (in...
Definition adjacent_edges.h:682
vcl::comp::HasOptionalAdjacentFaces
A concept that checks whether a type T (that should be a Element) has the AdjacentFaces component (in...
Definition adjacent_faces.h:686
vcl::comp::HasOptionalColor
A concept that checks whether a type T (that should be a Element or a Mesh) has the Color component (...
Definition color.h:144
vcl::comp::HasOptionalMark
A concept that checks whether a type T (that should be a Element or a Mesh) has the Mark component (i...
Definition mark.h:210
vcl::comp::HasOptionalMaterialIndex
A concept that checks whether a type T (that should be a Element or a Mesh) has the MaterialIndex com...
Definition material_index.h:155
vcl::comp::HasOptionalNormal
A concept that checks whether a type T (that should be a Element) has the Normal component (inherits ...
Definition normal.h:146
vcl::comp::HasOptionalPrincipalCurvature
A concept that checks whether a type T (that should be a Element) has the PrincipalCurvature componen...
Definition principal_curvature.h:159
vcl::comp::HasOptionalQuality
A concept that checks whether a type T (that should be a Element or a Mesh) has the Quality component...
Definition quality.h:144
vcl::comp::HasOptionalWedgeColors
A concept that checks whether a type T (that should be a Element) has the WedgeColors component (inhe...
Definition wedge_colors.h:350
vcl::comp::HasOptionalWedgeTexCoords
A concept that checks whether a type T (that should be a Element) has the WedgeTexCoords component (i...
Definition wedge_tex_coords.h:386
vcl::comp::HasPolygonBitFlags
A concept that checks whether a type T (that should be a Face Element) has the PolygonBitFlags compon...
Definition bit_flags.h:54
vcl::comp::HasPrincipalCurvature
A concept that checks whether a type T (that should be a Element) has the PrincipalCurvature componen...
Definition principal_curvature.h:145
vcl::comp::HasQuality
A concept that checks whether a type T (that should be a Element or a Mesh) has the Quality component...
Definition quality.h:132
vcl::comp::HasTriangleBitFlags
A concept that checks whether a type T (that should be a Face Element) has the TriangleBitFlags compo...
Definition bit_flags.h:69
vcl::comp::HasVertexReferences
A concept that checks whether a type T (that should be a Element) has the VertexReferences component ...
Definition vertex_references.h:712
vcl::comp::HasWedgeColors
A concept that checks whether a type T (that should be a Element) has the WedgeColors component (inhe...
Definition wedge_colors.h:337
vcl::comp::HasWedgeTexCoords
A concept that checks whether a type T (that should be a Element) has the WedgeTexCoords component (i...
Definition wedge_tex_coords.h:372
vcl::face::HasAdjacentEdges
Definition face_components.h:69
vcl::face::HasAdjacentFaces
Definition face_components.h:73
vcl::face::HasBitFlags
Definition face_components.h:77
vcl::face::HasColor
Definition face_components.h:79
vcl::face::HasCustomComponents
Definition face_components.h:83
vcl::face::HasFaceBitFlags
Definition face_components.h:85
vcl::face::HasMark
Definition face_components.h:87
vcl::face::HasMaterialIndex
Definition face_components.h:91
vcl::face::HasNormal
Definition face_components.h:95
vcl::face::HasOptionalAdjacentEdges
Definition face_components.h:71
vcl::face::HasOptionalAdjacentFaces
Definition face_components.h:75
vcl::face::HasOptionalColor
Definition face_components.h:81
vcl::face::HasOptionalMark
Definition face_components.h:89
vcl::face::HasOptionalMaterialIndex
Definition face_components.h:93
vcl::face::HasOptionalNormal
Definition face_components.h:97
vcl::face::HasOptionalPrincipalCurvature
Definition face_components.h:103
vcl::face::HasOptionalQuality
Definition face_components.h:107
vcl::face::HasOptionalWedgeColors
Definition face_components.h:115
vcl::face::HasOptionalWedgeTexCoords
Definition face_components.h:119
vcl::face::HasPolygonBitFlags
Definition face_components.h:99
vcl::face::HasPrincipalCurvature
Definition face_components.h:101
vcl::face::HasQuality
Definition face_components.h:105
vcl::face::HasTriangleBitFlags
Definition face_components.h:109
vcl::face::HasVertexReferences
Definition face_components.h:111
vcl::face::HasWedgeColors
Definition face_components.h:113
vcl::face::HasWedgeTexCoords
Definition face_components.h:117