Developer Documentation

MeshNodeDeprecatedT_impl.hh
1 /*===========================================================================*\
2 * *
3 * OpenFlipper *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openflipper.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenFlipper. *
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
45
46
47 //=============================================================================
48 //
49 // CLASS MeshNodeDeprecatedT - IMPLEMENTATION
50 //
51 //=============================================================================
52
53 #ifndef DOXY_IGNORE_THIS
54 #define ACG_MESHNODE_C
55
56 //== INCLUDES =================================================================
57
58
59 #include "MeshNodeDeprecatedT.hh"
60 #include "ShaderNode.hh"
61 #include "DrawModes.hh"
62 #include <ACG/GL/gl.hh>
63 #include <ACG/GL/GLError.hh>
64 #include <ACG/GL/ColorTranslator.hh>
65
66 #include <OpenMesh/Core/System/omstream.hh>
67 #include <OpenMesh/Core/Utils/Property.hh>
68
69 #include <algorithm>
70
71 //== NAMESPACES ==============================================================
72
73
74 namespace ACG {
75 namespace SceneGraph {
76
77
78 //== IMPLEMENTATION ==========================================================
79
80
81 template<class Mesh>
82 MeshNodeDeprecatedT<Mesh>::
83 MeshNodeDeprecatedT(const Mesh& _mesh,
84 BaseNode* _parent,
85 std::string _name)
86 : BaseNode(_parent, _name),
87 mesh_(_mesh),
88 enabled_arrays_(0),
89 face_index_buffer_(0),
90 vertex_buffer_(0),
91 normal_buffer_(0),
92 vertexBufferInitialized_(false),
93 normalBufferInitialized_(false),
94 faceIndexBufferInitialized_(false),
95 textureMap_(0),
96 propertyMap_(0),
97 default_halfedge_textcoord_property_("h:texcoords2D"),
98 indexPropertyName_("f:textureindex"),
99 updateFaceList_(true),
100 updateVertexList_(true),
101 updateEdgeList_(true),
102 updateAnyList_(true),
103 faceBaseIndex_(0),
104 vertexBaseIndex_(0),
105 edgeBaseIndex_(0),
106 anyBaseIndex_(0),
107 bbMin_(FLT_MAX, FLT_MAX, FLT_MAX),
108 bbMax_(-FLT_MAX, -FLT_MAX, -FLT_MAX)
109 {
110 faceList_ = glGenLists (1);
111 vertexList_ = glGenLists (1);
112 edgeList_ = glGenLists (1);
113 anyList_ = glGenLists (3);
114 }
115
116
117 //----------------------------------------------------------------------------
118
119
120 template<class Mesh>
121 MeshNodeDeprecatedT<Mesh>::
122 ~MeshNodeDeprecatedT()
123 {
124 if (vertex_buffer_)
125 glDeleteBuffers(1, (GLuint*) &vertex_buffer_);
126
127 if (normal_buffer_)
128 glDeleteBuffers(1, (GLuint*) &normal_buffer_);
129
130 if (face_index_buffer_)
131 glDeleteBuffers(1, (GLuint*) &face_index_buffer_ );
132
133 if (faceList_)
134 glDeleteLists (faceList_, 1);
135
136 if (vertexList_)
137 glDeleteLists (vertexList_, 1);
138
139 if (edgeList_)
140 glDeleteLists (edgeList_, 1);
141
142 if (anyList_)
143 glDeleteLists (anyList_, 3);
144 }
145
146
147 //----------------------------------------------------------------------------
148
149
150 template<class Mesh>
151 void
152 MeshNodeDeprecatedT<Mesh>::
153 boundingBox(Vec3d& _bbMin, Vec3d& _bbMax)
154 {
155 _bbMin.minimize(bbMin_);
156 _bbMax.maximize(bbMax_);
157 }
158
159
160 //----------------------------------------------------------------------------
161
162
163 template<class Mesh>
164 DrawModes::DrawMode
165 MeshNodeDeprecatedT<Mesh>::
166 availableDrawModes() const
167 {
168 DrawModes::DrawMode drawModes(DrawModes::NONE);
169
170 drawModes |= DrawModes::POINTS;
171 drawModes |= DrawModes::WIREFRAME;
172 drawModes |= DrawModes::HIDDENLINE;
173 drawModes |= DrawModes::SOLID_SHADER;
174
175 if (mesh_.has_vertex_normals())
176 {
177 drawModes |= DrawModes::POINTS_SHADED;
178 drawModes |= DrawModes::SOLID_SMOOTH_SHADED;
179 drawModes |= DrawModes::SOLID_PHONG_SHADED;
180 }
181
182 if (mesh_.has_vertex_colors())
183 {
184 drawModes |= DrawModes::POINTS_COLORED;
185 drawModes |= DrawModes::SOLID_POINTS_COLORED;
186 }
187
188 if (mesh_.has_face_normals())
189 drawModes |= DrawModes::SOLID_FLAT_SHADED;
190
191 if (mesh_.has_face_colors())
192 {
193 drawModes |= DrawModes::SOLID_FACES_COLORED;
194
195 if( mesh_.has_face_normals() )
196 drawModes |= DrawModes::SOLID_FACES_COLORED_FLAT_SHADED;
197 }
198
199 if (mesh_.has_vertex_texcoords1D())
200 {
201 drawModes |= DrawModes::SOLID_1DTEXTURED;
202
203 if (mesh_.has_vertex_normals())
204 drawModes |= DrawModes::SOLID_1DTEXTURED_SHADED;
205 }
206
207 if (mesh_.has_vertex_texcoords2D())
208 {
209 drawModes |= DrawModes::SOLID_TEXTURED;
210
211 if (mesh_.has_vertex_normals())
212 drawModes |= DrawModes::SOLID_TEXTURED_SHADED;
213 }
214
215 if (mesh_.has_vertex_texcoords3D())
216 {
217 drawModes |= DrawModes::SOLID_3DTEXTURED;
218
219 if (mesh_.has_vertex_normals())
220 drawModes |= DrawModes::SOLID_3DTEXTURED_SHADED;
221 }
222
223 if (mesh_.has_halfedge_texcoords2D())
224 {
225 drawModes |= DrawModes::SOLID_2DTEXTURED_FACE;
226 if (mesh_.has_face_normals())
227 drawModes |= DrawModes::SOLID_2DTEXTURED_FACE_SHADED;
228 }
229
230 return drawModes;
231 }
232
233
234 //----------------------------------------------------------------------------
235
236
237 template<class Mesh>
238 void
239 MeshNodeDeprecatedT<Mesh>::
240 enable_arrays(unsigned int _arrays)
241 {
242 // special case: VBO
243 // only use for float data, otherwise it's terribly slow!
244 typedef typename Mesh::Point Point;
245 typedef typename Point::value_type PointScalar;
246 typedef typename Mesh::Normal Normal;
247 typedef typename Normal::value_type NormalScalar;
248
249 bool use_vbo =
250 ((_arrays == VERTEX_ARRAY || _arrays == (VERTEX_ARRAY | NORMAL_ARRAY)) &&
251 (vertexBufferInitialized_ && normalBufferInitialized_) ) ;
252 // omlog() << "Use VBO: " << use_vbo << std::endl;
253
254
255
256 // unbind VBO buffers
257 if (!use_vbo && vertex_buffer_)
258 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
259
260
261
262 if (_arrays & VERTEX_ARRAY)
263 {
264 if (!(enabled_arrays_ & VERTEX_ARRAY))
265 {
266 enabled_arrays_ |= VERTEX_ARRAY;
267 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
268
269 if (use_vbo )
270 {
271 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buffer_);
272
273 // As we ensure that buffers are converted to float before using them, use Float here
274 ACG::GLState::vertexPointer(3, GL_FLOAT, 0, 0);
275 }
276 else
277 {
278 ACG::GLState::vertexPointer(mesh_.points());
279 }
280 }
281 }
282 else if (enabled_arrays_ & VERTEX_ARRAY)
283 {
284 enabled_arrays_ &= ~VERTEX_ARRAY;
285 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
286 }
287
288
289 if (_arrays & NORMAL_ARRAY)
290 {
291 if (!(enabled_arrays_ & NORMAL_ARRAY))
292 {
293 enabled_arrays_ |= NORMAL_ARRAY;
294 ACG::GLState::enableClientState(GL_NORMAL_ARRAY);
295
296 if (use_vbo)
297 {
298 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer_);
299
300 // As we ensure that buffers are converted to float before using them, use Float here
301 ACG::GLState::normalPointer(GL_FLOAT, 0 , 0);
302 }
303 else
304 {
305 ACG::GLState::normalPointer(mesh_.vertex_normals());
306 }
307 }
308 }
309 else if (enabled_arrays_ & NORMAL_ARRAY)
310 {
311 enabled_arrays_ &= ~NORMAL_ARRAY;
312 ACG::GLState::disableClientState(GL_NORMAL_ARRAY);
313 }
314
315
316 if (_arrays & COLOR_ARRAY)
317 {
318 if (!(enabled_arrays_ & COLOR_ARRAY))
319 {
320 enabled_arrays_ |= COLOR_ARRAY;
321 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
322 ACG::GLState::colorPointer(mesh_.vertex_colors());
323 }
324 }
325 else if (enabled_arrays_ & COLOR_ARRAY)
326 {
327 enabled_arrays_ &= ~COLOR_ARRAY;
328 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
329 }
330
331
332 if (_arrays & TEXTURE_COORD_1D_ARRAY)
333 {
334 if (!(enabled_arrays_ & TEXTURE_COORD_1D_ARRAY))
335 {
336 enabled_arrays_ |= TEXTURE_COORD_1D_ARRAY;
337 ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
338 ACG::GLState::texcoordPointer(mesh_.texcoords1D());
339 }
340 }
341 else if (enabled_arrays_ & TEXTURE_COORD_1D_ARRAY)
342 {
343 enabled_arrays_ &= ~TEXTURE_COORD_1D_ARRAY;
344 ACG::GLState::disableClientState(GL_TEXTURE_COORD_ARRAY);
345 }
346
347
348 if (_arrays & TEXTURE_COORD_2D_ARRAY)
349 {
350 if (!(enabled_arrays_ & TEXTURE_COORD_2D_ARRAY))
351 {
352 enabled_arrays_ |= TEXTURE_COORD_2D_ARRAY;
353 ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
354 ACG::GLState::texcoordPointer(mesh_.texcoords2D());
355 }
356 }
357 else if (enabled_arrays_ & TEXTURE_COORD_2D_ARRAY)
358 {
359 enabled_arrays_ &= ~TEXTURE_COORD_2D_ARRAY;
360 ACG::GLState::disableClientState(GL_TEXTURE_COORD_ARRAY);
361 }
362
363
364 if (_arrays & TEXTURE_COORD_3D_ARRAY)
365 {
366 if (!(enabled_arrays_ & TEXTURE_COORD_3D_ARRAY))
367 {
368 enabled_arrays_ |= TEXTURE_COORD_3D_ARRAY;
369 ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
370 ACG::GLState::texcoordPointer(mesh_.texcoords3D());
371 }
372 }
373 else if (enabled_arrays_ & TEXTURE_COORD_3D_ARRAY)
374 {
375 enabled_arrays_ &= ~TEXTURE_COORD_3D_ARRAY;
376 ACG::GLState::disableClientState(GL_TEXTURE_COORD_ARRAY);
377 }
378
379
380 glCheckErrors();
381 }
382
383
384 //----------------------------------------------------------------------------
385
386
387 template<class Mesh>
388 void
389 MeshNodeDeprecatedT<Mesh>::
390 update_geometry()
391 {
392 updateFaceList_ = true;
393 updateVertexList_ = true;
394 updateEdgeList_ = true;
395 updateAnyList_ = true;
396
397 bbMin_ = Vec3d(FLT_MAX, FLT_MAX, FLT_MAX);
398 bbMax_ = Vec3d(-FLT_MAX, -FLT_MAX, -FLT_MAX);
399 typename Mesh::ConstVertexIter v_it(mesh_.vertices_begin()),
400 v_end(mesh_.vertices_end());
401
402 for (; v_it!=v_end; ++v_it)
403 {
404 bbMin_.minimize(mesh_.point(*v_it));
405 bbMax_.maximize(mesh_.point(*v_it));
406 }
407
408 typedef typename Mesh::Point Point;
409 typedef typename Point::value_type PointScalar;
410 typedef typename Mesh::Normal Normal;
411 typedef typename Normal::value_type NormalScalar;
412
413 //===================================================================
414 // Generate a vertex buffer on the GPU
415 //===================================================================
416
417 if (!vertex_buffer_) glGenBuffers(1, (GLuint*) &vertex_buffer_);
418
419 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buffer_);
420 vertexBufferInitialized_ = false;
421
422 //Check if using floats otherwise convert to internal float array
423 if ( sizeof(PointScalar) == 4 ) {
424
425 glBufferData(GL_ARRAY_BUFFER_ARB,
426 3 * mesh_.n_vertices() * sizeof(PointScalar),
427 mesh_.points(),
428 GL_STATIC_DRAW_ARB);
429
430 vertexBufferInitialized_ = true;
431
432 } else {
433
434 vertices_.clear();
435 typename Mesh::ConstVertexIter v_it(mesh_.vertices_begin()),
436 v_end(mesh_.vertices_end());
437
438 for ( ; v_it != v_end ; ++v_it )
439 vertices_.push_back( ACG::Vec3f(mesh_.point(*v_it)) );
440
441 if ( !vertices_.empty() ) {
442
443 glBufferData(GL_ARRAY_BUFFER_ARB,
444 3 * mesh_.n_vertices() * sizeof(float),
445 &vertices_[0],
446 GL_STATIC_DRAW_ARB);
447 vertexBufferInitialized_ = true;
448
449 }
450 }
451
452 //===================================================================
453 // Generate a normal buffer on the GPU
454 //===================================================================
455
456 if (!normal_buffer_) glGenBuffers(1, (GLuint*) &normal_buffer_);
457 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer_);
458 normalBufferInitialized_ = false;
459
460 // Check if using floats otherwise convert to internal float array
461 if ( sizeof(NormalScalar) == 4) {
462
463 glBufferData(GL_ARRAY_BUFFER_ARB,
464 3 * mesh_.n_vertices() * sizeof(NormalScalar),
465 mesh_.vertex_normals(),
466 GL_STATIC_DRAW_ARB);
467
468 normalBufferInitialized_ = true;
469
470 } else {
471 normals_.clear();
472 typename Mesh::ConstVertexIter v_it(mesh_.vertices_begin()),
473 v_end(mesh_.vertices_end());
474
475 for ( ; v_it != v_end ; ++v_it )
476 normals_.push_back( ACG::Vec3f(mesh_.normal(*v_it)) );
477
478 if ( !normals_.empty() ) {
479
480 glBufferData(GL_ARRAY_BUFFER_ARB,
481 3 * mesh_.n_vertices() * sizeof(float),
482 &normals_[0],
483 GL_STATIC_DRAW_ARB);
484 normalBufferInitialized_ = true;
485 }
486
487 }
488
489 // unbind buffers
490 ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
491
492 } else omlog() << "MeshNodeDeprecatedT: VBO not supported on this machine\n";
493 }
494
495
496 //----------------------------------------------------------------------------
497
498
499 template<class Mesh>
500 void
501 MeshNodeDeprecatedT<Mesh>::
502 update_topology()
503 {
504 updateFaceList_ = true;
505 updateVertexList_ = true;
506
507 if (mesh_.is_trimesh())
508 {
509 typename Mesh::ConstFaceIter f_it(mesh_.faces_sbegin()),
510 f_end(mesh_.faces_end());
511 typename Mesh::ConstFaceVertexIter fv_it;
512
513 try
514 {
515 indices_.clear();
516 std::vector<unsigned int>().swap(indices_);
517 indices_.reserve(mesh_.n_faces()*3);
518
519 for (; f_it!=f_end; ++f_it)
520 {
521 fv_it = mesh_.cfv_iter( *f_it );
522 indices_.push_back(fv_it->idx()); ++fv_it;
523 indices_.push_back(fv_it->idx()); ++fv_it;
524 indices_.push_back(fv_it->idx());
525 }
526 }
527 catch (...)
528 {
529 indices_.clear();
530 std::vector<unsigned int>().swap(indices_);
531 omerr() << "Topology caching failed\n";
532 }
533
534 //===================================================================
535 // Generate an index buffer on the GPU
536 //===================================================================
537 faceIndexBufferInitialized_ = false;
538
539 if ( !indices_.empty() ) {
540
541 // generate buffer
542 if (!face_index_buffer_) glGenBuffers(1, (GLuint*) &face_index_buffer_);
543
544 // index buffer
545 ACG::GLState::bindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, face_index_buffer_);
546
547 glBufferData(GL_ELEMENT_ARRAY_BUFFER_ARB,
548 indices_.size() * sizeof(unsigned int),
549 &indices_[0],
550 GL_STATIC_DRAW_ARB);
551
552 faceIndexBufferInitialized_ = true;
553
554 // unbind buffer
555 ACG::GLState::bindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
556
557 }
558
559 }
560
561 }
562
563
564 //----------------------------------------------------------------------------
565
566
567 template<class Mesh>
568 void
569 MeshNodeDeprecatedT<Mesh>::
570 draw(GLState& _state, const DrawModes::DrawMode& _drawMode)
571 {
572 GLenum prev_depth = _state.depthFunc();
573
574 if (_drawMode & DrawModes::POINTS)
575 {
576 enable_arrays(VERTEX_ARRAY);
577 ACG::GLState::disable(GL_LIGHTING);
578 ACG::GLState::shadeModel(GL_FLAT);
579 draw_vertices();
580 }
581
582
583 if ( ( _drawMode & DrawModes::POINTS_COLORED ) && mesh_.has_vertex_colors())
584 {
585 enable_arrays(VERTEX_ARRAY | COLOR_ARRAY);
586 ACG::GLState::disable(GL_LIGHTING);
587 ACG::GLState::shadeModel(GL_FLAT);
588 draw_vertices();
589 }
590
591
592 if ( ( _drawMode & DrawModes::POINTS_SHADED ) && mesh_.has_vertex_normals())
593 {
594 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY);
595 ACG::GLState::enable(GL_LIGHTING);
596 ACG::GLState::shadeModel(GL_FLAT);
597 draw_vertices();
598 }
599
600
601 if (_drawMode & DrawModes::WIREFRAME)
602 {
603 glPushAttrib(GL_ENABLE_BIT);
604
605 ACG::GLState::disable( GL_CULL_FACE );
606
607 enable_arrays(VERTEX_ARRAY);
608 ACG::GLState::disable(GL_LIGHTING);
609 ACG::GLState::shadeModel(GL_FLAT);
610 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
611 draw_faces(PER_VERTEX);
612 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
613
614 glPopAttrib();
615 }
616
617
618 if (_drawMode & DrawModes::HIDDENLINE)
619 {
620 enable_arrays(VERTEX_ARRAY);
621
622 Vec4f clear_color = _state.clear_color();
623 Vec4f base_color = _state.base_color();
624 clear_color[3] = 1.0;
625
626 ACG::GLState::disable(GL_LIGHTING);
627 ACG::GLState::shadeModel(GL_FLAT);
628 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
629 _state.set_base_color(clear_color);
630
631 ACG::GLState::depthRange(0.01, 1.0);
632 draw_faces(PER_VERTEX);
633 ACG::GLState::depthRange(0.0, 1.0);
634
635 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
636 ACG::GLState::depthFunc(GL_LEQUAL);
637 _state.set_base_color(base_color);
638 draw_faces(PER_VERTEX);
639 ACG::GLState::depthFunc(prev_depth);
640 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
641 }
642
643
644 if ( ( _drawMode & DrawModes::SOLID_FLAT_SHADED ) && mesh_.has_face_normals())
645 {
646 ACG::GLState::enable(GL_LIGHTING);
647 ACG::GLState::shadeModel(GL_FLAT);
648 ACG::GLState::depthRange(0.01, 1.0);
649 draw_faces(FACE_NORMALS);
650 ACG::GLState::depthRange(0.0, 1.0);
651 }
652
653
654 if ( ( _drawMode & DrawModes::SOLID_SMOOTH_SHADED ) && mesh_.has_vertex_normals())
655 {
656 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY);
657 ACG::GLState::enable(GL_LIGHTING);
658 ACG::GLState::shadeModel(GL_SMOOTH);
659 ACG::GLState::depthRange(0.01, 1.0);
660 draw_faces(PER_VERTEX);
661 ACG::GLState::depthRange(0.0, 1.0);
662 }
663
664 if ( ( _drawMode & DrawModes::SOLID_PHONG_SHADED ) && mesh_.has_vertex_normals() )
665 {
666 // if ( parent() != 0 ) {
667 // if ( parent()->className() == "ShaderNode" ) {
668 //
669 // ShaderNode* node = dynamic_cast< ShaderNode* > ( parent() );
670 //
671 // GLSL::PtrProgram program = node->getShader( DrawModes::SOLID_PHONG_SHADED );
672 //
673 // // Enable own Phong shader
674 // program->use();
675
676 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY);
677 ACG::GLState::enable(GL_LIGHTING);
678 ACG::GLState::shadeModel(GL_SMOOTH);
679 ACG::GLState::depthRange(0.01, 1.0);
680 draw_faces(PER_VERTEX);
681 ACG::GLState::depthRange(0.0, 1.0);
682
683 //disable own Phong shader
684 // program->disable();
685 // }
686 // }
687 }
688
689 if ( ( _drawMode & DrawModes::SOLID_ENV_MAPPED ) && mesh_.has_vertex_normals())
690 {
691 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY);
692 ACG::GLState::enable(GL_LIGHTING);
693 ACG::GLState::shadeModel(GL_SMOOTH);
694 ACG::GLState::depthRange(0.01, 1.0);
695 draw_faces(PER_VERTEX);
696 ACG::GLState::depthRange(0.0, 1.0);
697 }
698
699
700 if ( ( _drawMode & DrawModes::SOLID_FACES_COLORED )&& mesh_.has_face_colors())
701 {
702 Vec4f base_color_backup = _state.base_color();
703
704 ACG::GLState::disable(GL_LIGHTING);
705 ACG::GLState::shadeModel(GL_FLAT);
706 ACG::GLState::depthRange(0.01, 1.0);
707 draw_faces(FACE_COLORS);
708 ACG::GLState::depthRange(0.0, 1.0);
709
710 _state.set_base_color(base_color_backup);
711 }
712
713
714 if ( ( _drawMode & DrawModes::SOLID_FACES_COLORED_FLAT_SHADED ) && mesh_.has_face_colors() && mesh_.has_face_normals())
715 {
716 Vec4f base_color_backup = _state.base_color();
717 ACG::GLState::enable(GL_LIGHTING);
718
719 ACG::GLState::shadeModel(GL_FLAT);
720 ACG::GLState::depthRange(0.01, 1.0);
721 draw_faces(FACE_NORMALS_COLORS);
722 ACG::GLState::depthRange(0.0, 1.0);
723
724 _state.set_base_color(base_color_backup);
725 }
726
727
728 if ( ( _drawMode & DrawModes::SOLID_POINTS_COLORED ) && mesh_.has_vertex_colors())
729 {
730 Vec4f base_color_backup = _state.base_color();
731
732 enable_arrays(VERTEX_ARRAY | COLOR_ARRAY);
733 ACG::GLState::disable(GL_LIGHTING);
734 ACG::GLState::shadeModel(GL_SMOOTH);
735 ACG::GLState::depthRange(0.01, 1.0);
736 draw_faces(PER_VERTEX);
737 ACG::GLState::depthRange(0.0, 1.0);
738
739 _state.set_base_color(base_color_backup);
740 }
741
742
743 if ( ( _drawMode & DrawModes::SOLID_TEXTURED ) && mesh_.has_vertex_texcoords2D())
744 {
745 enable_arrays(VERTEX_ARRAY | TEXTURE_COORD_2D_ARRAY);
746 ACG::GLState::enable(GL_TEXTURE_2D);
747 ACG::GLState::disable(GL_LIGHTING);
748 ACG::GLState::shadeModel(GL_FLAT);
749 ACG::GLState::depthRange(0.01, 1.0);
750 draw_faces(PER_VERTEX);
751 ACG::GLState::depthRange(0.0, 1.0);
752 ACG::GLState::disable(GL_TEXTURE_2D);
753 }
754
755
756 if ( ( _drawMode & DrawModes::SOLID_TEXTURED_SHADED ) && mesh_.has_vertex_texcoords2D() && mesh_.has_vertex_normals())
757 {
758 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY | TEXTURE_COORD_2D_ARRAY);
759 ACG::GLState::enable(GL_TEXTURE_2D);
760 ACG::GLState::enable(GL_LIGHTING);
761 ACG::GLState::shadeModel(GL_SMOOTH);
762 ACG::GLState::depthRange(0.01, 1.0);
763 draw_faces(PER_VERTEX);
764 ACG::GLState::depthRange(0.0, 1.0);
765 ACG::GLState::disable(GL_TEXTURE_2D);
766 }
767
768
769 if ( ( _drawMode & DrawModes::SOLID_1DTEXTURED ) && mesh_.has_vertex_texcoords1D())
770 {
771 enable_arrays(VERTEX_ARRAY | TEXTURE_COORD_1D_ARRAY);
772 ACG::GLState::enable(GL_TEXTURE_1D);
773 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
774 ACG::GLState::disable(GL_LIGHTING);
775 ACG::GLState::shadeModel(GL_SMOOTH);
776 ACG::GLState::depthRange(0.01, 1.0);
777 draw_faces(PER_VERTEX);
778 ACG::GLState::depthRange(0.0, 1.0);
779 ACG::GLState::disable(GL_TEXTURE_1D);
780 }
781
782
783 if ( ( _drawMode & DrawModes::SOLID_1DTEXTURED_SHADED ) && mesh_.has_vertex_texcoords1D() && mesh_.has_vertex_normals())
784 {
785 // store and change colors
786 const Vec4f ambient = _state.ambient_color();
787 const Vec4f diffuse = _state.diffuse_color();
788 const Vec4f specular = _state.specular_color();
789 _state.set_ambient_color (Vec4f(0.1, 0.1, 0.1, 1.0));
790 _state.set_diffuse_color (Vec4f(0.8, 0.8, 0.8, 1.0));
791 _state.set_specular_color (Vec4f(1.0, 1.0, 1.0, 1.0));
792
793 // store and change texture mode
794 GLint texmode;
795 glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texmode);
796 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
797
798 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY | TEXTURE_COORD_1D_ARRAY);
799 ACG::GLState::enable(GL_TEXTURE_1D);
800 ACG::GLState::enable(GL_LIGHTING);
801 ACG::GLState::shadeModel(GL_SMOOTH);
802 ACG::GLState::depthRange(0.01, 1.0);
803 draw_faces(PER_VERTEX);
804 ACG::GLState::depthRange(0.0, 1.0);
805 ACG::GLState::disable(GL_TEXTURE_1D);
806
807 // restore colors
808 _state.set_ambient_color(ambient);
809 _state.set_diffuse_color(diffuse);
810 _state.set_specular_color(specular);
811
812 // restore texture mode
813 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texmode);
814 }
815
816
817
818 if ( ( _drawMode & DrawModes::SOLID_3DTEXTURED ) && mesh_.has_vertex_texcoords3D())
819 {
820 enable_arrays(VERTEX_ARRAY | TEXTURE_COORD_3D_ARRAY);
821 ACG::GLState::enable(GL_TEXTURE_3D);
822 ACG::GLState::disable(GL_LIGHTING);
823 ACG::GLState::shadeModel(GL_FLAT);
824 ACG::GLState::depthRange(0.01, 1.0);
825 draw_faces(PER_VERTEX);
826 ACG::GLState::depthRange(0.0, 1.0);
827 ACG::GLState::disable(GL_TEXTURE_3D);
828 }
829
830
831 if ( ( _drawMode & DrawModes::SOLID_3DTEXTURED_SHADED ) && mesh_.has_vertex_texcoords3D() && mesh_.has_vertex_normals())
832 {
833 enable_arrays(VERTEX_ARRAY | NORMAL_ARRAY | TEXTURE_COORD_3D_ARRAY);
834 ACG::GLState::enable(GL_TEXTURE_3D);
835 ACG::GLState::enable(GL_LIGHTING);
836 ACG::GLState::shadeModel(GL_SMOOTH);
837 ACG::GLState::depthRange(0.01, 1.0);
838 draw_faces(PER_VERTEX);
839 ACG::GLState::depthRange(0.0, 1.0);
840 ACG::GLState::disable(GL_TEXTURE_3D);
841 }
842
843 // Textured by using coordinates stored in halfedges
844 // TODO: Check not only mesh_.has_halfedge_texcoords2D but check if custom property is available
845 if ( ( _drawMode & DrawModes::SOLID_2DTEXTURED_FACE ) && mesh_.has_halfedge_texcoords2D())
846 {
847 ACG::GLState::enable(GL_TEXTURE_2D);
848 ACG::GLState::disable(GL_LIGHTING);
849 ACG::GLState::shadeModel(GL_FLAT);
850 ACG::GLState::depthRange(0.01, 1.0);
851 draw_faces(FACE_HALFEDGE_TEXTURED);
852 ACG::GLState::depthRange(0.0, 1.0);
853 ACG::GLState::disable(GL_TEXTURE_2D);
854 }
855
856 // Textured by using coordinates stored in halfedges
857 // TODO: Check not only mesh_.has_halfedge_texcoords2D but check if custom property is available
858 if ( ( _drawMode & DrawModes::SOLID_2DTEXTURED_FACE_SHADED ) && mesh_.has_halfedge_texcoords2D() && mesh_.has_face_normals())
859 {
860 ACG::GLState::enable(GL_TEXTURE_2D);
861 ACG::GLState::enable(GL_LIGHTING);
862
863 ACG::GLState::shadeModel(GL_FLAT);
864 ACG::GLState::depthRange(0.01, 1.0);
865 draw_faces(FACE_HALFEDGE_TEXTURED);
866 ACG::GLState::depthRange(0.0, 1.0);
867 ACG::GLState::disable(GL_TEXTURE_2D);
868
869 }
870
871 // If in shader mode, just draw, as the shader has to be set by a shadernode above this node
872 if ( (_drawMode & DrawModes::SOLID_SHADER ) ) {
873
874 if ( mesh_.has_face_normals() )
875 enable_arrays( VERTEX_ARRAY | NORMAL_ARRAY);
876 else
877 enable_arrays( VERTEX_ARRAY );
878
879 ACG::GLState::enable(GL_LIGHTING);
880 ACG::GLState::shadeModel(GL_SMOOTH);
881 ACG::GLState::depthRange(0.01, 1.0);
882 draw_faces(PER_VERTEX);
883 ACG::GLState::depthRange(0.0, 1.0);
884 }
885
886
887 enable_arrays(0);
888 }
889
890
891 //----------------------------------------------------------------------------
892
893
894 template<class Mesh>
895 void
896 MeshNodeDeprecatedT<Mesh>::
897 draw_vertices()
898 {
899 glDrawArrays(GL_POINTS, 0, mesh_.n_vertices());
900 }
901
902
903 //----------------------------------------------------------------------------
904
905
906 template<class Mesh>
907 void
908 MeshNodeDeprecatedT<Mesh>::
909 draw_faces(FaceMode _mode)
910 {
911 typename Mesh::ConstFaceIter f_it(mesh_.faces_sbegin()),
912 f_end(mesh_.faces_end());
913 typename Mesh::ConstFaceVertexIter fv_it;
914 typename Mesh::ConstFaceHalfedgeIter fh_it;
915
916 switch (_mode)
917 {
918 case FACE_NORMALS:
919 {
920 if (mesh_.is_trimesh())
921 {
922 glBegin(GL_TRIANGLES);
923 for (; f_it!=f_end; ++f_it)
924 {
925 glNormal(mesh_.normal(*f_it));
926
927 fv_it=mesh_.cfv_iter(*f_it);
928 glVertex(mesh_.point(*fv_it)); ++fv_it;
929 glVertex(mesh_.point(*fv_it)); ++fv_it;
930 glVertex(mesh_.point(*fv_it));
931 }
932 glEnd();
933 }
934 else
935 {
936 for (; f_it!=f_end; ++f_it)
937 {
938 glBegin(GL_POLYGON);
939 glNormal(mesh_.normal(*f_it));
940 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
941 glVertex(mesh_.point(*fv_it));
942 glEnd();
943 }
944 }
945 break;
946 }
947
948
949 case FACE_COLORS:
950 {
951 if (mesh_.is_trimesh())
952 {
953 glBegin(GL_TRIANGLES);
954 for (; f_it!=f_end; ++f_it)
955 {
956 glColor(mesh_.color(*f_it));
957
958 fv_it=mesh_.cfv_iter(*f_it);
959 glVertex(mesh_.point(*fv_it)); ++fv_it;
960 glVertex(mesh_.point(*fv_it)); ++fv_it;
961 glVertex(mesh_.point(*fv_it));
962 }
963 glEnd();
964 }
965 else
966 {
967 for (; f_it!=f_end; ++f_it)
968 {
969 glBegin(GL_POLYGON);
970 glColor(mesh_.color(*f_it));
971 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
972 glVertex(mesh_.point(*fv_it));
973 glEnd();
974 }
975 }
976 break;
977 }
978
979
980 case FACE_NORMALS_COLORS:
981 {
982 if (mesh_.is_trimesh())
983 {
984 glBegin(GL_TRIANGLES);
985 for (; f_it!=f_end; ++f_it)
986 {
987 glColor(mesh_.color(*f_it));
988 glNormal(mesh_.normal(*f_it));
989
990 fv_it=mesh_.cfv_iter(*f_it);
991 glVertex(mesh_.point(*fv_it)); ++fv_it;
992 glVertex(mesh_.point(*fv_it)); ++fv_it;
993 glVertex(mesh_.point(*fv_it));
994 }
995 glEnd();
996 }
997 else
998 {
999 for (; f_it!=f_end; ++f_it)
1000 {
1001 glBegin(GL_POLYGON);
1002 glColor(mesh_.color(*f_it));
1003 glNormal(mesh_.normal(*f_it));
1004 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
1005 glVertex(mesh_.point(*fv_it));
1006 glEnd();
1007 }
1008 }
1009 break;
1010 }
1011
1012
1013 // propertyMap_ maps between an int index stored in the Mesh describing which texture to use
1014 // and a property name giving 2D Texture coordinates for halfedges ( texcoords for to vertex )
1015
1016 case FACE_HALFEDGE_TEXTURED:
1017 {
1018 if (mesh_.is_trimesh())
1019 {
1020
1021 OpenMesh::FPropHandleT< int > texture_index_property;
1022 if ( !mesh_.get_property_handle(texture_index_property,indexPropertyName_) ) {
1023 if( indexPropertyName_ != "No Texture Index")
1024 std::cerr << "Unable to get per face texture Index property named " << indexPropertyName_ << std::endl;
1025 if ( !mesh_.get_property_handle(texture_index_property,"f:textureindex") ) {
1026 std::cerr << "Unable to get standard per face texture Index property" << std::endl;
1027 texture_index_property.reset();
1028 }
1029 }
1030
1031 // textureMap_ maps between an int index stored in the Mesh describing which texture to use
1032 // and the GluInt bound by the TextureNode. If such a map is not available, assume TextureNode
1033 // has already bound a texture and we use only one texture.
1034 // Additionally if we do not have an texture index property, we do not know which textures
1035 // should be used .. therefore do not switch textures if this property is missing.
1036 if ( !textureMap_ || !texture_index_property.is_valid() ) {
1037
1038 // Get texture coords property
1039 OpenMesh::HPropHandleT< typename Mesh::TexCoord2D > texture_coord_property;
1040 if ( !mesh_.get_property_handle(texture_coord_property,default_halfedge_textcoord_property_) ) {
1041 std::cerr << "Error: Unable to get per face texture coordinate property named "
1042 << default_halfedge_textcoord_property_ << std::endl;
1043 std::cerr << "Unable to texture without texture coordinates" << std::endl;
1044 return;
1045 }
1046
1047 typename Mesh::Point point;
1048 typename Mesh::TexCoord2D tex2d;
1049 glBegin(GL_TRIANGLES);
1050 for (; f_it!=f_end; ++f_it) {
1051 glNormal(mesh_.normal(*f_it));
1052 for (fh_it = mesh_.cfh_iter(*f_it);fh_it.is_valid();++fh_it)
1053 {
1054 point = mesh_.point(mesh_.to_vertex_handle(*fh_it));
1055 tex2d = mesh_.property(texture_coord_property,*fh_it);
1056 glTexCoord2f(tex2d[0], tex2d[1]);
1057 glVertex(point);
1058 }
1059 }
1060 glEnd();
1061 } else {
1062
1063 OpenMesh::HPropHandleT< typename Mesh::TexCoord2D > texture_coord_property;
1064 int last_texture = -1;
1065
1066 typename Mesh::Point point;
1067 typename Mesh::TexCoord2D tex2d;
1068
1069 for (; f_it!=f_end; ++f_it)
1070 {
1071 int texture = mesh_.property(texture_index_property,*f_it);
1072
1073 if (texture == -1)
1074 continue;
1075
1076 if ( last_texture != texture ) {
1077
1078 if ( textureMap_->find(texture) == textureMap_->end() ) {
1079 std::cerr << "Illegal texture index ... trying to access " << texture << std::endl;
1080 last_texture = -1;
1081 continue;
1082 }
1083
1084 // Get texture coords property
1085 if ( !propertyMap_ || !mesh_.get_property_handle(texture_coord_property,(*propertyMap_)[texture]) ) {
1086 if ( propertyMap_)
1087 std::cerr << "Error: Unable to get per face texture coordinate property named "
1088 << (*propertyMap_)[texture] << std::endl;
1089 if ( !mesh_.get_property_handle(texture_coord_property,"h:texcoords2D") ) {
1090 std::cerr << "Fallback: Unable to get standard Property for per halfedge texcoords" << std::endl;
1091 std::cerr << "Unable to texture face without texture coordinates" << std::endl;
1092 last_texture = -1;
1093 continue;
1094 }
1095 }
1096
1097 ACG::GLState::bindTexture( GL_TEXTURE_2D, (*textureMap_)[texture] );
1098
1099 // Remember active texture to skip extra switches
1100 last_texture = texture;
1101
1102 }
1103
1104 glBegin(GL_TRIANGLES);
1105
1106 glNormal(mesh_.normal(*f_it));
1107 glColor(mesh_.color(*f_it));
1108
1109 for (fh_it = mesh_.cfh_iter(*f_it);fh_it.is_valid();++fh_it)
1110 {
1111 point = mesh_.point(mesh_.to_vertex_handle(*fh_it));
1112 tex2d = mesh_.property(texture_coord_property,*fh_it);
1113 glTexCoord2f(tex2d[0], tex2d[1]);
1114 glVertex(point);
1115 }
1116
1117 glEnd();
1118
1119 }
1120 }
1121 }
1122 else
1123 {
1124 // NOT IMPLEMENTED
1125 }
1126 break;
1127 }
1128
1129
1130 case PER_VERTEX:
1131 {
1132 if (mesh_.is_trimesh())
1133 {
1134 // try cached triangle indices
1135 if (!indices_.empty())
1136 {
1137
1138 // If we have an index buffer on the GPU, use it
1139 if ( faceIndexBufferInitialized_ ) {
1140
1141 // As we have a list of all faces on the GPU bind it
1142 ACG::GLState::bindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,face_index_buffer_);
1143
1144 // Draw it
1145 glDrawElements(GL_TRIANGLES,
1146 indices_.size(),
1147 GL_UNSIGNED_INT,
1148 0);
1149
1150 // And unbind it again
1151 ACG::GLState::bindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);
1152
1153 } else {
1154
1155 glDrawElements(GL_TRIANGLES,
1156 indices_.size(),
1157 GL_UNSIGNED_INT,
1158 &indices_[0]);
1159 }
1160
1161
1162 }
1163
1164 // otherwise use immediate mode
1165 else
1166 {
1167 glBegin(GL_TRIANGLES);
1168 for (; f_it!=f_end; ++f_it)
1169 {
1170
1171 fv_it=mesh_.cfv_iter(*f_it);
1172 glArrayElement(fv_it->idx()); ++fv_it;
1173 glArrayElement(fv_it->idx()); ++fv_it;
1174 glArrayElement(fv_it->idx());
1175 }
1176 glEnd();
1177 }
1178 }
1179 else
1180 {
1181 for (; f_it!=f_end; ++f_it)
1182 {
1183 glBegin(GL_POLYGON);
1184 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
1185 glArrayElement(fv_it->idx());
1186 glEnd();
1187 }
1188 }
1189 break;
1190 }
1191 }
1192 }
1193
1194
1195 //----------------------------------------------------------------------------
1196
1197
1198 template<class Mesh>
1199 void
1200 MeshNodeDeprecatedT<Mesh>::
1201 pick(GLState& _state, PickTarget _target)
1202 {
1203 switch (_target)
1204 {
1205 case PICK_VERTEX:
1206 {
1207 pick_vertices(_state);
1208 break;
1209 }
1210 case PICK_FRONT_VERTEX:
1211 {
1212 pick_vertices(_state, true);
1213 break;
1214 }
1215
1216 case PICK_ANYTHING:
1217 {
1218 pick_any(_state);
1219 break;
1220 }
1221 case PICK_FACE:
1222 {
1223 pick_faces(_state);
1224 break;
1225 }
1226
1227 case PICK_EDGE:
1228 {
1229 pick_edges(_state);
1230 break;
1231 }
1232
1233 case PICK_FRONT_EDGE:
1234 {
1235 pick_edges(_state, true);
1236 break;
1237 }
1238
1239 default:
1240 break;
1241 }
1242 }
1243
1244
1245 //----------------------------------------------------------------------------
1246
1247
1248 template<class Mesh>
1249 void
1250 MeshNodeDeprecatedT<Mesh>::
1251 pick_vertices(GLState& _state, bool _front)
1252 {
1253 GLenum prev_depth = _state.depthFunc();
1254
1255 typename Mesh::ConstVertexIter v_it(mesh_.vertices_begin()),
1256 v_end(mesh_.vertices_end());
1257 GLuint idx(0);
1258
1259 if (!_state.pick_set_maximum (mesh_.n_vertices()))
1260 {
1261 omerr() << "MeshNode::pick_vertices: color range too small, "
1262 << "picking failed\n";
1263 return;
1264 }
1265
1266 if (_front)
1267 {
1268 enable_arrays(VERTEX_ARRAY);
1269
1270 Vec4f clear_color = _state.clear_color();
1271 Vec4f base_color = _state.base_color();
1272 clear_color[3] = 1.0;
1273
1274 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1275 _state.set_base_color(clear_color);
1276
1277 ACG::GLState::depthRange(0.01, 1.0);
1278 draw_faces(PER_VERTEX);
1279 ACG::GLState::depthRange(0.0, 1.0);
1280
1281 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1282 ACG::GLState::depthFunc(GL_LEQUAL);
1283 _state.set_base_color(base_color);
1284
1285 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1286
1287 enable_arrays(0);
1288 }
1289
1290
1291 if (vertexList_ && !updateVertexList_ && _state.pick_current_index () == vertexBaseIndex_)
1292 {
1293 glCallList (vertexList_);
1294 ACG::GLState::depthFunc(prev_depth);
1295 return;
1296 }
1297
1298 if (vertexList_)
1299 {
1300 glNewList (vertexList_, GL_COMPILE);
1301 updateVertexList_ = false;
1302 vertexBaseIndex_ = _state.pick_current_index ();
1303 }
1304
1305 if (_state.color_picking ())
1306 {
1307 update_pick_buffers ();
1308
1309 for (; v_it!=v_end; ++v_it, ++idx)
1310 {
1311 pickColorBuf_[idx] = _state.pick_get_name_color (idx);
1312 pickVertexBuf_[idx] = mesh_.point(*v_it);
1313 }
1314
1315 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
1316 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
1317
1318 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1319 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1320
1321 glDrawArrays(GL_POINTS, 0, mesh_.n_vertices());
1322
1323 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
1324 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
1325 }
1326 else
1327 {
1328 for (; v_it!=v_end; ++v_it, ++idx)
1329 {
1330 _state.pick_set_name (idx);
1331 glBegin(GL_POINTS);
1332 glVertex(mesh_.point(*v_it));
1333 glEnd();
1334 }
1335 }
1336
1337 if (vertexList_)
1338 {
1339 glEndList ();
1340 glCallList (vertexList_);
1341 }
1342
1343 ACG::GLState::depthFunc(prev_depth);
1344 }
1345
1346
1347 //----------------------------------------------------------------------------
1348
1349
1350 template<class Mesh>
1351 void
1352 MeshNodeDeprecatedT<Mesh>::
1353 pick_faces(GLState& _state)
1354 {
1355 typename Mesh::ConstFaceIter f_it(mesh_.faces_sbegin()),
1356 f_end(mesh_.faces_end());
1357 typename Mesh::ConstFaceVertexIter fv_it;
1358
1359
1360 if ( mesh_.n_faces() > 0 )
1361 {
1362 if (!_state.pick_set_maximum (mesh_.n_faces()))
1363 {
1364 omerr() << "MeshNode::pick_faces: color range too small, "
1365 << "picking failed\n";
1366 return;
1367 }
1368 }
1369 else
1370 {
1371 if (!_state.pick_set_maximum (1))
1372 {
1373 omerr() << "Strange pickSetMAximum failed for index 1 in MeshNode\n";
1374 return;
1375 }
1376 }
1377
1378 if (faceList_ && !updateFaceList_ && _state.pick_current_index () == faceBaseIndex_)
1379 {
1380 glCallList (faceList_);
1381 return;
1382 }
1383
1384 if (faceList_)
1385 {
1386 glNewList (faceList_, GL_COMPILE);
1387 updateFaceList_ = false;
1388 faceBaseIndex_ = _state.pick_current_index ();
1389 }
1390
1391 if (_state.color_picking ())
1392 {
1393 update_pick_buffers ();
1394 unsigned int idx = 0;
1395
1396 if (mesh_.is_trimesh())
1397 {
1398 for (; f_it!=f_end; ++f_it)
1399 {
1400 pickColorBuf_[idx] = _state.pick_get_name_color (f_it->idx());
1401 pickColorBuf_[idx+1] = _state.pick_get_name_color (f_it->idx());
1402 pickColorBuf_[idx+2] = _state.pick_get_name_color (f_it->idx());
1403
1404 fv_it=mesh_.cfv_iter(*f_it);
1405 pickVertexBuf_[idx] = mesh_.point(*fv_it); ++fv_it;
1406 pickVertexBuf_[idx+1] = mesh_.point(*fv_it); ++fv_it;
1407 pickVertexBuf_[idx+2] = mesh_.point(*fv_it);
1408 idx += 3;
1409 }
1410
1411 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
1412 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
1413
1414 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1415 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1416
1417 glDrawArrays(GL_TRIANGLES, 0, mesh_.n_faces() * 3);
1418
1419 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
1420 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
1421
1422 }
1423 else
1424 {
1425 unsigned int face = 0;
1426 std::vector <GLint> first;
1427 std::vector <GLsizei> count;
1428
1429 first.resize (mesh_.n_faces());
1430 count.resize (mesh_.n_faces());
1431
1432 for (; f_it!=f_end; ++f_it, ++face)
1433 {
1434 unsigned int cnt = 0;
1435 first[face] = idx;
1436
1437
1438 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it, ++idx, ++cnt)
1439 {
1440 pickVertexBuf_[idx] = mesh_.point(*fv_it);
1441 pickColorBuf_[idx] = _state.pick_get_name_color (f_it->idx());
1442 }
1443 count[face] = cnt;
1444 }
1445 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
1446 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
1447
1448 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1449 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1450
1451 glMultiDrawArrays(GL_POLYGON, &first[0], &count[0], mesh_.n_faces());
1452
1453 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
1454 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
1455 }
1456 }
1457 else
1458 {
1459
1460 if (mesh_.is_trimesh())
1461 {
1462 for (; f_it!=f_end; ++f_it)
1463 {
1464 // set index
1465 _state.pick_set_name (f_it->idx());
1466
1467 glBegin(GL_TRIANGLES);
1468
1469 fv_it=mesh_.cfv_iter(*f_it);
1470 glVertex(mesh_.point(*fv_it)); ++fv_it;
1471 glVertex(mesh_.point(*fv_it)); ++fv_it;
1472 glVertex(mesh_.point(*fv_it));
1473 glEnd();
1474 }
1475 }
1476 else
1477 {
1478 for (; f_it!=f_end; ++f_it)
1479 {
1480 // set index
1481 _state.pick_set_name (f_it->idx());
1482
1483 glBegin(GL_POLYGON);
1484
1485 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
1486 glVertex(mesh_.point(*fv_it));
1487
1488 glEnd();
1489 }
1490 }
1491 }
1492
1493 if (faceList_)
1494 {
1495 glEndList ();
1496 glCallList (faceList_);
1497 }
1498 }
1499
1500 //----------------------------------------------------------------------------
1501
1502
1503 template<class Mesh>
1504 void
1505 MeshNodeDeprecatedT<Mesh>::
1506 pick_edges(GLState& _state, bool _front)
1507 {
1508 typename Mesh::ConstEdgeIter e_it(mesh_.edges_sbegin()),
1509 e_end(mesh_.edges_end());
1510
1511 GLenum prev_depth = _state.depthFunc();
1512
1513 if (!_state.pick_set_maximum (mesh_.n_edges()))
1514 {
1515 omerr() << "MeshNode::pick_edges: color range too small, "
1516 << "picking failed\n";
1517 return;
1518 }
1519
1520 if (_front)
1521 {
1522 enable_arrays(VERTEX_ARRAY);
1523
1524 Vec4f clear_color = _state.clear_color();
1525 Vec4f base_color = _state.base_color();
1526 clear_color[3] = 1.0;
1527
1528 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1529 _state.set_base_color(clear_color);
1530
1531 ACG::GLState::depthRange(0.01, 1.0);
1532 draw_faces(PER_VERTEX);
1533 ACG::GLState::depthRange(0.0, 1.0);
1534
1535 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1536 ACG::GLState::depthFunc(GL_LEQUAL);
1537 _state.set_base_color(base_color);
1538
1539 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1540
1541 enable_arrays(0);
1542 }
1543
1544 if (edgeList_ && !updateEdgeList_ && _state.pick_current_index () == edgeBaseIndex_)
1545 {
1546 glCallList (edgeList_);
1547 ACG::GLState::depthFunc(prev_depth);
1548 return;
1549 }
1550
1551 if (edgeList_)
1552 {
1553 glNewList (edgeList_, GL_COMPILE);
1554 updateEdgeList_ = false;
1555 edgeBaseIndex_ = _state.pick_current_index ();
1556 }
1557
1558 if (_state.color_picking ())
1559 {
1560 unsigned int idx = 0;
1561 update_pick_buffers ();
1562
1563 for (; e_it!=e_end; ++e_it)
1564 {
1565 pickColorBuf_[idx] = _state.pick_get_name_color (e_it->idx());
1566 pickColorBuf_[idx+1] = _state.pick_get_name_color (e_it->idx());
1567 pickVertexBuf_[idx] = mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 0)));
1568 pickVertexBuf_[idx+1] = mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 1)));
1569 idx += 2;
1570 }
1571
1572 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
1573 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
1574
1575 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1576 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1577
1578 glDrawArrays(GL_LINES, 0, mesh_.n_edges() * 2);
1579
1580 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
1581 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
1582 }
1583 else
1584 {
1585 for (; e_it!=e_end; ++e_it)
1586 {
1587 _state.pick_set_name (e_it->idx());
1588 glBegin(GL_LINES);
1589 glVertex(mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 0))));
1590 glVertex(mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 1))));
1591 glEnd();
1592 }
1593 }
1594
1595 if (edgeList_)
1596 {
1597 glEndList ();
1598 glCallList (edgeList_);
1599 }
1600
1601 ACG::GLState::depthFunc(prev_depth);
1602 }
1603
1604 //----------------------------------------------------------------------------
1605
1606
1607 template<class Mesh>
1608 void
1609 MeshNodeDeprecatedT<Mesh>::
1610 pick_any(GLState& _state)
1611 {
1612 GLenum prev_depth = _state.depthFunc();
1613
1614 unsigned int numElements = mesh_.n_faces() + mesh_.n_edges() + mesh_.n_vertices();
1615
1616 // nothing to pick ?
1617 if (numElements == 0)
1618 return;
1619
1620 if (!_state.pick_set_maximum (numElements))
1621 {
1622 omerr() << "MeshNode::pick_any: color range too small, "
1623 << "picking failed\n";
1624 return;
1625 }
1626
1627 if (anyList_ && !updateAnyList_ && _state.pick_current_index () == anyBaseIndex_)
1628 {
1629 glCallList (anyList_);
1630 glCallList (anyList_+1);
1631 glCallList (anyList_+2);
1632 return;
1633 }
1634
1635 if (anyList_)
1636 {
1637 glNewList (anyList_, GL_COMPILE);
1638 updateAnyList_ = false;
1639 anyBaseIndex_ = _state.pick_current_index ();
1640 }
1641
1642 // faces
1643 typename Mesh::ConstFaceIter f_it(mesh_.faces_sbegin()),
1644 f_end(mesh_.faces_end());
1645 typename Mesh::ConstFaceVertexIter fv_it;
1646
1647 // edges
1648 typename Mesh::ConstEdgeIter e_it(mesh_.edges_sbegin()),
1649 e_end(mesh_.edges_end());
1650
1651 // vertices
1652 typename Mesh::ConstVertexIter v_it(mesh_.vertices_begin()),
1653 v_end(mesh_.vertices_end());
1654 GLuint vidx(mesh_.n_faces() + mesh_.n_edges());
1655
1656
1657
1658 if (_state.color_picking ())
1659 {
1660 update_pick_buffers ();
1661
1662 ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
1663 ACG::GLState::enableClientState(GL_COLOR_ARRAY);
1664
1665 // faces
1666 unsigned int idx = 0;
1667 if (mesh_.is_trimesh())
1668 {
1669 for (; f_it!=f_end; ++f_it)
1670 {
1671 pickColorBuf_[idx] = _state.pick_get_name_color (f_it->idx());
1672 pickColorBuf_[idx+1] = _state.pick_get_name_color (f_it->idx());
1673 pickColorBuf_[idx+2] = _state.pick_get_name_color (f_it->idx());
1674
1675 fv_it=mesh_.cfv_iter(*f_it);
1676 pickVertexBuf_[idx] = mesh_.point(*fv_it); ++fv_it;
1677 pickVertexBuf_[idx+1] = mesh_.point(*fv_it); ++fv_it;
1678 pickVertexBuf_[idx+2] = mesh_.point(*fv_it);
1679 idx += 3;
1680 }
1681
1682 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1683 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1684
1685 glDrawArrays(GL_TRIANGLES, 0, mesh_.n_faces() * 3);
1686
1687 }
1688 else
1689 {
1690 unsigned int face = 0;
1691 std::vector <GLint> first;
1692 std::vector <GLsizei> count;
1693
1694 first.resize (mesh_.n_faces());
1695 count.resize (mesh_.n_faces());
1696
1697 for (; f_it!=f_end; ++f_it, ++face)
1698 {
1699 unsigned int cnt = 0;
1700 first[face] = idx;
1701
1702
1703 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it, ++idx, ++cnt)
1704 {
1705 pickVertexBuf_[idx] = mesh_.point(*fv_it);
1706 pickColorBuf_[idx] = _state.pick_get_name_color (f_it->idx());
1707 }
1708 count[face] = cnt;
1709 }
1710
1711 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1712 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1713
1714 glMultiDrawArrays(GL_POLYGON, &first[0], &count[0], mesh_.n_faces());
1715
1716 }
1717
1718 if (anyList_)
1719 {
1720 glEndList ();
1721 glNewList (anyList_+1, GL_COMPILE);
1722 }
1723
1724 ACG::GLState::depthFunc(GL_LEQUAL);
1725
1726 // edges
1727 idx = 0;
1728 for (; e_it!=e_end; ++e_it)
1729 {
1730 pickColorBuf_[idx] = _state.pick_get_name_color (mesh_.n_faces() + e_it->idx());
1731 pickColorBuf_[idx+1] = _state.pick_get_name_color (mesh_.n_faces() + e_it->idx());
1732 pickVertexBuf_[idx] = mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 0)));
1733 pickVertexBuf_[idx+1] = mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 1)));
1734 idx += 2;
1735 }
1736
1737 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1738 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1739
1740 glDrawArrays(GL_LINES, 0, mesh_.n_edges() * 2);
1741
1742 if (anyList_)
1743 {
1744 ACG::GLState::depthFunc(prev_depth);
1745 glEndList ();
1746 glNewList (anyList_+2, GL_COMPILE);
1747 ACG::GLState::depthFunc(GL_LEQUAL);
1748 }
1749
1750 // vertices
1751 idx = 0;
1752 for (; v_it!=v_end; ++v_it, ++idx, ++vidx)
1753 {
1754 pickColorBuf_[idx] = _state.pick_get_name_color (vidx);
1755 pickVertexBuf_[idx] = mesh_.point(*v_it);
1756 }
1757
1758 ACG::GLState::vertexPointer (&pickVertexBuf_[0]);
1759 ACG::GLState::colorPointer(&pickColorBuf_[0]);
1760
1761 glDrawArrays(GL_POINTS, 0, mesh_.n_vertices());
1762
1763 ACG::GLState::disableClientState(GL_COLOR_ARRAY);
1764 ACG::GLState::disableClientState(GL_VERTEX_ARRAY);
1765 }
1766 else
1767 {
1768 // faces
1769 if (mesh_.is_trimesh())
1770 {
1771 for (; f_it!=f_end; ++f_it)
1772 {
1773 // set index
1774 _state.pick_set_name (f_it->idx());
1775
1776 glBegin(GL_TRIANGLES);
1777
1778 fv_it=mesh_.cfv_iter(*f_it);
1779 glVertex(mesh_.point(*fv_it)); ++fv_it;
1780 glVertex(mesh_.point(*fv_it)); ++fv_it;
1781 glVertex(mesh_.point(*fv_it));
1782 glEnd();
1783 }
1784 }
1785 else
1786 {
1787 for (; f_it!=f_end; ++f_it)
1788 {
1789 // set index
1790 _state.pick_set_name (f_it->idx());
1791
1792 glBegin(GL_POLYGON);
1793
1794 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
1795 glVertex(mesh_.point(*fv_it));
1796
1797 glEnd();
1798 }
1799 }
1800
1801 if (anyList_)
1802 {
1803 ACG::GLState::depthFunc(prev_depth);
1804 glEndList ();
1805 glNewList (anyList_+1, GL_COMPILE);
1806 }
1807
1808 ACG::GLState::depthFunc(GL_LEQUAL);
1809
1810 // edges
1811 for (; e_it!=e_end; ++e_it)
1812 {
1813 _state.pick_set_name (mesh_.n_faces() + e_it->idx());
1814 glBegin(GL_LINES);
1815 glVertex(mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 0))));
1816 glVertex(mesh_.point(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 1))));
1817 glEnd();
1818 }
1819
1820 if (anyList_)
1821 {
1822 ACG::GLState::depthFunc(prev_depth);
1823 glEndList ();
1824 glNewList (anyList_+2, GL_COMPILE);
1825 ACG::GLState::depthFunc(GL_LEQUAL);
1826 }
1827
1828 // vertices
1829 for (; v_it!=v_end; ++v_it, ++vidx)
1830 {
1831 _state.pick_set_name (vidx);
1832 glBegin(GL_POINTS);
1833 glVertex(mesh_.point(*v_it));
1834 glEnd();
1835 }
1836 }
1837
1838 ACG::GLState::depthFunc(prev_depth);
1839
1840 if (anyList_)
1841 {
1842 glEndList ();
1843 glCallList (anyList_);
1844 glCallList (anyList_+1);
1845 glCallList (anyList_+2);
1846 }
1847 }
1848
1849 //----------------------------------------------------------------------------
1850
1851 template<class Mesh>
1852 void
1853 MeshNodeDeprecatedT<Mesh>::
1854 update_pick_buffers ()
1855 {
1856 unsigned int nfv = 0;
1857 if (mesh_.is_trimesh())
1858 nfv = mesh_.n_faces() * 3;
1859 else
1860 {
1861 // count number of vertices we need for faces in our buffer
1862 typename Mesh::ConstFaceIter f_it(mesh_.faces_sbegin()),
1863 f_end(mesh_.faces_end());
1864 typename Mesh::ConstFaceVertexIter fv_it;
1865 for (; f_it!=f_end; ++f_it)
1866 {
1867 for (fv_it=mesh_.cfv_iter(*f_it); fv_it.is_valid(); ++fv_it)
1868 nfv++;
1869 }
1870 }
1871
1872 pickVertexBuf_.resize (std::max(mesh_.n_vertices(), std::max(mesh_.n_edges() * 2, size_t(nfv))));
1873 pickColorBuf_.resize (std::max(mesh_.n_vertices(), std::max(mesh_.n_edges() * 2, size_t(nfv))));
1874 }
1875
1876 //=============================================================================
1877 } // namespace SceneGraph
1878 } // namespace ACG
1879 #endif // DOXY_IGNORE_THIS
1880 //=============================================================================
ACG::SceneGraph::DrawModes::SOLID_2DTEXTURED_FACE
DrawMode SOLID_2DTEXTURED_FACE
draw per halfedge textured faces
Definition: DrawModes.cc:96
ACG::glColor
void glColor(const Vec3f &_v)
Wrapper: glColor for Vec3f.
Definition: gl.hh:144
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::mesh_
Mesh & mesh_
The mesh this node works on.
Definition: MeshNode2T_impl.hh:184
omstream.hh
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::bbMax_
Vec3d bbMax_
bounding box upper right corner
Definition: MeshNode2T_impl.hh:218
OpenMesh::PolyMeshT::ConstFaceVertexIter
Kernel::ConstFaceVertexIter ConstFaceVertexIter
Circulator.
Definition: PolyMeshT.hh:177
ACG::SceneGraph::PICK_EDGE
picks edges (may not be implemented for all nodes)
Definition: PickTarget.hh:80
ACG::glNormal
void glNormal(const Vec3f &_n)
Wrapper: glNormal for Vec3f.
Definition: gl.hh:135
OpenMesh::PolyMeshT::Normal
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:114
ACG::SceneGraph::DrawModes::SOLID_3DTEXTURED_SHADED
DrawMode SOLID_3DTEXTURED_SHADED
draw smooth shaded textured faces
Definition: DrawModes.cc:93
ACG::SceneGraph::PICK_FACE
picks faces (should be implemented for all nodes)
Definition: PickTarget.hh:78
OpenMesh::HPropHandleT
Definition: Property.hh:499
ACG::SceneGraph::DrawModes::SOLID_ENV_MAPPED
DrawMode SOLID_ENV_MAPPED
draw environment mapped
Definition: DrawModes.cc:87
ACG
Namespace providing different geometric functions concerning angles.
Definition: BaseObjectData.hh:68
ACG::SceneGraph::PICK_FRONT_VERTEX
picks only visible front verices (may not be implemented for all nodes)
Definition: PickTarget.hh:89
ACG::Vec4f
VectorT< float, 4 > Vec4f
Definition: VectorT.hh:138
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
OpenMesh::TriMesh_ArrayKernelT
Definition: PolyMesh_ArrayKernelT.hh:73
ACG::SceneGraph::ACG::GLState::disable
static void disable(GLenum _cap, bool _warnRemoved=true)
replaces glDisable, but supports locking
ACG::SceneGraph::ACG::GLState::enableClientState
static void enableClientState(GLenum _cap)
replaces glEnableClientState, supports locking
OpenMesh::VectorT
Definition: Vector11T.hh:83
ACG::SceneGraph::ACG::GLState::bindBufferARB
static void bindBufferARB(GLenum _target, GLuint _buffer)
same function as bindBuffer
Definition: MeshNode2T_impl.hh:573
ACG::SceneGraph::DrawModes::SOLID_2DTEXTURED_FACE_SHADED
DrawMode SOLID_2DTEXTURED_FACE_SHADED
draw per halfedge textured faces
Definition: DrawModes.cc:97
ACG::SceneGraph::DrawModes::HIDDENLINE
DrawMode HIDDENLINE
draw hidden line (2 rendering passes needed)
Definition: DrawModes.cc:80
OpenMesh::TriMeshT::is_trimesh
static constexpr bool is_trimesh()
Determine whether this is a PolyMeshT or TriMeshT (This function does not check the per face vertex c...
Definition: TriMeshT.hh:104
OpenMesh::VectorT::maximize
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: Vector11T.hh:568
ACG::glCheckErrors
void glCheckErrors()
Definition: GLError.hh:96
ACG::SceneGraph::DrawModes::SOLID_SMOOTH_SHADED
DrawMode SOLID_SMOOTH_SHADED
draw smooth shaded (Gouraud shaded) faces (requires halfedge normals)
Definition: DrawModes.cc:82
ACG::SceneGraph::ACG::GLState::disableClientState
static void disableClientState(GLenum _cap)
replaces glDisableClientState, supports locking
OpenMesh::BaseHandle::is_valid
bool is_valid() const
The handle is valid iff the index is not negative.
Definition: Handles.hh:72
SceneGraph
Definition: QtPrincipalAxisDialog.hh:67
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::pick_vertices
void pick_vertices(GLState &_state, bool _front=false)
Renders picking for vertices _front: Only render front vertices (not occluded by geometry) ...
Definition: MeshNode2T_impl.hh:1176
ACG::SceneGraph::DrawModes::SOLID_3DTEXTURED
DrawMode SOLID_3DTEXTURED
draw textured faces
Definition: DrawModes.cc:92
ACG::SceneGraph::PickTarget
PickTarget
What target to use for picking.
Definition: PickTarget.hh:73
ACG::SceneGraph::DrawModes::SOLID_PHONG_SHADED
DrawMode SOLID_PHONG_SHADED
draw phong shaded faces
Definition: DrawModes.cc:83
ACG::SceneGraph::ACG::GLState::colorPointer
static void colorPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glColorPointer, supports locking
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::Point
Mesh::Point Point
Definition: MeshNode2T_impl.hh:164
OpenMesh::PolyMeshT::ConstFaceHalfedgeIter
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:178
ACG::SceneGraph::DrawModes::SOLID_1DTEXTURED
DrawMode SOLID_1DTEXTURED
draw textured faces
Definition: DrawModes.cc:90
ACG::SceneGraph::DrawModes::SOLID_POINTS_COLORED
DrawMode SOLID_POINTS_COLORED
draw colored, but not lighted faces using interpolated vertex colors
Definition: DrawModes.cc:85
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::enable_arrays
void enable_arrays(unsigned int _arrays)
enable/disable vertex arrays according to the bits in _arrays
Definition: MeshNode2T_impl.hh:1017
ACG::SceneGraph::PICK_ANYTHING
pick any of the prior targets (should be implemented for all nodes)
Definition: PickTarget.hh:84
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::pick_edges
void pick_edges(GLState &_state, bool _front=false)
Renders picking for edges _front: Only render front edges (not occluded by geometry) ...
Definition: MeshNode2T_impl.hh:1275
ACG::SceneGraph::DrawModes::SOLID_TEXTURED
DrawMode SOLID_TEXTURED
draw textured faces
Definition: DrawModes.cc:88
ACG::SceneGraph::DrawModes::SOLID_FACES_COLORED_FLAT_SHADED
DrawMode SOLID_FACES_COLORED_FLAT_SHADED
draw flat shaded and colored faces (requires face normals and colors)
Definition: DrawModes.cc:94
ACG::SceneGraph::PICK_VERTEX
picks verices (may not be implemented for all nodes)
Definition: PickTarget.hh:82
OpenMesh::VectorT::minimize
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: Vector11T.hh:540
ACG::SceneGraph::PICK_FRONT_EDGE
picks only visible front edges (may not be implemented for all nodes)
Definition: PickTarget.hh:87
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::draw_faces
void draw_faces()
draws all faces of the mesh
Definition: MeshNode2T_impl.hh:1003
OpenMesh::PolyMeshT::TexCoord2D
Kernel::TexCoord2D TexCoord2D
TexCoord2D type.
Definition: PolyMeshT.hh:120
ACG::SceneGraph::BaseNode
Definition: BaseNode.hh:104
ACG::SceneGraph::ACG::GLState::normalPointer
static void normalPointer(GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glNormalPointer, supports locking
ACG::glVertex
void glVertex(const Vec2i &_v)
Wrapper: glVertex for Vec2i.
Definition: gl.hh:95
ACG::SceneGraph::DrawModes::NONE
DrawMode NONE
not a valid draw mode
Definition: DrawModes.cc:71
ACG::SceneGraph::DrawModes::POINTS
DrawMode POINTS
draw unlighted points using the default base color
Definition: DrawModes.cc:73
ACG::SceneGraph::DrawModes::SOLID_SHADER
DrawMode SOLID_SHADER
Definition: DrawModes.cc:98
ACG::SceneGraph::ACG::GLState::texcoordPointer
static void texcoordPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glTexcoordPointer, supports locking
ACG::SceneGraph::ACG::GLState::vertexPointer
static void vertexPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glVertexPointer, supports locking
ACG::SceneGraph::DrawModes::SOLID_FLAT_SHADED
DrawMode SOLID_FLAT_SHADED
draw flat shaded faces (requires face normals)
Definition: DrawModes.cc:81
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::pick_any
void pick_any(GLState &_state)
Renders picking for all primitives.
Definition: MeshNode2T_impl.hh:1473
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::bbMin_
Vec3d bbMin_
bounding box lower left corner
Definition: MeshNode2T_impl.hh:215
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::pick_faces
void pick_faces(GLState &_state)
Renders picking for faces _front: Only render front faces (not occluded by geometry) ...
Definition: MeshNode2T_impl.hh:1371
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::enabled_arrays_
unsigned int enabled_arrays_
which arrays are currently enabled?
Definition: MeshNode2T_impl.hh:285
ACG::SceneGraph::DrawModes::SOLID_1DTEXTURED_SHADED
DrawMode SOLID_1DTEXTURED_SHADED
draw smooth shaded textured faces
Definition: DrawModes.cc:91
ACG::SceneGraph::DrawModes::WIREFRAME
DrawMode WIREFRAME
draw wireframe
Definition: DrawModes.cc:78
ACG::SceneGraph::DrawModes::SOLID_FACES_COLORED
DrawMode SOLID_FACES_COLORED
draw colored, but not lighted faces using face colors
Definition: DrawModes.cc:84
ACG::SceneGraph::DrawModes::POINTS_COLORED
DrawMode POINTS_COLORED
draw colored, but not lighted points (requires point colors)
Definition: DrawModes.cc:74
ACG::SceneGraph::ACG::GLState::enable
static void enable(GLenum _cap, bool _warnRemoved=true)
replaces glEnable, but supports locking
OpenMesh::FPropHandleT
Definition: Property.hh:529
ACG::SceneGraph::ACG::GLState::depthRange
static void depthRange(GLclampd _zNear, GLclampd _zFar)
replaces glDepthRange, supports locking
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::draw_vertices
void draw_vertices()
draws all vertices of the mesh
Definition: MeshNode2T_impl.hh:956
ACG::SceneGraph::DrawModes::SOLID_TEXTURED_SHADED
DrawMode SOLID_TEXTURED_SHADED
draw smooth shaded textured faces
Definition: DrawModes.cc:89
ACG::SceneGraph::DrawModes::POINTS_SHADED
DrawMode POINTS_SHADED
draw shaded points (requires point normals)
Definition: DrawModes.cc:75
ACG::SceneGraph::ACG::GLState::bindTexture
static void bindTexture(GLenum _target, GLuint _buffer)
replaces glBindTexture, supports locking
ACG::SceneGraph::ACG::GLState::shadeModel
static void shadeModel(GLenum _mode)
replaces glShadeModel, supports locking
OpenMesh::BaseHandle::reset
void reset()
reset handle to be invalid
Definition: Handles.hh:75
ACG::SceneGraph::ACG::GLState::depthFunc
const GLenum & depthFunc() const
get glDepthFunc() that is supposed to be active
ACG::Vec3d
VectorT< double, 3 > Vec3d
Definition: VectorT.hh:121
ACG::SceneGraph::ACG::SceneGraph::MeshNodeT::textureMap_
std::map< int, GLuint > * textureMap_
Mapping of mesh face texture indices to gltexture id ( has to be provided externally ) ...
Definition: MeshNode2T_impl.hh:495