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/normal.h"
33#include "../components/parent_mesh_pointer.h"
34#include "../components/polygon_bit_flags.h"
35#include "../components/principal_curvature.h"
36#include "../components/quality.h"
37#include "../components/triangle_bit_flags.h"
38#include "../components/vertex_references.h"
39#include "../components/wedge_colors.h"
40#include "../components/wedge_tex_coords.h"
41
59namespace vcl::face {
60
66/* Port concepts into the face namespace */
67template<typename T>
68concept HasAdjacentEdges = comp::HasAdjacentEdges<T>;
69template<typename T>
70concept HasOptionalAdjacentEdges = comp::HasOptionalAdjacentEdges<T>;
71template<typename T>
72concept HasAdjacentFaces = comp::HasAdjacentFaces<T>;
73template<typename T>
74concept HasOptionalAdjacentFaces = comp::HasOptionalAdjacentFaces<T>;
75template<typename T>
76concept HasBitFlags = comp::HasBitFlags<T>;
77template<typename T>
78concept HasColor = comp::HasColor<T>;
79template<typename T>
80concept HasOptionalColor = comp::HasOptionalColor<T>;
81template<typename T>
82concept HasCustomComponents = comp::HasCustomComponents<T>;
83template<typename T>
84concept HasFaceBitFlags = comp::HasFaceBitFlags<T>;
85template<typename T>
86concept HasMark = comp::HasMark<T>;
87template<typename T>
88concept HasOptionalMark = comp::HasOptionalMark<T>;
89template<typename T>
90concept HasNormal = comp::HasNormal<T>;
91template<typename T>
92concept HasOptionalNormal = comp::HasOptionalNormal<T>;
93template<typename T>
94concept HasPolygonBitFlags = comp::HasPolygonBitFlags<T>;
95template<typename T>
96concept HasPrincipalCurvature = comp::HasPrincipalCurvature<T>;
97template<typename T>
98concept HasOptionalPrincipalCurvature = comp::HasOptionalPrincipalCurvature<T>;
99template<typename T>
100concept HasQuality = comp::HasQuality<T>;
101template<typename T>
102concept HasOptionalQuality = comp::HasOptionalQuality<T>;
103template<typename T>
104concept HasTriangleBitFlags = comp::HasTriangleBitFlags<T>;
105template<typename T>
106concept HasVertexReferences = comp::HasVertexReferences<T>;
107template<typename T>
108concept HasWedgeColors = comp::HasWedgeColors<T>;
109template<typename T>
110concept HasOptionalWedgeColors = comp::HasOptionalWedgeColors<T>;
111template<typename T>
112concept HasWedgeTexCoords = comp::HasWedgeTexCoords<T>;
113template<typename T>
114concept HasOptionalWedgeTexCoords = comp::HasOptionalWedgeTexCoords<T>;
115
// end of group
117
123/* Port AdjacentEdges class into face namespace */
124template<bool INDEXED, typename EdgeType>
125using AdjacentEdges = comp::AdjacentEdges<INDEXED, EdgeType, -1, false>;
126
127template<bool INDEXED, typename EdgeType, typename ParentFaceType>
128using AdjacentPolygonEdges =
129 comp::AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType>;
130
131template<bool INDEXED, typename EdgeType, typename ParentFaceType>
132using AdjacentTriangleEdges =
133 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType>;
134
135template<bool INDEXED, typename EdgeType, typename ParentFaceType>
136using VerticalAdjacentEdges =
137 comp::AdjacentEdges<INDEXED, EdgeType, -1, false, ParentFaceType, true>;
138
139template<bool INDEXED, typename EdgeType, typename ParentFaceType>
140using VerticalAdjacentPolygonEdges =
141 comp::AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType, true>;
142
143template<bool INDEXED, typename EdgeType, typename ParentFaceType>
144using VerticalAdjacentTriangleEdges =
145 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType, true>;
146
147template<bool INDEXED, typename EdgeType, typename ParentFaceType>
148using OptionalAdjacentEdges = comp::
149 AdjacentEdges<INDEXED, EdgeType, -1, false, ParentFaceType, true, true>;
150
151template<bool INDEXED, typename EdgeType, typename ParentFaceType>
152using OptionalAdjacentPolygonEdges = comp::
153 AdjacentEdges<INDEXED, EdgeType, -1, true, ParentFaceType, true, true>;
154
155template<bool INDEXED, typename EdgeType, typename ParentFaceType>
156using OptionalAdjacentTriangleEdges =
157 comp::AdjacentEdges<INDEXED, EdgeType, 3, true, ParentFaceType, true, true>;
158
159template<typename EdgeType>
160using AdjacentEdgeIndices = comp::AdjacentEdges<true, EdgeType, -1, false>;
161
162template<typename EdgeType, typename ParentFaceType>
163using AdjacentPolygonEdgeIndices =
164 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType>;
165
166template<typename EdgeType, typename ParentFaceType>
167using AdjacentTriangleEdgeIndices =
168 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType>;
169
170template<typename EdgeType, typename ParentFaceType>
171using VerticalAdjacentEdgeIndices =
172 comp::AdjacentEdges<true, EdgeType, -1, false, ParentFaceType, true>;
173
174template<typename EdgeType, typename ParentFaceType>
175using VerticalAdjacentPolygonEdgeIndices =
176 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType, true>;
177
178template<typename EdgeType, typename ParentFaceType>
179using VerticalAdjacentTriangleEdgeIndices =
180 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType, true>;
181
182template<typename EdgeType, typename ParentFaceType>
183using OptionalAdjacentEdgeIndices =
184 comp::AdjacentEdges<true, EdgeType, -1, false, ParentFaceType, true, true>;
185
186template<typename EdgeType, typename ParentFaceType>
187using OptionalAdjacentPolygonEdgeIndices =
188 comp::AdjacentEdges<true, EdgeType, -1, true, ParentFaceType, true, true>;
189
190template<typename EdgeType, typename ParentFaceType>
191using OptionalAdjacentTriangleEdgeIndices =
192 comp::AdjacentEdges<true, EdgeType, 3, true, ParentFaceType, true, true>;
193
194template<typename EdgeType>
195using AdjacentEdgePointers = comp::AdjacentEdges<false, EdgeType, -1, false>;
196
197template<typename EdgeType, typename ParentFaceType>
198using AdjacentPolygonEdgePointers =
199 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType>;
200
201template<typename EdgeType, typename ParentFaceType>
202using AdjacentTriangleEdgePointers =
203 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType>;
204
205template<typename EdgeType, typename ParentFaceType>
206using VerticalAdjacentEdgePointers =
207 comp::AdjacentEdges<false, EdgeType, -1, false, ParentFaceType, true>;
208
209template<typename EdgeType, typename ParentFaceType>
210using VerticalAdjacentPolygonEdgePointers =
211 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType, true>;
212
213template<typename EdgeType, typename ParentFaceType>
214using VerticalAdjacentTriangleEdgePointers =
215 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType, true>;
216
217template<typename EdgeType, typename ParentFaceType>
218using OptionalAdjacentEdgePointers =
219 comp::AdjacentEdges<false, EdgeType, -1, false, ParentFaceType, true, true>;
220
221template<typename EdgeType, typename ParentFaceType>
222using OptionalAdjacentPolygonEdgePointers =
223 comp::AdjacentEdges<false, EdgeType, -1, true, ParentFaceType, true, true>;
224
225template<typename EdgeType, typename ParentFaceType>
226using OptionalAdjacentTriangleEdgePointers =
227 comp::AdjacentEdges<false, EdgeType, 3, true, ParentFaceType, true, true>;
228
229/* Port AdjacentFaces class into face namespace */
230template<bool INDEXED, typename ParentFaceType>
231using AdjacentPolygons =
232 comp::AdjacentFaces<INDEXED, ParentFaceType, -1, true, ParentFaceType>;
233
234template<bool INDEXED, typename ParentFaceType>
235using AdjacentTriangles =
236 comp::AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType>;
237
238template<bool INDEXED, typename ParentFaceType>
239using VerticalAdjacentPolygons = comp::
240 AdjacentFaces<INDEXED, ParentFaceType, -1, true, ParentFaceType, true>;
241
242template<bool INDEXED, typename ParentFaceType>
243using VerticalAdjacentTriangles =
244 comp::AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType, true>;
245
246template<bool INDEXED, typename ParentFaceType>
247using OptionalAdjacentPolygons = comp::AdjacentFaces<
248 INDEXED,
249 ParentFaceType,
250 -1,
251 true,
252 ParentFaceType,
253 true,
254 true>;
255
256template<bool INDEXED, typename ParentFaceType>
257using OptionalAdjacentTriangles = comp::
258 AdjacentFaces<INDEXED, ParentFaceType, 3, true, ParentFaceType, true, true>;
259
260template<typename ParentFaceType>
261using AdjacentPolygonIndices =
262 comp::AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType>;
263
264template<typename ParentFaceType>
265using AdjacentTriangleIndices =
266 comp::AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType>;
267
268template<typename ParentFaceType>
269using VerticalAdjacentPolygonIndices =
270 comp::AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType, true>;
271
272template<typename ParentFaceType>
273using VerticalAdjacentTriangleIndices =
274 comp::AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType, true>;
275
276template<typename ParentFaceType>
277using OptionalAdjacentPolygonIndices = comp::
278 AdjacentFaces<true, ParentFaceType, -1, true, ParentFaceType, true, true>;
279
280template<typename ParentFaceType>
281using OptionalAdjacentTriangleIndices = comp::
282 AdjacentFaces<true, ParentFaceType, 3, true, ParentFaceType, true, true>;
283
284template<typename ParentFaceType>
285using AdjacentPolygonPointers =
286 comp::AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType>;
287
288template<typename ParentFaceType>
289using AdjacentTrianglePointers =
290 comp::AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType>;
291
292template<typename ParentFaceType>
293using VerticalAdjacentPolygonPointers =
294 comp::AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType, true>;
295
296template<typename ParentFaceType>
297using VerticalAdjacentTrianglePointers =
298 comp::AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType, true>;
299
300template<typename ParentFaceType>
301using OptionalAdjacentPolygonPointers = comp::
302 AdjacentFaces<false, ParentFaceType, -1, true, ParentFaceType, true, true>;
303
304template<typename ParentFaceType>
305using OptionalAdjacentTrianglePointers = comp::
306 AdjacentFaces<false, ParentFaceType, 3, true, ParentFaceType, true, true>;
307
308/* Port BitFlags class into face namespace */
309using BitFlags = comp::BitFlags<>;
310
311template<typename ParentFaceType>
312using VerticalBitFlags = comp::BitFlags<ParentFaceType>;
313
314/* Port Color class into face namespace */
315using Color = comp::Color<>;
316
317template<typename VertexType>
318using VerticalColor = comp::Color<VertexType>;
319
320template<typename ParentFaceType>
321using OptionalColor = comp::Color<ParentFaceType, true>;
322
323/* Port CustomComponents class into face namespace */
324template<typename ParentFaceType>
325using CustomComponents = comp::CustomComponents<ParentFaceType>;
326
327/* Port Mark class into face namespace */
328using Mark = comp::Mark<>;
329
330template<typename ParentFaceType>
331using VerticalMark = comp::Mark<ParentFaceType>;
332
333template<typename ParentFaceType>
334using OptionalMark = comp::Mark<ParentFaceType, true>;
335
336/* Port Normal classes into face namespace */
337template<typename ScalarType, int N>
338using Normal = comp::Normal<Point<ScalarType, N>>;
339
340template<typename ScalarType>
341using Normal3 = comp::Normal3<ScalarType>;
342
343using Normal3f = comp::Normal3f<>;
344using Normal3d = comp::Normal3d<>;
345
346template<typename ScalarType, int N, typename VertexType>
347using VerticalNormal = comp::Normal<Point<ScalarType, N>, VertexType>;
348
349template<typename ScalarType, typename VertexType>
350using VerticalNormal3 = comp::Normal3<ScalarType, VertexType>;
351
352template<typename VertexType>
353using VerticalNormal3f = comp::Normal3f<VertexType>;
354
355template<typename VertexType>
356using VerticalNormal3d = comp::Normal3d<VertexType>;
357
358template<typename ScalarType, int N, typename ParentFaceType>
359using OptionalNormal = comp::Normal<Point<ScalarType, N>, ParentFaceType, true>;
360
361template<typename ScalarType, typename ParentFaceType>
362using OptionalNormal3 = comp::Normal3<ScalarType, ParentFaceType, true>;
363
364template<typename ParentFaceType>
365using OptionalNormal3f = comp::Normal3f<ParentFaceType, true>;
366
367template<typename ParentFaceType>
368using OptionalNormal3d = comp::Normal3d<ParentFaceType, true>;
369
370/* Port ParentMeshPointer class into vert namespace */
371template<typename MeshType>
372using ParentMeshPointer = comp::ParentMeshPointer<MeshType>;
373
374/* Port PolygonBitFlags class into face namespace */
375using PolygonBitFlags = comp::PolygonBitFlags<-1>;
376
377template<typename ParentFaceType>
378using VerticalPolygonBitFlags = comp::PolygonBitFlags<-1, ParentFaceType>;
379
380/* Port PrincipalCurvature class into face namespace */
381template<typename ParentFaceType>
382using PrincipalCurvature = comp::PrincipalCurvature<ParentFaceType>;
383
384using PrincipalCurvaturef = comp::PrincipalCurvaturef<>;
385using PrincipalCurvatured = comp::PrincipalCurvatured<>;
386
387template<typename ScalarType, typename ParentFaceType>
388using VerticalPrincipalCurvature =
389 comp::PrincipalCurvature<ScalarType, ParentFaceType>;
390
391template<typename ParentFaceType>
392using VerticalPrincipalCurvaturef = comp::PrincipalCurvaturef<ParentFaceType>;
393template<typename ParentFaceType>
394using VerticalPrincipalCurvatured = comp::PrincipalCurvatured<ParentFaceType>;
395
396template<typename ScalarType, typename ParentFaceType>
397using OptionalPrincipalCurvature =
398 comp::PrincipalCurvature<ScalarType, ParentFaceType, true>;
399
400template<typename ParentFaceType>
401using OptionalPrincipalCurvaturef =
402 comp::PrincipalCurvaturef<ParentFaceType, true>;
403template<typename ParentFaceType>
404using OptionalPrincipalCurvatured =
405 comp::PrincipalCurvatured<ParentFaceType, true>;
406
407/* Port Quality class into face namespace */
408template<typename QualityType>
409using Quality = comp::Quality<QualityType>;
410
411using Qualityf = comp::Qualityf<>;
412using Qualityd = comp::Qualityd<>;
413
414template<typename QualityType, typename ParentFaceType>
415using VerticalQuality = comp::Quality<QualityType, ParentFaceType>;
416
417template<typename ParentFaceType>
418using VerticalQualityf = comp::Quality<float, ParentFaceType>;
419
420template<typename ParentFaceType>
421using VerticalQualityd = comp::Quality<double, ParentFaceType>;
422
423template<typename QualityType, typename ParentFaceType>
424using OptionalQuality = comp::Quality<QualityType, ParentFaceType, true>;
425
426template<typename ParentFaceType>
427using OptionalQualityf = comp::Quality<float, ParentFaceType, true>;
428
429template<typename ParentFaceType>
430using OptionalQualityd = comp::Quality<double, ParentFaceType, true>;
431
432/* Port TriangleBitFlags class into face namespace */
433using TriangleBitFlags = comp::TriangleBitFlags<>;
434
435template<typename ParentFaceType>
436using VerticalTriangleBitFlags = comp::TriangleBitFlags<ParentFaceType>;
437
438/* Port VertexReferences alias into face namespace */
439template<bool INDEXED, typename Vertex, int N, typename FaceType>
440using VertexReferences = comp::VertexReferences<INDEXED, Vertex, N, FaceType>;
441
442template<bool INDEXED, typename Vertex, typename FaceType>
443using TriangleVertexRefs = comp::VertexReferences<INDEXED, Vertex, 3, FaceType>;
444
445template<bool INDEXED, typename Vertex, typename FaceType>
446using PolygonVertexRefs = comp::VertexReferences<INDEXED, Vertex, -1, FaceType>;
447
448template<typename Vertex, int N, typename FaceType>
449using VertexIndices = comp::VertexReferences<true, Vertex, N, FaceType>;
450
451template<typename Vertex, typename FaceType>
452using TriangleVertexInds = comp::VertexReferences<true, Vertex, 3, FaceType>;
453
454template<typename Vertex, typename FaceType>
455using PolygonVertexInds = comp::VertexReferences<true, Vertex, -1, FaceType>;
456
457template<typename Vertex, int N, typename FaceType>
458using VertexPointers = comp::VertexReferences<false, Vertex, N, FaceType>;
459
460template<typename Vertex, typename FaceType>
461using TriangleVertexPtrs = comp::VertexReferences<false, Vertex, 3, FaceType>;
462
463template<typename Vertex, typename FaceType>
464using PolygonVertexPtrs = comp::VertexReferences<false, Vertex, -1, FaceType>;
465
466/* Port WedgeColors class into face namespace */
467using PolygonWedgeColors = comp::WedgeColors<-1>;
468
469using TriangleWedgeColors = comp::WedgeColors<3>;
470
471template<typename ParentFaceType>
472using VerticalPolygonWedgeColors = comp::WedgeColors<-1, ParentFaceType>;
473
474template<typename ParentFaceType>
475using VerticalTriangleWedgeColors = comp::WedgeColors<3, ParentFaceType>;
476
477template<typename ParentFaceType>
478using OptionalPolygonWedgeColors = comp::WedgeColors<-1, ParentFaceType, true>;
479
480template<typename ParentFaceType>
481using OptionalTriangleWedgeColors = comp::WedgeColors<3, ParentFaceType, true>;
482
483/* Port WedgeTexCoords class into face namespace */
484template<typename ScalarType>
485using PolygonWedgeTexCoords = comp::WedgeTexCoords<ScalarType, -1>;
486
487template<typename ScalarType>
488using TriangleWedgeTexCoords = comp::WedgeTexCoords<ScalarType, 3>;
489
490using PolygonWedgeTexCoordsf = PolygonWedgeTexCoords<float>;
491using PolygonWedgeTexCoordsd = PolygonWedgeTexCoords<double>;
492using TriangleWedgeTexCoordsf = TriangleWedgeTexCoords<float>;
493using TriangleWedgeTexCoordsd = TriangleWedgeTexCoords<double>;
494
495template<typename ScalarType, typename ParentFaceType>
496using VerticalPolygonWedgeTexCoords =
497 comp::WedgeTexCoords<ScalarType, -1, ParentFaceType, true>;
498
499template<typename ScalarType, typename ParentFaceType>
500using VerticalTriangleWedgeTexCoords =
501 comp::WedgeTexCoords<ScalarType, 3, ParentFaceType, true>;
502
503template<typename ParentFaceType>
504using VerticalPolygonWedgeTexCoordsf =
505 comp::WedgeTexCoords<float, -1, ParentFaceType>;
506template<typename ParentFaceType>
507using VerticalPolygonWedgeTexCoordsd =
508 comp::WedgeTexCoords<double, -1, ParentFaceType>;
509template<typename ParentFaceType>
510using VerticalTriangleWedgeTexCoordsf =
511 comp::WedgeTexCoords<float, 3, ParentFaceType>;
512template<typename ParentFaceType>
513using VerticalTriangleWedgeTexCoordsd =
514 comp::WedgeTexCoords<double, 3, ParentFaceType>;
515
516template<typename ScalarType, typename ParentFaceType>
517using OptionalPolygonWedgeTexCoords =
518 comp::WedgeTexCoords<ScalarType, -1, ParentFaceType, true>;
519
520template<typename ScalarType, typename ParentFaceType>
521using OptionalTriangleWedgeTexCoords =
522 comp::WedgeTexCoords<ScalarType, 3, ParentFaceType, true>;
523
524template<typename ParentFaceType>
525using OptionalPolygonWedgeTexCoordsf =
526 comp::WedgeTexCoords<float, -1, ParentFaceType, true>;
527template<typename ParentFaceType>
528using OptionalPolygonWedgeTexCoordsd =
529 comp::WedgeTexCoords<double, -1, ParentFaceType, true>;
530template<typename ParentFaceType>
531using OptionalTriangleWedgeTexCoordsf =
532 comp::WedgeTexCoords<float, 3, ParentFaceType, true>;
533template<typename ParentFaceType>
534using OptionalTriangleWedgeTexCoordsd =
535 comp::WedgeTexCoords<double, 3, ParentFaceType, true>;
536
// end of edge_components group
538
539} // namespace vcl::face
540
541#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::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::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:413
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:399
vcl::face::HasAdjacentEdges
Definition face_components.h:68
vcl::face::HasAdjacentFaces
Definition face_components.h:72
vcl::face::HasBitFlags
Definition face_components.h:76
vcl::face::HasColor
Definition face_components.h:78
vcl::face::HasCustomComponents
Definition face_components.h:82
vcl::face::HasFaceBitFlags
Definition face_components.h:84
vcl::face::HasMark
Definition face_components.h:86
vcl::face::HasNormal
Definition face_components.h:90
vcl::face::HasOptionalAdjacentEdges
Definition face_components.h:70
vcl::face::HasOptionalAdjacentFaces
Definition face_components.h:74
vcl::face::HasOptionalColor
Definition face_components.h:80
vcl::face::HasOptionalMark
Definition face_components.h:88
vcl::face::HasOptionalNormal
Definition face_components.h:92
vcl::face::HasOptionalPrincipalCurvature
Definition face_components.h:98
vcl::face::HasOptionalQuality
Definition face_components.h:102
vcl::face::HasOptionalWedgeColors
Definition face_components.h:110
vcl::face::HasOptionalWedgeTexCoords
Definition face_components.h:114
vcl::face::HasPolygonBitFlags
Definition face_components.h:94
vcl::face::HasPrincipalCurvature
Definition face_components.h:96
vcl::face::HasQuality
Definition face_components.h:100
vcl::face::HasTriangleBitFlags
Definition face_components.h:104
vcl::face::HasVertexReferences
Definition face_components.h:106
vcl::face::HasWedgeColors
Definition face_components.h:108
vcl::face::HasWedgeTexCoords
Definition face_components.h:112