OpenMesh
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
AttribKernelT.hh
1 /*===========================================================================*\
2  * *
3  * OpenMesh *
4  * Copyright (C) 2001-2012 by Computer Graphics Group, RWTH Aachen *
5  * www.openmesh.org *
6  * *
7  *---------------------------------------------------------------------------*
8  * This file is part of OpenMesh. *
9  * *
10  * OpenMesh is free software: you can redistribute it and/or modify *
11  * it under the terms of the GNU Lesser General Public License as *
12  * published by the Free Software Foundation, either version 3 of *
13  * the License, or (at your option) any later version with the *
14  * following exceptions: *
15  * *
16  * If other files instantiate templates or use macros *
17  * or inline functions from this file, or you compile this file and *
18  * link it with other files to produce an executable, this file does *
19  * not by itself cause the resulting executable to be covered by the *
20  * GNU Lesser General Public License. This exception does not however *
21  * invalidate any other reasons why the executable file might be *
22  * covered by the GNU Lesser General Public License. *
23  * *
24  * OpenMesh is distributed in the hope that it will be useful, *
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
27  * GNU Lesser General Public License for more details. *
28  * *
29  * You should have received a copy of the GNU LesserGeneral Public *
30  * License along with OpenMesh. If not, *
31  * see <http://www.gnu.org/licenses/>. *
32  * *
33 \*===========================================================================*/
34 
35 /*===========================================================================*\
36  * *
37  * $Revision: 736 $ *
38  * $Date: 2012-10-08 09:30:49 +0200 (Mo, 08 Okt 2012) $ *
39  * *
40 \*===========================================================================*/
41 
42 #ifndef OPENMESH_ATTRIBKERNEL_HH
43 #define OPENMESH_ATTRIBKERNEL_HH
44 
45 
46 //== INCLUDES =================================================================
47 
49 #include <OpenMesh/Core/Utils/GenProg.hh>
50 #include <OpenMesh/Core/Utils/vector_traits.hh>
51 #include <vector>
52 #include <algorithm>
53 
54 //== NAMESPACES ===============================================================
55 
56 namespace OpenMesh {
57 
58 
59 //== CLASS DEFINITION =========================================================
60 
69 template <class MeshItems, class Connectivity>
70 class AttribKernelT : public Connectivity
71 {
72 public:
73 
74  //---------------------------------------------------------------- item types
75 
76  typedef typename Connectivity::Vertex Vertex;
77  typedef typename Connectivity::Halfedge Halfedge;
78  typedef typename Connectivity::Edge Edge;
79  typedef typename Connectivity::Face Face;
80 
81  typedef typename MeshItems::Point Point;
82  typedef typename MeshItems::Normal Normal;
83  typedef typename MeshItems::Color Color;
84  typedef typename MeshItems::TexCoord1D TexCoord1D;
85  typedef typename MeshItems::TexCoord2D TexCoord2D;
86  typedef typename MeshItems::TexCoord3D TexCoord3D;
87  typedef typename MeshItems::Scalar Scalar;
88  typedef typename MeshItems::TextureIndex TextureIndex;
89 
90  typedef typename MeshItems::VertexData VertexData;
91  typedef typename MeshItems::HalfedgeData HalfedgeData;
92  typedef typename MeshItems::EdgeData EdgeData;
93  typedef typename MeshItems::FaceData FaceData;
94 
96 
97  enum Attribs {
98  VAttribs = MeshItems::VAttribs,
99  HAttribs = MeshItems::HAttribs,
100  EAttribs = MeshItems::EAttribs,
101  FAttribs = MeshItems::FAttribs
102  };
103 
108 
109 public:
110 
111  //-------------------------------------------------- constructor / destructor
112 
113  AttribKernelT()
114  : refcount_vnormals_(0),
115  refcount_vcolors_(0),
116  refcount_vtexcoords1D_(0),
117  refcount_vtexcoords2D_(0),
118  refcount_vtexcoords3D_(0),
119  refcount_htexcoords1D_(0),
120  refcount_htexcoords2D_(0),
121  refcount_htexcoords3D_(0),
122  refcount_henormals_(0),
123  refcount_hecolors_(0),
124  refcount_ecolors_(0),
125  refcount_fnormals_(0),
126  refcount_fcolors_(0),
127  refcount_ftextureIndex_(0)
128  {
129  this->add_property( points_, "v:points" );
130 
131  if (VAttribs & Attributes::Normal)
132  request_vertex_normals();
133 
134  if (VAttribs & Attributes::Color)
135  request_vertex_colors();
136 
137  if (VAttribs & Attributes::TexCoord1D)
138  request_vertex_texcoords1D();
139 
140  if (VAttribs & Attributes::TexCoord2D)
141  request_vertex_texcoords2D();
142 
143  if (VAttribs & Attributes::TexCoord3D)
144  request_vertex_texcoords3D();
145 
146  if (HAttribs & Attributes::TexCoord1D)
147  request_halfedge_texcoords1D();
148 
149  if (HAttribs & Attributes::TexCoord2D)
150  request_halfedge_texcoords2D();
151 
152  if (HAttribs & Attributes::TexCoord3D)
153  request_halfedge_texcoords3D();
154 
155  if (HAttribs & Attributes::Color)
156  request_halfedge_colors();
157 
158  if (VAttribs & Attributes::Status)
159  Connectivity::request_vertex_status();
160 
161  if (HAttribs & Attributes::Status)
162  Connectivity::request_halfedge_status();
163 
164  if (HAttribs & Attributes::Normal)
165  request_halfedge_normals();
166 
167  if (EAttribs & Attributes::Status)
168  Connectivity::request_edge_status();
169 
170  if (EAttribs & Attributes::Color)
171  request_edge_colors();
172 
173  if (FAttribs & Attributes::Normal)
174  request_face_normals();
175 
176  if (FAttribs & Attributes::Color)
177  request_face_colors();
178 
179  if (FAttribs & Attributes::Status)
180  Connectivity::request_face_status();
181 
182  if (FAttribs & Attributes::TextureIndex)
183  request_face_texture_index();
184 
185  //FIXME: data properties might actually cost storage even
186  //if there are no data traits??
187  this->add_property(data_vpph_);
188  this->add_property(data_fpph_);
189  this->add_property(data_hpph_);
190  this->add_property(data_epph_);
191  }
192 
193  virtual ~AttribKernelT()
194  {
195  // should remove properties, but this will be done in
196  // BaseKernel's destructor anyway...
197  }
198 
207  template <class _AttribKernel>
208  void assign(const _AttribKernel& _other)
209  {
210  this->assign_connectivity(_other);
211  for (typename Connectivity::VertexIter v_it = Connectivity::vertices_begin();
212  v_it != Connectivity::vertices_end(); ++v_it)
213  {//assumes Point constructor supports cast from _AttribKernel::Point
214  set_point(v_it, (Point)_other.point(v_it));
215  }
216  }
217 
218  //-------------------------------------------------------------------- points
219 
220  const Point* points() const
221  { return this->property(points_).data(); }
222 
223  const Point& point(VertexHandle _vh) const
224  { return this->property(points_, _vh); }
225 
226  Point& point(VertexHandle _vh)
227  { return this->property(points_, _vh); }
228 
229  void set_point(VertexHandle _vh, const Point& _p)
230  { this->property(points_, _vh) = _p; }
231 
232 
233  //------------------------------------------------------------ vertex normals
234 
235  const Normal* vertex_normals() const
236  { return this->property(vertex_normals_).data(); }
237 
238  const Normal& normal(VertexHandle _vh) const
239  { return this->property(vertex_normals_, _vh); }
240 
241  void set_normal(VertexHandle _vh, const Normal& _n)
242  { this->property(vertex_normals_, _vh) = _n; }
243 
244 
245  //------------------------------------------------------------- vertex colors
246 
247  const Color* vertex_colors() const
248  { return this->property(vertex_colors_).data(); }
249 
250  const Color& color(VertexHandle _vh) const
251  { return this->property(vertex_colors_, _vh); }
252 
253  void set_color(VertexHandle _vh, const Color& _c)
254  { this->property(vertex_colors_, _vh) = _c; }
255 
256 
257  //------------------------------------------------------- vertex 1D texcoords
258 
259  const TexCoord1D* texcoords1D() const {
260  return this->property(vertex_texcoords1D_).data();
261  }
262 
263  const TexCoord1D& texcoord1D(VertexHandle _vh) const {
264  return this->property(vertex_texcoords1D_, _vh);
265  }
266 
267  void set_texcoord1D(VertexHandle _vh, const TexCoord1D& _t) {
268  this->property(vertex_texcoords1D_, _vh) = _t;
269  }
270 
271 
272  //------------------------------------------------------- vertex 2D texcoords
273 
274  const TexCoord2D* texcoords2D() const {
275  return this->property(vertex_texcoords2D_).data();
276  }
277 
278  const TexCoord2D& texcoord2D(VertexHandle _vh) const {
279  return this->property(vertex_texcoords2D_, _vh);
280  }
281 
282  void set_texcoord2D(VertexHandle _vh, const TexCoord2D& _t) {
283  this->property(vertex_texcoords2D_, _vh) = _t;
284  }
285 
286 
287  //------------------------------------------------------- vertex 3D texcoords
288 
289  const TexCoord3D* texcoords3D() const {
290  return this->property(vertex_texcoords3D_).data();
291  }
292 
293  const TexCoord3D& texcoord3D(VertexHandle _vh) const {
294  return this->property(vertex_texcoords3D_, _vh);
295  }
296 
297  void set_texcoord3D(VertexHandle _vh, const TexCoord3D& _t) {
298  this->property(vertex_texcoords3D_, _vh) = _t;
299  }
300 
301  //.------------------------------------------------------ halfedge 1D texcoords
302 
303  const TexCoord1D* htexcoords1D() const {
304  return this->property(halfedge_texcoords1D_).data();
305  }
306 
307  const TexCoord1D& texcoord1D(HalfedgeHandle _heh) const {
308  return this->property(halfedge_texcoords1D_, _heh);
309  }
310 
311  void set_texcoord1D(HalfedgeHandle _heh, const TexCoord1D& _t) {
312  this->property(halfedge_texcoords1D_, _heh) = _t;
313  }
314 
315 
316  //------------------------------------------------------- halfedge 2D texcoords
317 
318  const TexCoord2D* htexcoords2D() const {
319  return this->property(halfedge_texcoords2D_).data();
320  }
321 
322  const TexCoord2D& texcoord2D(HalfedgeHandle _heh) const {
323  return this->property(halfedge_texcoords2D_, _heh);
324  }
325 
326  void set_texcoord2D(HalfedgeHandle _heh, const TexCoord2D& _t) {
327  this->property(halfedge_texcoords2D_, _heh) = _t;
328  }
329 
330 
331  //------------------------------------------------------- halfedge 3D texcoords
332 
333  const TexCoord3D* htexcoords3D() const {
334  return this->property(halfedge_texcoords3D_).data();
335  }
336 
337  const TexCoord3D& texcoord3D(HalfedgeHandle _heh) const {
338  return this->property(halfedge_texcoords3D_, _heh);
339  }
340 
341  void set_texcoord3D(HalfedgeHandle _heh, const TexCoord3D& _t) {
342  this->property(halfedge_texcoords3D_, _heh) = _t;
343  }
344 
345  //------------------------------------------------------------- edge colors
346 
347  const Color* edge_colors() const
348  { return this->property(edge_colors_).data(); }
349 
350  const Color& color(EdgeHandle _eh) const
351  { return this->property(edge_colors_, _eh); }
352 
353  void set_color(EdgeHandle _eh, const Color& _c)
354  { this->property(edge_colors_, _eh) = _c; }
355 
356 
357  //------------------------------------------------------------- halfedge normals
358 
359  const Normal& normal(HalfedgeHandle _heh) const
360  { return this->property(halfedge_normals_, _heh); }
361 
362  void set_normal(HalfedgeHandle _heh, const Normal& _n)
363  { this->property(halfedge_normals_, _heh) = _n; }
364 
365 
366  //------------------------------------------------------------- halfedge colors
367 
368  const Color* halfedge_colors() const
369  { return this->property(halfedge_colors_).data(); }
370 
371  const Color& color(HalfedgeHandle _heh) const
372  { return this->property(halfedge_colors_, _heh); }
373 
374  void set_color(HalfedgeHandle _heh, const Color& _c)
375  { this->property(halfedge_colors_, _heh) = _c; }
376 
377  //-------------------------------------------------------------- face normals
378 
379  const Normal& normal(FaceHandle _fh) const
380  { return this->property(face_normals_, _fh); }
381 
382  void set_normal(FaceHandle _fh, const Normal& _n)
383  { this->property(face_normals_, _fh) = _n; }
384 
385  //-------------------------------------------------------------- per Face Texture index
386 
387  const TextureIndex& texture_index(FaceHandle _fh) const
388  { return this->property(face_texture_index_, _fh); }
389 
390  void set_texture_index(FaceHandle _fh, const TextureIndex& _t)
391  { this->property(face_texture_index_, _fh) = _t; }
392 
393  //--------------------------------------------------------------- face colors
394 
395  const Color& color(FaceHandle _fh) const
396  { return this->property(face_colors_, _fh); }
397 
398  void set_color(FaceHandle _fh, const Color& _c)
399  { this->property(face_colors_, _fh) = _c; }
400 
401  //------------------------------------------------ request / alloc properties
402 
403  void request_vertex_normals()
404  {
405  if (!refcount_vnormals_++)
406  this->add_property( vertex_normals_, "v:normals" );
407  }
408 
409  void request_vertex_colors()
410  {
411  if (!refcount_vcolors_++)
412  this->add_property( vertex_colors_, "v:colors" );
413  }
414 
415  void request_vertex_texcoords1D()
416  {
417  if (!refcount_vtexcoords1D_++)
418  this->add_property( vertex_texcoords1D_, "v:texcoords1D" );
419  }
420 
421  void request_vertex_texcoords2D()
422  {
423  if (!refcount_vtexcoords2D_++)
424  this->add_property( vertex_texcoords2D_, "v:texcoords2D" );
425  }
426 
427  void request_vertex_texcoords3D()
428  {
429  if (!refcount_vtexcoords3D_++)
430  this->add_property( vertex_texcoords3D_, "v:texcoords3D" );
431  }
432 
433  void request_halfedge_texcoords1D()
434  {
435  if (!refcount_htexcoords1D_++)
436  this->add_property( halfedge_texcoords1D_, "h:texcoords1D" );
437  }
438 
439  void request_halfedge_texcoords2D()
440  {
441  if (!refcount_htexcoords2D_++)
442  this->add_property( halfedge_texcoords2D_, "h:texcoords2D" );
443  }
444 
445  void request_halfedge_texcoords3D()
446  {
447  if (!refcount_htexcoords3D_++)
448  this->add_property( halfedge_texcoords3D_, "h:texcoords3D" );
449  }
450 
451  void request_edge_colors()
452  {
453  if (!refcount_ecolors_++)
454  this->add_property( edge_colors_, "e:colors" );
455  }
456 
457  void request_halfedge_normals()
458  {
459  if (!refcount_henormals_++)
460  this->add_property( halfedge_normals_, "h:normals" );
461  }
462 
463  void request_halfedge_colors()
464  {
465  if (!refcount_hecolors_++)
466  this->add_property( halfedge_colors_, "h:colors" );
467  }
468 
469  void request_face_normals()
470  {
471  if (!refcount_fnormals_++)
472  this->add_property( face_normals_, "f:normals" );
473  }
474 
475  void request_face_colors()
476  {
477  if (!refcount_fcolors_++)
478  this->add_property( face_colors_, "f:colors" );
479  }
480 
481  void request_face_texture_index()
482  {
483  if (!refcount_ftextureIndex_++)
484  this->add_property( face_texture_index_, "f:textureindex" );
485  }
486 
487  //------------------------------------------------- release / free properties
488 
489  void release_vertex_normals()
490  {
491  if ((refcount_vnormals_ > 0) && (! --refcount_vnormals_))
492  this->remove_property(vertex_normals_);
493  }
494 
495  void release_vertex_colors()
496  {
497  if ((refcount_vcolors_ > 0) && (! --refcount_vcolors_))
498  this->remove_property(vertex_colors_);
499  }
500 
501  void release_vertex_texcoords1D() {
502  if ((refcount_vtexcoords1D_ > 0) && (! --refcount_vtexcoords1D_))
503  this->remove_property(vertex_texcoords1D_);
504  }
505 
506  void release_vertex_texcoords2D() {
507  if ((refcount_vtexcoords2D_ > 0) && (! --refcount_vtexcoords2D_))
508  this->remove_property(vertex_texcoords2D_);
509  }
510 
511  void release_vertex_texcoords3D() {
512  if ((refcount_vtexcoords3D_ > 0) && (! --refcount_vtexcoords3D_))
513  this->remove_property(vertex_texcoords3D_);
514  }
515 
516  void release_halfedge_texcoords1D() {
517  if ((refcount_htexcoords1D_ > 0) && (! --refcount_htexcoords1D_))
518  this->remove_property(halfedge_texcoords1D_);
519  }
520 
521  void release_halfedge_texcoords2D() {
522  if ((refcount_htexcoords2D_ > 0) && (! --refcount_htexcoords2D_))
523  this->remove_property(halfedge_texcoords2D_);
524  }
525 
526  void release_halfedge_texcoords3D() {
527  if ((refcount_htexcoords3D_ > 0) && (! --refcount_htexcoords3D_))
528  this->remove_property(halfedge_texcoords3D_);
529  }
530 
531  void release_edge_colors()
532  {
533  if ((refcount_ecolors_ > 0) && (! --refcount_ecolors_))
534  this->remove_property(edge_colors_);
535  }
536 
537  void release_halfedge_normals()
538  {
539  if ((refcount_henormals_ > 0) && (! --refcount_henormals_))
540  this->remove_property(halfedge_normals_);
541  }
542 
543  void release_halfedge_colors()
544  {
545  if ((refcount_hecolors_ > 0) && (! --refcount_hecolors_))
546  this->remove_property(halfedge_colors_);
547  }
548 
549  void release_face_normals()
550  {
551  if ((refcount_fnormals_ > 0) && (! --refcount_fnormals_))
552  this->remove_property(face_normals_);
553  }
554 
555  void release_face_colors()
556  {
557  if ((refcount_fcolors_ > 0) && (! --refcount_fcolors_))
558  this->remove_property(face_colors_);
559  }
560 
561  void release_face_texture_index()
562  {
563  if ((refcount_ftextureIndex_ > 0) && (! --refcount_ftextureIndex_))
564  this->remove_property(face_texture_index_);
565  }
566 
567  //---------------------------------------------- dynamic check for properties
568 
569  bool has_vertex_normals() const { return vertex_normals_.is_valid(); }
570  bool has_vertex_colors() const { return vertex_colors_.is_valid(); }
571  bool has_vertex_texcoords1D() const { return vertex_texcoords1D_.is_valid(); }
572  bool has_vertex_texcoords2D() const { return vertex_texcoords2D_.is_valid(); }
573  bool has_vertex_texcoords3D() const { return vertex_texcoords3D_.is_valid(); }
574  bool has_halfedge_texcoords1D() const { return halfedge_texcoords1D_.is_valid();}
575  bool has_halfedge_texcoords2D() const { return halfedge_texcoords2D_.is_valid();}
576  bool has_halfedge_texcoords3D() const { return halfedge_texcoords3D_.is_valid();}
577  bool has_edge_colors() const { return edge_colors_.is_valid(); }
578  bool has_halfedge_normals() const { return halfedge_normals_.is_valid(); }
579  bool has_halfedge_colors() const { return halfedge_colors_.is_valid(); }
580  bool has_face_normals() const { return face_normals_.is_valid(); }
581  bool has_face_colors() const { return face_colors_.is_valid(); }
582  bool has_face_texture_index() const { return face_texture_index_.is_valid(); }
583 
584 public:
585 
586  typedef VPropHandleT<Point> PointsPropertyHandle;
587  typedef VPropHandleT<Normal> VertexNormalsPropertyHandle;
588  typedef VPropHandleT<Color> VertexColorsPropertyHandle;
589  typedef VPropHandleT<TexCoord1D> VertexTexCoords1DPropertyHandle;
590  typedef VPropHandleT<TexCoord2D> VertexTexCoords2DPropertyHandle;
591  typedef VPropHandleT<TexCoord3D> VertexTexCoords3DPropertyHandle;
592  typedef HPropHandleT<TexCoord1D> HalfedgeTexCoords1DPropertyHandle;
593  typedef HPropHandleT<TexCoord2D> HalfedgeTexCoords2DPropertyHandle;
594  typedef HPropHandleT<TexCoord3D> HalfedgeTexCoords3DPropertyHandle;
595  typedef EPropHandleT<Color> EdgeColorsPropertyHandle;
596  typedef HPropHandleT<Normal> HalfedgeNormalsPropertyHandle;
597  typedef HPropHandleT<Color> HalfedgeColorsPropertyHandle;
598  typedef FPropHandleT<Normal> FaceNormalsPropertyHandle;
599  typedef FPropHandleT<Color> FaceColorsPropertyHandle;
600  typedef FPropHandleT<TextureIndex> FaceTextureIndexPropertyHandle;
601 
602 public:
603  //standard vertex properties
604  PointsPropertyHandle points_pph() const
605  { return points_; }
606 
607  VertexNormalsPropertyHandle vertex_normals_pph() const
608  { return vertex_normals_; }
609 
610  VertexColorsPropertyHandle vertex_colors_pph() const
611  { return vertex_colors_; }
612 
613  VertexTexCoords1DPropertyHandle vertex_texcoords1D_pph() const
614  { return vertex_texcoords1D_; }
615 
616  VertexTexCoords2DPropertyHandle vertex_texcoords2D_pph() const
617  { return vertex_texcoords2D_; }
618 
619  VertexTexCoords3DPropertyHandle vertex_texcoords3D_pph() const
620  { return vertex_texcoords3D_; }
621 
622  //standard halfedge properties
623  HalfedgeTexCoords1DPropertyHandle halfedge_texcoords1D_pph() const
624  { return halfedge_texcoords1D_; }
625 
626  HalfedgeTexCoords2DPropertyHandle halfedge_texcoords2D_pph() const
627  { return halfedge_texcoords2D_; }
628 
629  HalfedgeTexCoords3DPropertyHandle halfedge_texcoords3D_pph() const
630  { return halfedge_texcoords3D_; }
631 
632  // standard edge properties
633  HalfedgeNormalsPropertyHandle halfedge_normals_pph() const
634  { return halfedge_normals_; }
635 
636 
637  // standard edge properties
638  HalfedgeColorsPropertyHandle halfedge_colors_pph() const
639  { return halfedge_colors_; }
640 
641  // standard edge properties
642  EdgeColorsPropertyHandle edge_colors_pph() const
643  { return edge_colors_; }
644 
645  //standard face properties
646  FaceNormalsPropertyHandle face_normals_pph() const
647  { return face_normals_; }
648 
649  FaceColorsPropertyHandle face_colors_pph() const
650  { return face_colors_; }
651 
652  FaceTextureIndexPropertyHandle face_texture_index_pph() const
653  { return face_texture_index_; }
654 
655  VertexData& data(VertexHandle _vh)
656  { return this->property(data_vpph_, _vh); }
657 
658  const VertexData& data(VertexHandle _vh) const
659  { return this->property(data_vpph_, _vh); }
660 
661  FaceData& data(FaceHandle _fh)
662  { return this->property(data_fpph_, _fh); }
663 
664  const FaceData& data(FaceHandle _fh) const
665  { return this->property(data_fpph_, _fh); }
666 
667  EdgeData& data(EdgeHandle _eh)
668  { return this->property(data_epph_, _eh); }
669 
670  const EdgeData& data(EdgeHandle _eh) const
671  { return this->property(data_epph_, _eh); }
672 
673  HalfedgeData& data(HalfedgeHandle _heh)
674  { return this->property(data_hpph_, _heh); }
675 
676  const HalfedgeData& data(HalfedgeHandle _heh) const
677  { return this->property(data_hpph_, _heh); }
678 
679 private:
680  //standard vertex properties
681  PointsPropertyHandle points_;
682  VertexNormalsPropertyHandle vertex_normals_;
683  VertexColorsPropertyHandle vertex_colors_;
684  VertexTexCoords1DPropertyHandle vertex_texcoords1D_;
685  VertexTexCoords2DPropertyHandle vertex_texcoords2D_;
686  VertexTexCoords3DPropertyHandle vertex_texcoords3D_;
687  //standard halfedge properties
688  HalfedgeTexCoords1DPropertyHandle halfedge_texcoords1D_;
689  HalfedgeTexCoords2DPropertyHandle halfedge_texcoords2D_;
690  HalfedgeTexCoords3DPropertyHandle halfedge_texcoords3D_;
691  HalfedgeNormalsPropertyHandle halfedge_normals_;
692  HalfedgeColorsPropertyHandle halfedge_colors_;
693  // standard edge properties
694  EdgeColorsPropertyHandle edge_colors_;
695  //standard face properties
696  FaceNormalsPropertyHandle face_normals_;
697  FaceColorsPropertyHandle face_colors_;
698  FaceTextureIndexPropertyHandle face_texture_index_;
699  //data properties handles
700  DataVPropHandle data_vpph_;
701  DataHPropHandle data_hpph_;
702  DataEPropHandle data_epph_;
703  DataFPropHandle data_fpph_;
704 
705  unsigned int refcount_vnormals_;
706  unsigned int refcount_vcolors_;
707  unsigned int refcount_vtexcoords1D_;
708  unsigned int refcount_vtexcoords2D_;
709  unsigned int refcount_vtexcoords3D_;
710  unsigned int refcount_htexcoords1D_;
711  unsigned int refcount_htexcoords2D_;
712  unsigned int refcount_htexcoords3D_;
713  unsigned int refcount_henormals_;
714  unsigned int refcount_hecolors_;
715  unsigned int refcount_ecolors_;
716  unsigned int refcount_fnormals_;
717  unsigned int refcount_fcolors_;
718  unsigned int refcount_ftextureIndex_;
719 };
720 
721 //=============================================================================
722 } // namespace OpenMesh
723 //=============================================================================
724 #endif // OPENMESH_ATTRIBKERNEL_HH defined
725 //=============================================================================

acg pic Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .