| OpenMesh

AttribKernelT.hh
1 /* ========================================================================= *
2 * *
3 * OpenMesh *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openmesh.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenMesh. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 * ========================================================================= */
41
42
43
44 #ifndef OPENMESH_KERNEL_OSG_ATTRIBKERNEL_HH
45 #define OPENMESH_KENREL_OSG_ATTRIBKERNEL_HH
46
47
48 //== INCLUDES =================================================================
49
50 #include <OpenMesh/Core/Utils/GenProg.hh>
51 #include <OpenMesh/Core/Mesh/Attributes.hh>
52 // --------------------
53 #include <OpenMesh/Tools/Kernel_OSG/PropertyT.hh>
54 #include <OpenMesh/Tools/Kernel_OSG/PropertyKernel.hh>
55 // --------------------
56 #include <osg/Geometry>
57
58
59 //== NAMESPACES ===============================================================
60
61 namespace OpenMesh {
62 namespace Kernel_OSG {
63
64 //== CLASS DEFINITION =========================================================
65
66
67
69 template <class MeshItems>
70 class AttribKernelT
71 : public PropertyKernel< typename MeshItems::Face::IsTriangle >
72 {
73 protected:
74
75 typedef typename MeshItems::Face::IsTriangle IsTriMesh;
76 typedef PropertyKernel< IsTriMesh > Base;
77
78 typedef typename Base::FPTypesHandle FPTypesHandle;
79 typedef typename Base::FPLengthsHandle FPLengthsHandle;
80 typedef typename Base::FIndicesHandle FIndicesHandle;
81
82 public:
83
84 //---------------------------------------------------------------- item types
85
86 typedef typename MeshItems::Vertex Vertex;
87 typedef typename MeshItems::Halfedge Halfedge;
88 typedef typename MeshItems::Edge Edge;
89 typedef typename MeshItems::Face Face;
90
91 typedef typename MeshItems::Point Point;
92 typedef typename MeshItems::Normal Normal;
93 typedef typename MeshItems::Color Color;
94 typedef typename MeshItems::TexCoord TexCoord;
95
96 typedef typename MeshItems::Scalar Scalar;
97
98 typedef Attributes::StatusInfo StatusInfo;
99
100
101 enum Attribs {
102 VAttribs = MeshItems::VAttribs,
103 HAttribs = MeshItems::HAttribs,
104 EAttribs = MeshItems::EAttribs,
105 FAttribs = MeshItems::FAttribs,
106 };
107
108 typedef GenProg::Bool2Type<(bool)(HAttribs & Attributes::PrevHalfedge)>
109 HasPrevHalfedge;
110
111 //
112
113 typedef typename _t2vp< Point >::prop GeoPositions;
114 typedef typename _t2vn< Normal >::prop GeoNormals;
115 typedef typename _t2vc< Color >::prop GeoColors;
116 typedef typename _t2vtc< TexCoord >::prop GeoTexCoords;
117
118 // typedef typename Base::GeoPTypes GeoPTypes;
119 // typedef typename Base::GeoPLengths GeoPLengths;
120 // typedef typename Base::GeoIndices GeoIndices;
121
122 //-------------------------------------------------- constructor / destructor
123
124 AttribKernelT() :
125
126 refcount_vnormals_(0),
127 refcount_vcolors_(0),
128 refcount_vtexcoords_(0),
129 refcount_vstatus_(0),
130 refcount_estatus_(0),
131 refcount_ecolors_(0),
132 refcount_hstatus_(0),
133 refcount_fnormals_(0),
134 refcount_fcolors_(0),
135 refcount_fstatus_(0)
136
137 {
138 points_ = add_vpositions( Point(), "v:points" );
139
140 face_types_ = add_fptypes();
141 face_lengths_ = add_fplengths();
142 face_indices_ = add_findices( face_types_, face_lengths_);
143
144 if (VAttribs & Attributes::Normal)
145 request_vertex_normals();
146
147 if (VAttribs & Attributes::Color)
148 request_vertex_colors();
149
150 if (VAttribs & Attributes::TexCoord)
151 request_vertex_texcoords();
152
153 if (VAttribs & Attributes::Status)
154 request_vertex_status();
155
156 if (EAttribs & Attributes::Status)
157 request_edge_status();
158
159 if (EAttribs & Attributes::Color)
160 request_edge_colors();
161
162 if (FAttribs & Attributes::Normal)
163 request_face_normals();
164
165 if (FAttribs & Attributes::Color)
166 request_face_colors();
167
168 if (FAttribs & Attributes::Status)
169 request_face_status();
170 }
171
172 ~AttribKernelT()
173 {
174 // should remove properties, but this will be done in
175 // BaseKernel's destructor anyway...
176 }
177
178
179 // ------------------------------------------------------- copy & assignement
180
181 AttribKernelT( const AttribKernelT& _rhs )
182 : Base( _rhs )
183 {
184 operator=(_rhs);
185 }
186
187 AttribKernelT& operator = ( const AttribKernelT& _rhs )
188 {
189 // remove old properties
190 remove_property(points_);
191 remove_property(vertex_normals_);
192 remove_property(vertex_colors_);
193 remove_property(vertex_texcoords_);
194 remove_property(vertex_status_);
195 remove_property(halfedge_status_);
196 remove_property(edge_status_);
197 remove_property(edge_colors_);
198 remove_property(face_normals_);
199 remove_property(face_colors_);
200 remove_property(face_status_);
201
202 // parent deep-copies properties
203 BaseKernel::operator=(_rhs);
204
205 // copy property handles
206 points_ = _rhs.points_;
207 vertex_normals_ = _rhs.vertex_normals_;
208 vertex_colors_ = _rhs.vertex_colors_;
209 vertex_texcoords_ = _rhs.vertex_texcoords_;
210 vertex_status_ = _rhs.vertex_status_;
211 halfedge_status_ = _rhs.halfedge_status_;
212 edge_status_ = _rhs.edge_status_;
213 edge_colors_ = _rhs.edge_colors_;
214 face_normals_ = _rhs.face_normals_;
215 face_colors_ = _rhs.face_colors_;
216 face_status_ = _rhs.face_status_;
217
218 // copy ref-counts
219 refcount_vnormals_ = _rhs.refcount_vnormals_;
220 refcount_vcolors_ = _rhs.refcount_vcolors_;
221 refcount_vtexcoords_ = _rhs.refcount_vtexcoords_;
222 refcount_vstatus_ = _rhs.refcount_vstatus_;
223 refcount_hstatus_ = _rhs.refcount_hstatus_;
224 refcount_estatus_ = _rhs.refcount_estatus_;
225 refcount_ecolors_ = _rhs.refcount_ecolors_;
226 refcount_fnormals_ = _rhs.refcount_fnormals_;
227 refcount_fcolors_ = _rhs.refcount_fcolors_;
228 refcount_fstatus_ = _rhs.refcount_fstatus_;
229
230 return *this;
231 }
232
233 //------------------------------------------------------------ osg properties
234
235 //------------------------------ vertex property
236
237 typename GeoPositions::property_ptr_t osg_vpositions()
238 { return vpositions(points_).osg_ptr(); }
239
240 typename GeoNormals::property_ptr_t osg_vnormals()
241 { return vnormals(vertex_normals_).osg_ptr(); }
242
243 typename GeoColors::property_ptr_t osg_vcolors()
244 { return vcolors(vertex_colors_).osg_ptr(); }
245
246 typename GeoTexCoords::property_ptr_t osg_vtexcoords()
247 { return vtexcoords(vertex_texcoords_).osg_ptr(); }
248
249 //------------------------------ edge property
250
251 typename GeoColors::property_ptr_t osg_ecolors()
252 { return ecolors(edge_colors_).osg_ptr(); }
253
254 //------------------------------ face property
255
256 GeoPTypes::property_ptr_t osg_ptypes()
257 { return fptypes( face_types_ ).osg_ptr(); }
258
259 GeoPLengths::property_ptr_t osg_plengths()
260 { return fplengths( face_lengths_ ).osg_ptr(); }
261
262 typename GeoIndices::property_ptr_t osg_indices()
263 { return findices( face_indices_ ).osg_ptr(); }
264
265
266 //---------------------------------------- set osg geo property
267
268 //------------------------------ face property
269
270 void set_face_types( FaceHandle _fh, GeoPTypes::value_type _t)
271 { fptypes( face_types_, _fh ) = _t; }
272
273 void set_face_lengths( FaceHandle _fh, GeoPLengths::value_type _l)
274 { fplengths( face_lengths_, _fh ) = _l; }
275
276 void set_face_indices( FaceHandle _fh,
277 typename GeoIndices::value_type _i)
278 { findices( face_indices_, _fh ) = _i; }
279
280 //--------------------------------------------------------- set/get properties
281
282 //---------------------------------------- points
283
284 const Point* points() const
285 { return vpositions( points_ ).data(); }
286
287 const Point& point(VertexHandle _vh) const
288 { return vpositions( points_, _vh); }
289
290 void set_point(VertexHandle _vh, const Point& _p)
291 { vpositions( points_, _vh ) = _p; }
292
293
294 //---------------------------------------- vertex normals
295
296 const Normal* vertex_normals() const {
297 return vnormals(vertex_normals_).data();
298 }
299
300 const Normal& normal(VertexHandle _vh) const {
301 return vnormals(vertex_normals_, _vh);
302 }
303
304 void set_normal(VertexHandle _vh, const Normal& _n) {
305 vnormals(vertex_normals_, _vh) = _n;
306 }
307
308
309 //---------------------------------------- vertex colors
310
311 const Color* vertex_colors() const {
312 return vcolors(vertex_colors_).data();
313 }
314
315 const Color& color(VertexHandle _vh) const {
316 return vcolors(vertex_colors_, _vh);
317 }
318
319 void set_color(VertexHandle _vh, const Color& _c) {
320 vcolors(vertex_colors_, _vh) = _c;
321 }
322
323
324 //---------------------------------------- vertex texcoords
325
326 const TexCoord* texcoords() const {
327 return vtexcoords(vertex_texcoords_).data();
328 }
329
330 const TexCoord& texcoord(VertexHandle _vh) const {
331 return vtexcoords(vertex_texcoords_, _vh);
332 }
333
334 void set_texcoord(VertexHandle _vh, const TexCoord& _t) {
335 vtexcoords(vertex_texcoords_, _vh) = _t;
336 }
337
338
339 //---------------------------------------- vertex status
340
341 const StatusInfo& status(VertexHandle _vh) const {
342 return property(vertex_status_, _vh);
343 }
344
345 StatusInfo& status(VertexHandle _vh) {
346 return property(vertex_status_, _vh);
347 }
348
349
350 //---------------------------------------- halfedge status
351
352 const StatusInfo& status(HalfedgeHandle _eh) const {
353 return property(halfedge_status_, _eh);
354 }
355
356 StatusInfo& status(HalfedgeHandle _eh) {
357 return property(halfedge_status_, _eh);
358 }
359
360
361 //---------------------------------------- edge status
362
363 const StatusInfo& status(EdgeHandle _eh) const {
364 return property(edge_status_, _eh);
365 }
366
367 StatusInfo& status(EdgeHandle _eh) {
368 return property(edge_status_, _eh);
369 }
370
371 //---------------------------------------- edge colors
372
373 const Color* edge_colors() const {
374 return ecolors(edge_colors_).data();
375 }
376
377 const Color& color(EdgeHandle _eh) const {
378 return ecolors(edge_colors_, _eh);
379 }
380
381 void set_color(EdgeHandle _eh, const Color& _c) {
382 ecolors(edge_colors_, _eh) = _c;
383 }
384
385
386 //---------------------------------------- face status
387
388 const StatusInfo& status(FaceHandle _fh) const {
389 return property(face_status_, _fh);
390 }
391
392 StatusInfo& status(FaceHandle _fh) {
393 return property(face_status_, _fh);
394 }
395
396
397 //---------------------------------------- face normals
398
399 const Normal& normal(FaceHandle _fh) const {
400 return property(face_normals_, _fh);
401 }
402
403 void set_normal(FaceHandle _fh, const Normal& _n) {
404 property(face_normals_, _fh) = _n;
405 }
406
407
408 //---------------------------------------- face colors
409
410 const Color& color(FaceHandle _fh) const {
411 return property(face_colors_, _fh);
412 }
413
414 void set_color(FaceHandle _fh, const Color& _c) {
415 property(face_colors_, _fh) = _c;
416 }
417
418
419
420 //------------------------------------------------ request / alloc properties
421
422 void request_vertex_normals() {
423 if (!refcount_vnormals_++)
424 vertex_normals_ = add_vnormals( Normal(), "v:normals" );
425 }
426
427 void request_vertex_colors() {
428 if (!refcount_vcolors_++)
429 vertex_colors_ = add_vcolors( Color(), "v:colors" );
430 }
431
432 void request_vertex_texcoords() {
433 if (!refcount_vtexcoords_++)
434 vertex_texcoords_ = add_vtexcoords( TexCoord(), "v:texcoords" );
435 }
436
437 void request_vertex_status() {
438 if (!refcount_vstatus_++)
439 add_property( vertex_status_, "v:status" );
440 }
441
442 void request_halfedge_status() {
443 if (!refcount_hstatus_++)
444 add_property( halfedge_status_, "h:status" );
445 }
446
447 void request_edge_status() {
448 if (!refcount_estatus_++)
449 add_property( edge_status_, "e:status" );
450 }
451
452 void request_edge_colors() {
453 if (!refcount_ecolors_++)
454 edge_colors_ = add_ecolors( Color(), "e:colors" );
455 }
456
457 void request_face_normals() {
458 if (!refcount_fnormals_++)
459 add_property( face_normals_, "f:normals" );
460 }
461
462 void request_face_colors() {
463 if (!refcount_fcolors_++)
464 add_property( face_colors_, "f:colors" );
465 }
466
467 void request_face_status() {
468 if (!refcount_fstatus_++)
469 add_property( face_status_, "f:status" );
470 }
471
472
473
474 //------------------------------------------------- release / free properties
475
476 void release_vertex_normals() {
477 if ((refcount_vnormals_ > 0) && (! --refcount_vnormals_))
478 remove_property(vertex_normals_);
479 }
480
481 void release_vertex_colors() {
482 if ((refcount_vcolors_ > 0) && (! --refcount_vcolors_))
483 remove_property(vertex_colors_);
484 }
485
486 void release_vertex_texcoords() {
487 if ((refcount_vtexcoords_ > 0) && (! --refcount_vtexcoords_))
488 remove_property(vertex_texcoords_);
489 }
490
491 void release_vertex_status() {
492 if ((refcount_vstatus_ > 0) && (! --refcount_vstatus_))
493 remove_property(vertex_status_);
494 }
495
496 void release_halfedge_status() {
497 if ((refcount_hstatus_ > 0) && (! --refcount_hstatus_))
498 remove_property(halfedge_status_);
499 }
500
501 void release_edge_status() {
502 if ((refcount_estatus_ > 0) && (! --refcount_estatus_))
503 remove_property(edge_status_);
504 }
505
506 void release_edge_colors() {
507 if ((refcount_ecolors_ > 0) && (! --refcount_ecolors_))
508 remove_property(edge_colors_);
509 }
510
511 void release_face_normals() {
512 if ((refcount_fnormals_ > 0) && (! --refcount_fnormals_))
513 remove_property(face_normals_);
514 }
515
516 void release_face_colors() {
517 if ((refcount_fcolors_ > 0) && (! --refcount_fcolors_))
518 remove_property(face_colors_);
519 }
520
521 void release_face_status() {
522 if ((refcount_fstatus_ > 0) && (! --refcount_fstatus_))
523 remove_property(face_status_);
524 }
525
526
527 //----------------------------------------------- static check for properties
528
529 typedef
530 GenProg::Bool2Type<(bool)(VAttribs & Attributes::Normal)>
531 HasVertexNormals;
532
533 typedef
534 GenProg::Bool2Type<(bool)(VAttribs & Attributes::Color)>
535 HasVertexColors;
536
537 typedef
538 GenProg::Bool2Type<(bool)(VAttribs & Attributes::TexCoord)>
539 HasVertexTexCoords;
540
541 typedef
542 GenProg::Bool2Type<(bool)(VAttribs & Attributes::Status)>
543 HasVertexStatus;
544
545
546 typedef
547 GenProg::Bool2Type<(bool)(HAttribs & Attributes::PrevHalfedge)>
548 HasPrevHalfedge;
549
550 typedef
551 GenProg::Bool2Type<(bool)(HAttribs & Attributes::Status)>
552 HasHalfedgeStatus;
553
554
555 typedef
556 GenProg::Bool2Type<(bool)(EAttribs & Attributes::Status)>
557 HasEdgeStatus;
558
559 typedef
560 GenProg::Bool2Type<(bool)(EAttribs & Attributes::Color)>
561 HasEdgeColors;
562
563
564 typedef
565 GenProg::Bool2Type<(bool)(FAttribs & Attributes::Normal)>
566 HasFaceNormals;
567
568 typedef
569 GenProg::Bool2Type<(bool)(FAttribs & Attributes::Color)>
570 HasFaceColors;
571
572 typedef
573 GenProg::Bool2Type<(bool)(FAttribs & Attributes::Status)>
574 HasFaceStatus;
575
576
577 //---------------------------------------------- dynamic check for properties
578
579 bool has_vertex_normals() const { return vertex_normals_.is_valid(); }
580 bool has_vertex_colors() const { return vertex_colors_.is_valid(); }
581 bool has_vertex_texcoords() const { return vertex_texcoords_.is_valid(); }
582 bool has_vertex_status() const { return vertex_status_.is_valid(); }
583 bool has_edge_status() const { return edge_status_.is_valid(); }
584 bool has_halfedge_status() const { return halfedge_status_.is_valid(); }
585 bool has_edge_colors() const { return edge_colors_.is_valid(); }
586 bool has_face_normals() const { return face_normals_.is_valid(); }
587 bool has_face_colors() const { return face_colors_.is_valid(); }
588 bool has_face_status() const { return face_status_.is_valid(); }
589
590 static bool has_prev_halfedge() {
591 return (HAttribs & Attributes::PrevHalfedge);
592 }
593
594
595 public:
596
597 osg::GeometryPtr createGeometryPtr()
598 {
599 using namespace osg;
600 GeometryPtr geo=Geometry::create();
601 return bind(geo) ? geo : NullFC;
602 }
603
604 // create new geometry core from mesh
605 bool bind( osg::GeometryPtr& _geo )
606 {
607 using namespace osg;
608
609 int Mask =
610 Geometry::TypesFieldMask |
611 Geometry::LengthsFieldMask |
612 Geometry::IndicesFieldMask |
613 Geometry::PositionsFieldMask;
614
615 if ( has_vertex_colors() )
616 Mask |= Geometry::ColorsFieldMask;
617 if ( has_vertex_normals() )
618 Mask |= Geometry::NormalsFieldMask;
619 if ( has_vertex_texcoords() )
620 Mask |= Geometry::TexCoordsFieldMask;
621
622 // std::clog << "#ptypes : " << osg_ptypes()->getSize() << std::endl;
623 // std::clog << "#plengths : " << osg_plengths()->getSize() << std::endl;
624 // std::clog << "#indices : " << osg_indices()->getSize() << std::endl;
625 // std::clog << "#points : " << osg_vpositions()->getSize() << std::endl;
626
627 beginEditCP( _geo, Mask );
628 {
629 addRefCP( osg_ptypes() );
630 _geo->setTypes ( osg_ptypes() );
631 addRefCP( osg_plengths() );
632 _geo->setLengths ( osg_plengths() );
633 addRefCP( osg_indices() );
634 _geo->setIndices ( osg_indices() );
635 addRefCP( osg_vpositions() );
636 _geo->setPositions( osg_vpositions() );
637
638 if ( has_vertex_colors() )
639 {
640 addRefCP( osg_vcolors() );
641 _geo->setColors ( osg_vcolors() );
642 }
643 if ( has_vertex_normals() )
644 {
645 addRefCP( osg_vnormals() );
646 _geo->setNormals ( osg_vnormals() );
647 }
648 if ( has_vertex_texcoords() )
649 {
650 addRefCP( osg_vtexcoords() );
651 _geo->setTexCoords( osg_vtexcoords() );
652 }
653 }
654 endEditCP (_geo, Mask);
655
656 return true;
657 }
658
659 private:
660
661 VPropHandleT<Point> points_;
662 VPropHandleT<Normal> vertex_normals_;
663 VPropHandleT<Color> vertex_colors_;
664 VPropHandleT<TexCoord> vertex_texcoords_;
665 VPropHandleT<StatusInfo> vertex_status_;
666
667 FPTypesHandle face_types_;
668 FPLengthsHandle face_lengths_;
669 FIndicesHandle face_indices_;
670
671 EPropHandleT<StatusInfo> edge_status_;
672 EPropHandleT<StatusInfo> edge_colors_;
673 HPropHandleT<StatusInfo> halfedge_status_;
674
675 FPropHandleT<Normal> face_normals_;
676 FPropHandleT<Color> face_colors_;
677 FPropHandleT<StatusInfo> face_status_;
678
679 unsigned int refcount_vnormals_;
680 unsigned int refcount_vcolors_;
681 unsigned int refcount_vtexcoords_;
682 unsigned int refcount_vstatus_;
683 unsigned int refcount_estatus_;
684 unsigned int refcount_ecolors_;
685 unsigned int refcount_hstatus_;
686 unsigned int refcount_fnormals_;
687 unsigned int refcount_fcolors_;
688 unsigned int refcount_fstatus_;
689
690 };
691
692
693 //=============================================================================
694 } // namespace Kernel_OSG
695 } // namespace OpenMesh
696 //=============================================================================
697 #endif // OPENMESH_KERNEL_OSG_ATTRIBKERNEL_HH defined
698 //=============================================================================
699
OpenMesh::BaseKernel::property
PropertyT< T > & property(VPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:310
OpenMesh::BaseKernel::remove_property
void remove_property(VPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:194
OpenMesh::HalfedgeHandle
Handle for a halfedge entity.
Definition: Handles.hh:127
OpenMesh::FPropHandleT
Handle representing a face property.
Definition: Property.hh:524
OpenMesh::Attributes::StatusInfo
Add status information to a base class.
Definition: Status.hh:94
OpenMesh::Kernel_OSG::bind
bool bind(osg::GeometryPtr &_geo, Mesh &_mesh)
Bind a OpenSG geometry to a mesh.
Definition: bindT.hh:101
OpenMesh::VPropHandleT< Point >
OpenMesh::BaseKernel::add_property
void add_property(VPropHandleT< T > &_ph, const std::string &_name="<vprop>")
You should not use this function directly.
Definition: BaseKernel.hh:141
OpenMesh::Attributes::Status
Add status to mesh item (all items)
Definition: Attributes.hh:85
OpenMesh::VertexHandle
Handle for a vertex entity.
Definition: Handles.hh:120
OpenMesh::EdgeHandle
Handle for a edge entity.
Definition: Handles.hh:134
OpenMesh::Kernel_OSG::AttribKernelT
This class adds the standard properties to the mesh type.
Definition: AttribKernelT.hh:70
OpenMesh::Attributes::PrevHalfedge
Add storage for previous halfedge (halfedges). The bit is set by default in the DefaultTraits.
Definition: Attributes.hh:84
OpenMesh::Attributes::Color
Add colors to mesh item (vertices/faces/edges)
Definition: Attributes.hh:83
OpenMesh::Attributes::Normal
Add normals to mesh item (vertices/faces)
Definition: Attributes.hh:82
Attributes.hh
This file provides some macros containing attribute usage.
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:59
OpenMesh::EPropHandleT< StatusInfo >
OpenMesh::FaceHandle
Handle for a face entity.
Definition: Handles.hh:141
OpenMesh::Kernel_OSG::PropertyKernel
Helper class, extending functionaliy of OpenMesh::BaseKernel to OpenSG specific property adaptors...
Definition: PropertyKernel.hh:68
OpenMesh::BaseHandle::is_valid
bool is_valid() const
The handle is valid iff the index is not negative.
Definition: Handles.hh:72
OpenMesh::HPropHandleT< StatusInfo >