Developer Documentation

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
VolumeMeshNodeT.cc
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 * $Revision$ *
45 * $LastChangedBy$ *
46 * $Date$ *
47 * *
48 \*===========================================================================*/
49
50 #define VOLUMEMESHNODET_CC
51
52 //== INCLUDES =================================================================
53
54 #include "VolumeMeshNode.hh"
55
56 #include <ACG/GL/gl.hh>
57 #include <ACG/Utils/VSToolsT.hh>
58 #include <vector>
59
60 #include <ACG/GL/RenderObject.hh>
61 #include <ACG/GL/VertexDeclaration.hh>
62 #include <ACG/GL/IRenderer.hh>
63
64 #include <OpenVolumeMesh/Mesh/HexahedralMesh.hh>
65
66 typedef OpenVolumeMesh::HexahedralMeshTopologyKernel HexahedralMeshTopologyKernel;
67
68
69 //== NAMESPACES ===============================================================
70
71 namespace ACG {
72 namespace SceneGraph {
73
74 //== IMPLEMENTATION ==========================================================
75
76
77 template<class VolumeMeshT>
78 VolumeMeshNodeT<VolumeMeshT>::VolumeMeshNodeT(const VolumeMesh& _mesh,
79 OpenVolumeMesh::StatusAttrib& _statusAttrib,
80 OpenVolumeMesh::ColorAttrib<Vec4f>& _colorAttrib,
81 OpenVolumeMesh::NormalAttrib<VolumeMesh>& _normalAttrib,
82 OpenVolumeMesh::TexCoordAttrib<Vec2f>& _texcoordAttrib,
83 const MaterialNode* _matNode, BaseNode* _parent,
84 std::string _name) :
85 BaseNode(_parent, _name),
86 mesh_(_mesh),
87 scale_(1.0),
88 boundary_only_(false),
89 translucency_factor_(0.1f),
90 selection_color_(ACG::Vec4f(1.0f, 0.0f, 0.0f, 1.0f)),
91 statusAttrib_(_statusAttrib),
92 colorAttrib_(_colorAttrib),
93 normalAttrib_(_normalAttrib),
94 texcoordAttrib_(_texcoordAttrib),
95 materialNode_(_matNode),
96
97 cellsBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
98 facesBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
99 edgesBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
100 verticesBufferManager_(_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
101
102 cellSelectionBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
103 faceSelectionBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
104 edgeSelectionBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
105 vertexSelectionBufferManager_(_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
106
107 cellPickBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
108 facePickBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
109 edgePickBufferManager_ (_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
110 vertexPickBufferManager_(_mesh, _statusAttrib, _colorAttrib, _normalAttrib, _texcoordAttrib),
111
112 drawModes_(),
113 lastDrawMode_ (DrawModes::NONE),
114 lastCellDrawMode_ (DrawModes::NONE),
115 lastFaceDrawMode_ (DrawModes::NONE),
116 lastEdgeDrawMode_ (DrawModes::NONE),
117 lastVertexDrawMode_(DrawModes::NONE),
118 lastPickTarget_(PICK_ANYTHING),
119 face_normals_calculated_(false),
120 vertex_normals_calculated_(false)
121 {
122 vertexSelectionBufferManager_.setSelectionOnly(true);
123 edgeSelectionBufferManager_.setSelectionOnly(true);
124 faceSelectionBufferManager_.setSelectionOnly(true);
125 cellSelectionBufferManager_.setSelectionOnly(true);
126 }
127
128
129 //----------------------------------------------------------------------------
130
131 template<class VolumeMeshT>
132 VolumeMeshNodeT<VolumeMeshT>::~VolumeMeshNodeT() {
133
134 }
135
136 //----------------------------------------------------------------------------
137
138 template<class VolumeMeshT>
139 void VolumeMeshNodeT<VolumeMeshT>::boundingBox(Vec3d& _bbMin, Vec3d& _bbMax) {
140
141 int n_vertices(mesh_.n_vertices());
142 for (int i = 0; i < n_vertices; ++i) {
143 Vec3d p(mesh_.vertex(VertexHandle(i)));
144 _bbMin.minimize(p);
145 _bbMax.maximize(p);
146 }
147 }
148
149 //----------------------------------------------------------------------------
150
151
152 template<class VolumeMeshT>
153 DrawModes::DrawMode VolumeMeshNodeT<VolumeMeshT>::availableDrawModes() const {
154 DrawModes::DrawMode result;
155
156 if (mesh_.n_cells() > 0)
157 {
158 result |= drawModes_.cellsTransparent;
159 result |= drawModes_.cellsFlatShaded;
160 result |= drawModes_.cellsSmoothShaded;
161 result |= drawModes_.cellsPhongShaded;
162 if (colorAttrib_.vertex_colors_available())
163 result |= drawModes_.cellsColoredPerVertex;
164 if (colorAttrib_.halfface_colors_available())
165 result |= drawModes_.cellsColoredPerHalfface;
166 if (colorAttrib_.face_colors_available())
167 result |= drawModes_.cellsColoredPerFace;
168 if (colorAttrib_.cell_colors_available())
169 result |= drawModes_.cellsColoredPerCell;
170 }
171
172 if (mesh_.n_faces() > 0)
173 {
174 result |= drawModes_.facesFlatShaded;
175 result |= drawModes_.facesSmoothShaded;
176 result |= drawModes_.facesPhongShaded;
177 if (colorAttrib_.vertex_colors_available())
178 result |= drawModes_.facesColoredPerVertex;
179 if (colorAttrib_.face_colors_available())
180 result |= drawModes_.facesColoredPerFace;
181 if (texcoordAttrib_.vertex_texcoords_available())
182 result |= drawModes_.facesTextured;
183 if (texcoordAttrib_.vertex_texcoords_available())
184 result |= drawModes_.facesTexturedShaded;
185 }
186
187 if (mesh_.n_halffaces() > 0)
188 {
189 result |= drawModes_.halffacesFlatShaded;
190 result |= drawModes_.halffacesSmoothShaded;
191 result |= drawModes_.halffacesPhongShaded;
192 if (colorAttrib_.vertex_colors_available())
193 result |= drawModes_.halffacesColoredPerVertex;
194 if (colorAttrib_.halfface_colors_available())
195 result |= drawModes_.halffacesColoredPerHalfface;
196 }
197
198 if (mesh_.n_edges() > 0)
199 {
200 result |= drawModes_.edgesWireframe;
201
202 if (mesh_.n_cells () > 0)
203 result |= drawModes_.edgesOnCells;
204 if (mesh_.n_faces() > 0)
205 result |= drawModes_.edgesHiddenLine;
206 if (colorAttrib_.edge_colors_available())
207 result |= drawModes_.edgesColoredPerEdge;
208
209 if (dynamic_cast<const HexahedralMeshTopologyKernel*>(&mesh_) != NULL)
210 {
211 result |= drawModes_.irregularInnerEdges;
212 result |= drawModes_.irregularOuterEdges;
213 }
214 }
215
216 if (mesh_.n_halfedges() > 0)
217 {
218 result |= drawModes_.halfedgesWireframe;
219
220 if (mesh_.n_faces() > 0)
221 result |= drawModes_.halfedgesHiddenLine;
222 if (colorAttrib_.halfedge_colors_available())
223 result |= drawModes_.halfedgesColoredPerHalfedge;
224 }
225
226 if (mesh_.n_vertices() > 0)
227 {
228 result |= drawModes_.verticesFlatShaded;
229
230 if (colorAttrib_.vertex_colors_available())
231 result |= drawModes_.verticesColored;
232 }
233
234 return result;
235
236 }
237
238
239 //----------------------------------------------------------------------------
240
241
242 template<class VolumeMeshT>
243 void VolumeMeshNodeT<VolumeMeshT>::drawCells(GLState& _state, const DrawModes::DrawMode& _drawMode)
244 {
245
246 ACG::GLState::depthRange(0.01, 1.0);
247
248 cellsBufferManager_.setOptionsFromDrawMode(_drawMode);
249 GLState::bindBuffer(GL_ARRAY_BUFFER, cellsBufferManager_.getBuffer());
250 GLState::enableClientState(GL_VERTEX_ARRAY);
251 GLState::vertexPointer(3, GL_FLOAT, cellsBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
252
253 GLState::enableClientState(GL_NORMAL_ARRAY);
254 GLState::normalPointer(GL_FLOAT, cellsBufferManager_.getStride(), reinterpret_cast<GLvoid*>(cellsBufferManager_.getNormalOffset()));
255
256 if (_drawMode & (drawModes_.cellsColoredPerCell | drawModes_.cellsColoredPerFace | drawModes_.cellsColoredPerHalfface | drawModes_.cellsColoredPerVertex))
257 {
258 //for a drawmode with colors we have to activate and bind colors
259 GLState::enableClientState(GL_COLOR_ARRAY);
260 GLState::colorPointer(4, GL_UNSIGNED_BYTE, cellsBufferManager_.getStride(), reinterpret_cast<GLvoid*>(cellsBufferManager_.getColorOffset()));
261
262 GLState::shadeModel(GL_SMOOTH);
263 GLState::disable(GL_LIGHTING);
264 GLState::enable(GL_DEPTH_TEST);
265
266 }
267 else if (_drawMode & drawModes_.cellsSmoothShaded)
268 {
269 GLState::shadeModel(GL_SMOOTH);
270 GLState::enable(GL_LIGHTING);
271 GLState::enable(GL_DEPTH_TEST);
272 }
273 else if (_drawMode & drawModes_.cellsFlatShaded)
274 {
275 GLState::shadeModel(GL_FLAT);
276 GLState::enable(GL_LIGHTING);
277 GLState::enable(GL_DEPTH_TEST);
278 }
279 else if (_drawMode & drawModes_.cellsTransparent)
280 {
281 GLState::shadeModel(GL_FLAT);
282 GLState::disable(GL_LIGHTING);
283 GLState::disable(GL_DEPTH_TEST);
284 GLState::disableClientState(GL_COLOR_ARRAY);
285 Vec4f bc = _state.specular_color();
286 _state.set_color(Vec4f(bc[0],bc[1],bc[2],translucency_factor_));
287 GLState::enable(GL_BLEND);
288 GLState::blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
289 }
290
291 glDrawArrays(GL_TRIANGLES, 0, cellsBufferManager_.getNumOfVertices());
292
293 if (_drawMode & drawModes_.cellsTransparent)
294 {
295 _state.set_color(_state.base_color());
296 GLState::disable(GL_BLEND);
297 }
298
299 GLState::disableClientState(GL_COLOR_ARRAY);
300 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
301
302 ACG::GLState::depthRange(0.0, 1.0);
303 }
304
305 template<class VolumeMeshT>
306 void VolumeMeshNodeT<VolumeMeshT>::drawFaces(GLState& _state, const DrawModes::DrawMode& _drawMode)
307 {
308
309 ACG::GLState::depthRange(0.01, 1.0);
310
311 //faces are drawn from both sides, halffaces only when facing the camera
312 //however, if we only draw the boundary, we draw halffaces from both sides so we can see them
313 //when looking inside the object
314 if ((_drawMode & drawModes_.faceBasedDrawModes) || boundary_only_)
315 {
316 GLState::disable(GL_CULL_FACE);
317 }
318 else
319 {
320 GLState::enable(GL_CULL_FACE);
321 GLState::cullFace(GL_BACK);
322 }
323
324 GLState::enable(GL_DEPTH_TEST);
325
326 facesBufferManager_.setOptionsFromDrawMode(_drawMode);
327 GLState::bindBuffer(GL_ARRAY_BUFFER, facesBufferManager_.getBuffer());
328 GLState::enableClientState(GL_VERTEX_ARRAY);
329 GLState::vertexPointer(3, GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
330
331 if (_drawMode & (drawModes_.hiddenLineBackgroundFaces))
332 {
333 GLState::disable(GL_LIGHTING);
334 GLState::shadeModel(GL_FLAT);
335 GLState::disableClientState(GL_COLOR_ARRAY);
336 GLState::disableClientState(GL_NORMAL_ARRAY);
337 _state.set_color(_state.clear_color());
338 }
339 else if (_drawMode & (drawModes_.facesColoredPerFace | drawModes_.facesColoredPerVertex
340 | drawModes_.halffacesColoredPerHalfface | drawModes_.halffacesColoredPerVertex ))
341 {
342 GLState::enableClientState(GL_COLOR_ARRAY);
343 GLState::colorPointer(4, GL_UNSIGNED_BYTE, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facesBufferManager_.getColorOffset()));
344
345 GLState::disable(GL_LIGHTING);
346 GLState::shadeModel(GL_SMOOTH);
347 }
348 else if (_drawMode & (drawModes_.facesTexturedShaded) )
349 {
350 glClientActiveTexture(GL_TEXTURE0);
351 ACG::GLState::texcoordPointer(2, GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facesBufferManager_.getTexCoordOffset()));
352 ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
353
354 GLState::enable(GL_LIGHTING);
355 GLState::disableClientState(GL_COLOR_ARRAY);
356
357 GLState::enableClientState(GL_NORMAL_ARRAY);
358 GLState::normalPointer(GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facesBufferManager_.getNormalOffset()));
359
360 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
361 GLState::shadeModel(GL_SMOOTH);
362 }
363 else if (_drawMode & (drawModes_.facesTextured) )
364 {
365 glClientActiveTexture(GL_TEXTURE0);
366 ACG::GLState::texcoordPointer(2, GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facesBufferManager_.getTexCoordOffset()));
367 ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
368
369 GLState::disableClientState(GL_COLOR_ARRAY);
370 GLState::disableClientState(GL_NORMAL_ARRAY);
371
372 GLState::disable(GL_LIGHTING);
373 GLState::shadeModel(GL_SMOOTH);
374
375 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
376 }
377 else
378 {
379 GLState::enable(GL_LIGHTING);
380 GLState::disableClientState(GL_COLOR_ARRAY);
381
382 GLState::enableClientState(GL_NORMAL_ARRAY);
383 GLState::normalPointer(GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facesBufferManager_.getNormalOffset()));
384
385 GLState::shadeModel(GL_SMOOTH);
386 }
387
388 glDrawArrays(GL_TRIANGLES, 0, facesBufferManager_.getNumOfVertices());
389
390 GLState::disableClientState(GL_COLOR_ARRAY);
391
392 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
393
394 if (_drawMode & (drawModes_.edgesHiddenLine | drawModes_.halfedgesHiddenLine))
395 _state.set_color(_state.base_color());
396
397 ACG::GLState::depthRange(0.0, 1.0);
398 }
399
400 template<class VolumeMeshT>
401 void VolumeMeshNodeT<VolumeMeshT>::drawEdges(GLState& _state, const DrawModes::DrawMode& _drawMode)
402 {
403 ACG::GLState::depthRange(0.0, 1.0);
404
405 edgesBufferManager_.setDefaultColor(_state.specular_color());
406 edgesBufferManager_.setOptionsFromDrawMode(_drawMode);
407
408 GLState::bindBuffer(GL_ARRAY_BUFFER, edgesBufferManager_.getBuffer());
409 GLState::enableClientState(GL_VERTEX_ARRAY);
410 GLState::vertexPointer(3, GL_FLOAT, edgesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
411
412 if (_drawMode & ( drawModes_.edgesColoredPerEdge | drawModes_.halfedgesColoredPerHalfedge |
413 drawModes_.irregularInnerEdges | drawModes_.irregularOuterEdges ))
414 {
415 GLState::enableClientState(GL_COLOR_ARRAY);
416 GLState::colorPointer(4, GL_UNSIGNED_BYTE, edgesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(edgesBufferManager_.getColorOffset()));
417
418 GLState::disable(GL_LIGHTING);
419 GLState::shadeModel(GL_SMOOTH);
420
421 glLineWidth(_state.line_width() * 2.0f);
422 }
423 else
424 {
425 _state.set_color( _state.specular_color() );
426
427 ACG::GLState::disable(GL_LIGHTING);
428 ACG::GLState::shadeModel(GL_FLAT);
429
430 GLState::disableClientState(GL_NORMAL_ARRAY);
431 }
432
433
434 glDrawArrays(GL_LINES, 0, edgesBufferManager_.getNumOfVertices());
435 glLineWidth(_state.line_width());
436
437 GLState::disableClientState(GL_COLOR_ARRAY);
438
439 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
440
441 }
442
443 template<class VolumeMeshT>
444 void VolumeMeshNodeT<VolumeMeshT>::drawVertices(GLState& _state, const DrawModes::DrawMode& _drawMode)
445 {
446 verticesBufferManager_.setOptionsFromDrawMode(_drawMode);
447 GLState::bindBuffer(GL_ARRAY_BUFFER, verticesBufferManager_.getBuffer());
448 GLState::enableClientState(GL_VERTEX_ARRAY);
449 GLState::vertexPointer(3, GL_FLOAT, verticesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
450
451 GLState::depthRange(0.0,1.0);
452
453 if (_drawMode & ( drawModes_.verticesColored ))
454 {
455 GLState::enableClientState(GL_COLOR_ARRAY);
456 GLState::colorPointer(4, GL_UNSIGNED_BYTE, verticesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(verticesBufferManager_.getColorOffset()));
457
458 GLState::disable(GL_LIGHTING);
459 GLState::shadeModel(GL_SMOOTH);
460 }
461 else
462 {
463 _state.set_color( _state.specular_color() );
464
465 ACG::GLState::disable(GL_LIGHTING);
466 ACG::GLState::shadeModel(GL_FLAT);
467
468 GLState::disableClientState(GL_NORMAL_ARRAY);
469 }
470
471 glDrawArrays(GL_POINTS, 0, verticesBufferManager_.getNumOfVertices());
472
473 GLState::disableClientState(GL_COLOR_ARRAY);
474
475 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
476
477 }
478
479 template<class VolumeMeshT>
480 void VolumeMeshNodeT<VolumeMeshT>::drawSelection(GLState& _state, const DrawModes::DrawMode& _drawMode)
481 {
482
483 //save current shader
484 GLint currentProgramm;
485 glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgramm);
486 //disable shader for drawing of the selecttion
487 ACG::GLState::useProgram(0);
488
489 GLState::enable(GL_DEPTH_TEST);
490 GLState::depthFunc(GL_LEQUAL);
491 _state.set_color( selection_color_ );
492
493 GLState::disable(GL_LIGHTING);
494 GLState::shadeModel(GL_FLAT);
495 glDisable(GL_CULL_FACE);
496 GLState::disableClientState(GL_NORMAL_ARRAY);
497 GLState::disableClientState(GL_COLOR_ARRAY);
498
499 GLState::disable(GL_TEXTURE_2D);
500
501 GLState::enableClientState(GL_VERTEX_ARRAY);
502
503 if ((_drawMode & drawModes_.cellBasedDrawModes) && !(_drawMode & drawModes_.vertexBasedDrawModes))
504 vertexSelectionBufferManager_.enableVertexOnCellPrimitives();
505 else
506 vertexSelectionBufferManager_.enableVertexPrimitives();
507
508 if ((_drawMode & (drawModes_.cellBasedDrawModes | drawModes_.edgesOnCells)) && !(_drawMode & (drawModes_.edgeBasedDrawModes & ~drawModes_.edgesOnCells)))
509 edgeSelectionBufferManager_.enableEdgeOnCellPrimitives();
510 else
511 edgeSelectionBufferManager_.enableEdgePrimitives();
512
513 if ((_drawMode & drawModes_.cellBasedDrawModes) && !(_drawMode & (drawModes_.faceBasedDrawModes | drawModes_.halffaceBasedDrawModes)))
514 faceSelectionBufferManager_.enableFaceOnCellPrimitives();
515 else
516 faceSelectionBufferManager_.enableFacePrimitives();
517
518 cellSelectionBufferManager_.enableCellPrimitives();
519
520 glLineWidth(1.5*_state.line_width());
521
522 GLState::depthRange(0.0,1.0);
523
524 GLState::bindBuffer(GL_ARRAY_BUFFER, vertexSelectionBufferManager_.getBuffer());
525 GLState::vertexPointer(3, GL_FLOAT, 0, 0);
526 glDrawArrays(GL_POINTS, 0, vertexSelectionBufferManager_.getNumOfVertices());
527
528 GLState::bindBuffer(GL_ARRAY_BUFFER, edgeSelectionBufferManager_.getBuffer());
529 GLState::vertexPointer(3, GL_FLOAT, 0, 0);
530 glDrawArrays(GL_LINES, 0, edgeSelectionBufferManager_.getNumOfVertices());
531
532 GLState::depthRange(0.01,1.0);
533
534 GLState::bindBuffer(GL_ARRAY_BUFFER, faceSelectionBufferManager_.getBuffer());
535 GLState::vertexPointer(3, GL_FLOAT, 0, 0);
536 glDrawArrays(GL_TRIANGLES, 0, faceSelectionBufferManager_.getNumOfVertices());
537
538 GLState::bindBuffer(GL_ARRAY_BUFFER, cellSelectionBufferManager_.getBuffer());
539 GLState::vertexPointer(3, GL_FLOAT, 0, 0);
540 glDrawArrays(GL_TRIANGLES, 0, cellSelectionBufferManager_.getNumOfVertices());
541
542 GLState::depthRange(0.0,1.0);
543
544 _state.set_color(_state.base_color());
545
546 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
547
548
549 glLineWidth(_state.line_width());
550
551 ACG::GLState::useProgram(currentProgramm);
552
553 }
554
555 template<class VolumeMeshT>
556 void VolumeMeshNodeT<VolumeMeshT>::invalidateAllBuffers()
557 {
558 invalidateAllDrawBuffers();
559 invalidateAllPickingBuffers();
560 invalidateAllSelectionBuffers();
561 }
562
563 template<class VolumeMeshT>
564 void VolumeMeshNodeT<VolumeMeshT>::invalidateAllDrawBuffers()
565 {
566 cellsBufferManager_.invalidate();
567 facesBufferManager_.invalidate();
568 edgesBufferManager_.invalidate();
569 verticesBufferManager_.invalidate();
570 }
571
572 template<class VolumeMeshT>
573 void VolumeMeshNodeT<VolumeMeshT>::invalidateAllPickingBuffers()
574 {
575 cellPickBufferManager_.invalidate();
576 facePickBufferManager_.invalidate();
577 edgePickBufferManager_.invalidate();
578 vertexPickBufferManager_.invalidate();
579 }
580
581 template<class VolumeMeshT>
582 void VolumeMeshNodeT<VolumeMeshT>::invalidateAllSelectionBuffers()
583 {
584 cellSelectionBufferManager_.invalidate();
585 faceSelectionBufferManager_.invalidate();
586 edgeSelectionBufferManager_.invalidate();
587 vertexSelectionBufferManager_.invalidate();
588 }
589
590 template<class VolumeMeshT>
591 void VolumeMeshNodeT<VolumeMeshT>::draw(GLState& _state, const DrawModes::DrawMode& _drawMode) {
592
593 //save state
594 GLboolean lighting = false;
595 glGetBooleanv(GL_LIGHTING, &lighting);
596 GLboolean color_material = false;
597 glGetBooleanv(GL_COLOR_MATERIAL, &color_material);
598 GLboolean blend = false;
599 glGetBooleanv(GL_BLEND, &blend);
600 GLboolean depth = false;
601 glGetBooleanv(GL_DEPTH_TEST, &depth);
602 GLenum prev_depth = _state.depthFunc();
603 GLboolean cullFace = false;
604 glGetBooleanv(GL_CULL_FACE, &cullFace);
605 GLint cullFaceMode;
606 glGetIntegerv(GL_CULL_FACE_MODE, &cullFaceMode);
607 GLint texmode;
608 glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texmode);
609 GLboolean texturing;
610 glGetBooleanv(GL_TEXTURE_2D, &texturing);
611 const Vec4f oldColor = _state.color();
612
613 // ignore two sided lighting setting and turn it off
614 GLboolean lightModel = _state.twosided_lighting();
615 _state.set_twosided_lighting(false);
616
617 bool clientStateEnabledVertexArray = GLState::isClientStateEnabled(GL_VERTEX_ARRAY);
618 bool clientStateEnabledColorArray = GLState::isClientStateEnabled(GL_COLOR_ARRAY);
619 bool clientStateEnabledNormalArray = GLState::isClientStateEnabled(GL_NORMAL_ARRAY);
620 bool clientStateEnabledTexCoordArray = GLState::isClientStateEnabled(GL_TEXTURE_COORD_ARRAY);
621
622 DrawModes::DrawMode cellDrawMode = drawModes_.getFirstCellDrawMode(_drawMode);
623 DrawModes::DrawMode faceDrawMode = drawModes_.getFirstFaceDrawMode(_drawMode);
624 DrawModes::DrawMode edgeDrawMode = drawModes_.getFirstEdgeDrawMode(_drawMode);
625 DrawModes::DrawMode vertexDrawMode = drawModes_.getFirstVertexDrawMode(_drawMode);
626
627 if (!face_normals_calculated_)
628 {
629 if ( (cellDrawMode & drawModes_.cellsFlatShaded) ||
630 (faceDrawMode & (drawModes_.facesFlatShaded | drawModes_.halffacesFlatShaded | drawModes_.facesTexturedShaded)) )
631 update_face_normals();
632 }
633 if (!vertex_normals_calculated_)
634 {
635 if ( (cellDrawMode & (drawModes_.cellsSmoothShaded | drawModes_.cellsPhongShaded)) ||
636 (faceDrawMode & (drawModes_.facesSmoothShaded | drawModes_.halffacesSmoothShaded | drawModes_.facesPhongShaded | drawModes_.halffacesPhongShaded)) )
637 update_vertex_normals();
638 }
639
640 //the VolumeMeshBufferManager can handle non atomic drawmodes if it consists of one
641 // edge based draw mode (except edges on cells) and irregular edges
642 edgeDrawMode |= _drawMode & (drawModes_.irregularInnerEdges | drawModes_.irregularOuterEdges);
643
644
645 if (cellDrawMode)
646 drawCells(_state, cellDrawMode);
647 else
648 cellsBufferManager_.free();
649 if (faceDrawMode)
650 drawFaces(_state, faceDrawMode);
651 else
652 facesBufferManager_.free();
653 if (edgeDrawMode)
654 drawEdges(_state, edgeDrawMode);
655 else
656 edgesBufferManager_.free();
657 if (vertexDrawMode)
658 drawVertices(_state, vertexDrawMode);
659 else
660 verticesBufferManager_.free();
661
662 drawSelection(_state, cellDrawMode | faceDrawMode | edgeDrawMode | vertexDrawMode);
663
664
665 lastDrawMode_ = cellDrawMode | faceDrawMode | edgeDrawMode | vertexDrawMode;
666 lastCellDrawMode_ = cellDrawMode;
667 lastFaceDrawMode_ = faceDrawMode;
668 lastEdgeDrawMode_ = edgeDrawMode;
669 lastVertexDrawMode_ = vertexDrawMode;
670
671 //restore state
672 if(lighting)
673 ACG::GLState::enable(GL_LIGHTING);
674 else
675 ACG::GLState::disable(GL_LIGHTING);
676 if(color_material)
677 ACG::GLState::enable(GL_COLOR_MATERIAL);
678 else
679 ACG::GLState::disable(GL_COLOR_MATERIAL);
680 if(blend)
681 ACG::GLState::enable(GL_BLEND);
682 else
683 ACG::GLState::disable(GL_BLEND);
684 if(depth)
685 ACG::GLState::enable(GL_DEPTH_TEST);
686 else
687 ACG::GLState::disable(GL_DEPTH_TEST);
688 _state.depthFunc(prev_depth);
689 if(cullFace)
690 ACG::GLState::enable(GL_CULL_FACE);
691 else
692 ACG::GLState::disable(GL_CULL_FACE);
693 ACG::GLState::cullFace(cullFaceMode);
694 if(texturing)
695 ACG::GLState::enable(GL_TEXTURE_2D);
696 else
697 ACG::GLState::disable(GL_TEXTURE_2D);
698 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texmode);
699 _state.set_color(oldColor);
700
701 _state.set_twosided_lighting(lightModel);
702
703 if (clientStateEnabledVertexArray)
704 GLState::enableClientState(GL_VERTEX_ARRAY);
705 else
706 GLState::disableClientState(GL_VERTEX_ARRAY);
707
708 if (clientStateEnabledColorArray)
709 GLState::enableClientState(GL_COLOR_ARRAY);
710 else
711 GLState::disableClientState(GL_COLOR_ARRAY);
712
713 if (clientStateEnabledNormalArray)
714 GLState::enableClientState(GL_NORMAL_ARRAY);
715 else
716 GLState::disableClientState(GL_NORMAL_ARRAY);
717
718 if (clientStateEnabledTexCoordArray)
719 GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
720 else
721 GLState::disableClientState(GL_TEXTURE_COORD_ARRAY);
722
723 }
724
725
726
727 template<class VolumeMeshT>
728 void VolumeMeshNodeT<VolumeMeshT>::getCellRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
729 {
730 RenderObject ro;
731 ro.initFromState(&_state);
732
733 ro.debugName = "VolumeMeshNodeCells";
734
735 //Todo: use DrawModeProperties
736
737 // reset renderobject
738 ro.depthTest = true;
739 ro.depthWrite = true;
740 ro.depthFunc = GL_LESS;
741 ro.setMaterial(_mat);
742
743 ro.shaderDesc.clearTextures();
744
745 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
746
747 ro.depthRange = Vec2f(0.01f, 1.0f);
748
749 if (_drawMode & (drawModes_.cellsColoredPerCell | drawModes_.cellsColoredPerFace | drawModes_.cellsColoredPerHalfface | drawModes_.cellsColoredPerVertex))
750 {
751 ro.shaderDesc.vertexColors = true;
752 ro.shaderDesc.numLights = -1;
753 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
754
755 }
756 else if (_drawMode & drawModes_.cellsSmoothShaded)
757 {
758 ro.shaderDesc.numLights = 0;
759 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
760 }
761 else if (_drawMode & drawModes_.cellsFlatShaded)
762 {
763 ro.shaderDesc.numLights = 0;
764 ro.shaderDesc.shadeMode = SG_SHADE_FLAT;
765 }
766 else if (_drawMode & drawModes_.cellsTransparent)
767 {
768 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
769 ro.shaderDesc.numLights = -1;
770 ro.depthTest = false;
771
772 ro.diffuse = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
773 ro.ambient = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
774 ro.specular = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
775 ro.emissive = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
776
777 ro.alpha = translucency_factor_;
778 ro.blending = true;
779 ro.blendDest = GL_ONE_MINUS_SRC_ALPHA;
780 ro.blendSrc = GL_SRC_ALPHA;
781 }
782
783 cellsBufferManager_.setOptionsFromDrawMode(_drawMode);
784 ro.vertexBuffer = cellsBufferManager_.getBuffer();
785 ro.vertexDecl = cellsBufferManager_.getVertexDeclaration();
786
787 ro.glDrawArrays(GL_TRIANGLES, 0, cellsBufferManager_.getNumOfVertices());
788 _renderer->addRenderObject(&ro);
789 }
790
791 template<class VolumeMeshT>
792 void VolumeMeshNodeT<VolumeMeshT>::getFaceRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
793 {
794 RenderObject ro;
795 ro.initFromState(&_state);
796
797 ro.debugName = "VolumeMeshNodeFaces";
798
799 //Todo: use DrawModeProperties
800
801 // reset renderobject
802 ro.depthTest = true;
803 ro.depthWrite = true;
804 ro.depthFunc = GL_LESS;
805 ro.setMaterial(_mat);
806
807 ro.shaderDesc.clearTextures();
808
809 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
810
811 ro.depthRange = Vec2f(0.01f, 1.0f);
812
813 facesBufferManager_.setOptionsFromDrawMode(_drawMode);
814
815
816 if ((_drawMode & drawModes_.faceBasedDrawModes) || boundary_only_)
817 ro.culling = false;
818 else
819 ro.culling = true;
820
821 if (_drawMode & (drawModes_.hiddenLineBackgroundFaces))
822 {
823 ro.shaderDesc.numLights = -1;
824 ro.shaderDesc.shadeMode = SG_SHADE_FLAT;
825
826 ro.shaderDesc.vertexColors = false;
827
828 ro.diffuse = ACG::Vec3f(_state.clear_color()[0],_state.clear_color()[1],_state.clear_color()[2]);
829 ro.ambient = ACG::Vec3f(_state.clear_color()[0],_state.clear_color()[1],_state.clear_color()[2]);
830 ro.specular = ACG::Vec3f(_state.clear_color()[0],_state.clear_color()[1],_state.clear_color()[2]);
831 ro.emissive = ACG::Vec3f(_state.clear_color()[0],_state.clear_color()[1],_state.clear_color()[2]);
832 }
833 else if (_drawMode & (drawModes_.facesColoredPerFace | drawModes_.facesColoredPerVertex
834 | drawModes_.halffacesColoredPerHalfface | drawModes_.halffacesColoredPerVertex ))
835 {
836 ro.shaderDesc.vertexColors = true;
837 ro.shaderDesc.numLights = -1;
838 ro.shaderDesc.shadeMode = SG_SHADE_GOURAUD;
839 }
840 else
841 {
842 ro.shaderDesc.numLights = 0;
843 ro.shaderDesc.vertexColors = false;
844 }
845
846 ro.vertexBuffer = facesBufferManager_.getBuffer();
847 ro.vertexDecl = facesBufferManager_.getVertexDeclaration();
848
849 ro.glDrawArrays(GL_TRIANGLES, 0, facesBufferManager_.getNumOfVertices());
850 _renderer->addRenderObject(&ro);
851 }
852
853 template<class VolumeMeshT>
854 void VolumeMeshNodeT<VolumeMeshT>::getEdgeRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
855 {
856 RenderObject ro;
857 ro.initFromState(&_state);
858
859 ro.debugName = "VolumeMeshNodeEdges";
860
861 //Todo: use DrawModeProperties
862
863 // reset renderobject
864 ro.depthRange = Vec2f(0.0f, 1.0f);
865 ro.depthTest = true;
866 ro.depthWrite = true;
867 ro.depthFunc = GL_LESS;
868 ro.setMaterial(_mat);
869
870 ro.shaderDesc.clearTextures();
871
872 // no lighting, as there are no normals anyway
873 ro.shaderDesc.shadeMode = SG_SHADE_UNLIT;
874
875 // thick lines
876 if (_mat && _mat->lineWidth() > 1.0f)
877 ro.setupLineRendering(_mat->lineWidth(), ACG::Vec2f(_state.viewport_width(), _state.viewport_height()));
878
879 edgesBufferManager_.setDefaultColor(_state.specular_color());
880 edgesBufferManager_.setOptionsFromDrawMode(_drawMode);
881
882 if (_drawMode & ( drawModes_.edgesColoredPerEdge | drawModes_.halfedgesColoredPerHalfedge |
883 drawModes_.irregularInnerEdges | drawModes_.irregularOuterEdges ))
884 {
885 ro.shaderDesc.vertexColors = true;
886 }
887 else
888 {
889 ro.emissive = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
890 }
891
892 ro.vertexBuffer = edgesBufferManager_.getBuffer();
893 ro.vertexDecl = edgesBufferManager_.getVertexDeclaration();
894
895 ro.glDrawArrays(GL_LINES, 0, edgesBufferManager_.getNumOfVertices());
896 _renderer->addRenderObject(&ro);
897 }
898
899 template<class VolumeMeshT>
900 void VolumeMeshNodeT<VolumeMeshT>::getVertexRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
901 {
902 RenderObject ro;
903 ro.initFromState(&_state);
904
905 ro.debugName = "VolumeMeshNodeVertices";
906
907
908 //Todo: use DrawModeProperties
909
910 // reset renderobject
911 ro.depthRange = Vec2f(0.0f, 1.0f);
912 ro.depthTest = true;
913 ro.depthWrite = true;
914 ro.depthFunc = GL_LESS;
915 ro.setMaterial(_mat);
916
917 ro.shaderDesc.clearTextures();
918
919 // no lighting, as there are no normals anyway
920 ro.shaderDesc.shadeMode = SG_SHADE_UNLIT;
921
922 // draw with point size
923 if (_mat && _mat->pointSize() > 1.0f)
924 ro.setupPointRendering(_mat->pointSize(), ACG::Vec2f(_state.viewport_width(), _state.viewport_height()));
925
926 verticesBufferManager_.setDefaultColor(_state.specular_color());
927 verticesBufferManager_.setOptionsFromDrawMode(_drawMode);
928
929
930 if (_drawMode & ( drawModes_.verticesColored ))
931 ro.shaderDesc.vertexColors = true;
932 else
933 ro.emissive = ACG::Vec3f(_state.specular_color()[0],_state.specular_color()[1],_state.specular_color()[2]);
934
935 ro.vertexBuffer = verticesBufferManager_.getBuffer();
936 ro.vertexDecl = verticesBufferManager_.getVertexDeclaration();
937
938 ro.glDrawArrays(GL_POINTS, 0, verticesBufferManager_.getNumOfVertices());
939 _renderer->addRenderObject(&ro);
940 }
941
942
943
944 template<class VolumeMeshT>
945 void VolumeMeshNodeT<VolumeMeshT>::getSelectionRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
946 {
947 RenderObject ro;
948 ro.initFromState(&_state);
949
950 ro.debugName = "VolumeMeshNodeSelections";
951
952 ro.setMaterial(_mat);
953
954 ro.depthTest = true;
955 ro.depthFunc = GL_LEQUAL;
956
957 ro.shaderDesc.clearTextures();
958 ro.shaderDesc.vertexColors = false;
959 ro.shaderDesc.numLights = -1;
960 ro.shaderDesc.shadeMode = SG_SHADE_UNLIT;
961
962 ro.diffuse = ACG::Vec3f(selection_color_[0],selection_color_[1],selection_color_[2]);
963 ro.ambient = ACG::Vec3f(selection_color_[0],selection_color_[1],selection_color_[2]);
964 ro.specular = ACG::Vec3f(selection_color_[0],selection_color_[1],selection_color_[2]);
965 ro.emissive = ACG::Vec3f(selection_color_[0],selection_color_[1],selection_color_[2]);
966
967 if ((_drawMode & drawModes_.cellBasedDrawModes) && !(_drawMode & drawModes_.vertexBasedDrawModes))
968 vertexSelectionBufferManager_.enableVertexOnCellPrimitives();
969 else
970 vertexSelectionBufferManager_.enableVertexPrimitives();
971
972 if ((_drawMode & (drawModes_.cellBasedDrawModes | drawModes_.edgesOnCells)) && !(_drawMode & (drawModes_.edgeBasedDrawModes & ~drawModes_.edgesOnCells)))
973 edgeSelectionBufferManager_.enableEdgeOnCellPrimitives();
974 else
975 edgeSelectionBufferManager_.enableEdgePrimitives();
976
977 if ((_drawMode & drawModes_.cellBasedDrawModes) && !(_drawMode & (drawModes_.faceBasedDrawModes | drawModes_.halffaceBasedDrawModes)))
978 faceSelectionBufferManager_.enableFaceOnCellPrimitives();
979 else
980 faceSelectionBufferManager_.enableFacePrimitives();
981
982 cellSelectionBufferManager_.enableCellPrimitives();
983
984 ro.depthRange = Vec2f(0.0f,1.0f);
985
986 ro.vertexBuffer = vertexSelectionBufferManager_.getBuffer();
987 ro.vertexDecl = vertexSelectionBufferManager_.getVertexDeclaration();
988 ro.glDrawArrays(GL_POINTS, 0, vertexSelectionBufferManager_.getNumOfVertices());
989 if (vertexSelectionBufferManager_.getNumOfVertices())
990 {
991 ro.debugName = "VolumeMeshNode.VertexSelections";
992 ro.setupPointRendering(_state.point_size(), ACG::Vec2f(_state.viewport_width(), _state.viewport_height()));
993 _renderer->addRenderObject(&ro);
994
995 // reset shader templates
996 ro.shaderDesc.vertexTemplateFile = "";
997 ro.shaderDesc.geometryTemplateFile = "";
998 ro.shaderDesc.fragmentTemplateFile = "";
999 }
1000
1001 ro.vertexBuffer = edgeSelectionBufferManager_.getBuffer();
1002 ro.vertexDecl = edgeSelectionBufferManager_.getVertexDeclaration();
1003 ro.glDrawArrays(GL_LINES, 0, edgeSelectionBufferManager_.getNumOfVertices());
1004 if (edgeSelectionBufferManager_.getNumOfVertices())
1005 {
1006 ro.debugName = "VolumeMeshNode.EdgeSelections";
1007
1008 ro.setupLineRendering(_state.line_width(), ACG::Vec2f(_state.viewport_width(), _state.viewport_height()));
1009 _renderer->addRenderObject(&ro);
1010
1011 // reset shader templates
1012 ro.shaderDesc.vertexTemplateFile = "";
1013 ro.shaderDesc.geometryTemplateFile = "";
1014 ro.shaderDesc.fragmentTemplateFile = "";
1015 }
1016
1017 ro.depthRange = Vec2f(0.01f, 1.0f);
1018
1019 ro.vertexBuffer = faceSelectionBufferManager_.getBuffer();
1020 ro.vertexDecl = faceSelectionBufferManager_.getVertexDeclaration();
1021 ro.glDrawArrays(GL_TRIANGLES, 0, faceSelectionBufferManager_.getNumOfVertices());
1022 if (faceSelectionBufferManager_.getNumOfVertices())
1023 {
1024 ro.debugName = "VolumeMeshNode.FaceSelections";
1025
1026 _renderer->addRenderObject(&ro);
1027 }
1028
1029 ro.vertexBuffer = cellSelectionBufferManager_.getBuffer();
1030 ro.vertexDecl = cellSelectionBufferManager_.getVertexDeclaration();
1031 ro.glDrawArrays(GL_TRIANGLES, 0, cellSelectionBufferManager_.getNumOfVertices());
1032 if (cellSelectionBufferManager_.getNumOfVertices())
1033 {
1034 ro.debugName = "VolumeMeshNode.CellSelections";
1035 _renderer->addRenderObject(&ro);
1036 }
1037
1038
1039 }
1040
1041 template<class VolumeMeshT>
1042 void VolumeMeshNodeT<VolumeMeshT>::getRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
1043 {
1044
1045 DrawModes::DrawMode cellDrawMode = drawModes_.getFirstCellDrawMode(_drawMode);
1046 DrawModes::DrawMode faceDrawMode = drawModes_.getFirstFaceDrawMode(_drawMode);
1047 DrawModes::DrawMode edgeDrawMode = drawModes_.getFirstEdgeDrawMode(_drawMode);
1048 DrawModes::DrawMode vertexDrawMode = drawModes_.getFirstVertexDrawMode(_drawMode);
1049
1050 if (!face_normals_calculated_)
1051 {
1052 if ( (cellDrawMode & drawModes_.cellsFlatShaded) ||
1053 (faceDrawMode & (drawModes_.facesFlatShaded | drawModes_.halffacesFlatShaded | drawModes_.facesTexturedShaded)) )
1054 update_face_normals();
1055 }
1056 if (!vertex_normals_calculated_)
1057 {
1058 if ( (cellDrawMode & (drawModes_.cellsSmoothShaded | drawModes_.cellsPhongShaded)) ||
1059 (faceDrawMode & (drawModes_.facesSmoothShaded | drawModes_.halffacesSmoothShaded | drawModes_.facesPhongShaded | drawModes_.halffacesPhongShaded)) )
1060 update_vertex_normals();
1061 }
1062
1063 //the VolumeMeshBufferManager can handle non atomic drawmodes if it consists of one
1064 // edge based draw mode (except edges on cells) and irregular edges
1065 edgeDrawMode |= _drawMode & (drawModes_.irregularInnerEdges | drawModes_.irregularOuterEdges);
1066
1067 if (cellDrawMode)
1068 getCellRenderObjects(_renderer, _state, cellDrawMode, _mat);
1069 else
1070 cellsBufferManager_.free();
1071 if (faceDrawMode)
1072 getFaceRenderObjects(_renderer, _state, faceDrawMode, _mat);
1073 else
1074 facesBufferManager_.free();
1075 if (edgeDrawMode)
1076 getEdgeRenderObjects(_renderer, _state, edgeDrawMode, _mat);
1077 else
1078 edgesBufferManager_.free();
1079 if (vertexDrawMode)
1080 getVertexRenderObjects(_renderer, _state, vertexDrawMode, _mat);
1081 else
1082 verticesBufferManager_.free();
1083
1084 getSelectionRenderObjects(_renderer, _state, cellDrawMode | faceDrawMode | edgeDrawMode | vertexDrawMode, _mat);
1085
1086 }
1087
1088 //----------------------------------------------------------------------------
1089
1090
1091 template<class VolumeMeshT>
1092 void VolumeMeshNodeT<VolumeMeshT>::pick(GLState& _state, PickTarget _target) {
1093
1094 // save state
1095 bool clientStateEnabledVertexArray = GLState::isClientStateEnabled(GL_VERTEX_ARRAY);
1096 bool clientStateEnabledColorArray = GLState::isClientStateEnabled(GL_COLOR_ARRAY);
1097 bool clientStateEnabledNormalArray = GLState::isClientStateEnabled(GL_NORMAL_ARRAY);
1098 bool clientStateEnabledTexCoordArray = GLState::isClientStateEnabled(GL_TEXTURE_COORD_ARRAY);
1099
1100 GLState::depthRange(0.01, 1.0);
1101 if (lastCellDrawMode_)
1102 {
1103 //draw cells so the user cannot pick invisible stuff
1104
1105 GLState::bindBuffer(GL_ARRAY_BUFFER, cellsBufferManager_.getBuffer());
1106 GLState::enableClientState(GL_VERTEX_ARRAY);
1107 GLState::vertexPointer(3, GL_FLOAT, cellsBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1108
1109 GLState::disableClientState(GL_NORMAL_ARRAY);
1110 GLState::disableClientState(GL_COLOR_ARRAY);
1111
1112 Vec4f bc = _state.specular_color();
1113 _state.set_color(Vec4f(0.0,0.0,0.0,0.0));
1114
1115 glDrawArrays(GL_TRIANGLES, 0, cellsBufferManager_.getNumOfVertices());
1116
1117 _state.set_color(bc);
1118 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1119 }
1120
1121 if (lastFaceDrawMode_)
1122 {
1123 //draw faces so the user cannot pick invisible stuff
1124
1125 GLState::bindBuffer(GL_ARRAY_BUFFER, facesBufferManager_.getBuffer());
1126 GLState::enableClientState(GL_VERTEX_ARRAY);
1127 GLState::vertexPointer(3, GL_FLOAT, facesBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1128
1129 GLState::disableClientState(GL_NORMAL_ARRAY);
1130 GLState::disableClientState(GL_COLOR_ARRAY);
1131
1132 Vec4f bc = _state.specular_color();
1133 _state.set_color(Vec4f(0.0,0.0,0.0,0.0));
1134
1135 glDrawArrays(GL_TRIANGLES, 0, facesBufferManager_.getNumOfVertices());
1136
1137 _state.set_color(bc);
1138 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1139 }
1140
1141 GLenum oldDepthFunc = _state.depthFunc();
1142
1143 GLState::depthRange(0.0, 1.0);
1144
1145 _state.set_depthFunc(GL_LEQUAL);
1146
1147 switch (_target) {
1148 case PICK_VERTEX: {
1149 if (lastPickTarget_ != PICK_VERTEX)
1150 vertexPickBufferManager_.invalidateColors();
1151 _state.pick_set_maximum(mesh_.n_vertices());
1152 pickVertices(_state);
1153 break;
1154 }
1155
1156 case PICK_EDGE: {
1157 _state.pick_set_maximum(mesh_.n_edges());
1158 pickEdges(_state, 0);
1159 break;
1160 }
1161
1162 case PICK_FACE: {
1163 _state.pick_set_maximum(mesh_.n_faces());
1164 pickFaces(_state, 0);
1165 break;
1166 }
1167
1168 case PICK_CELL: {
1169 _state.pick_set_maximum(mesh_.n_cells());
1170 pickCells(_state, 0);
1171 break;
1172 }
1173
1174 case PICK_ANYTHING: {
1175 if (lastPickTarget_ != PICK_ANYTHING)
1176 vertexPickBufferManager_.invalidateColors();
1177
1178 int nv = mesh_.n_vertices();
1179 int ne = mesh_.n_edges();
1180 int nf = mesh_.n_faces();
1181 int nc = mesh_.n_cells();
1182
1183 _state.pick_set_maximum(nv + ne + nf + nc);
1184 pickVertices(_state);
1185 pickEdges(_state, nv);
1186 pickFaces(_state, nv + ne);
1187 pickCells(_state, nv + ne + nf);
1188 break;
1189 }
1190
1191 default:
1192 break;
1193 }
1194
1195 _state.set_depthFunc(oldDepthFunc);
1196
1197 lastPickTarget_ = _target;
1198
1199 // restore state
1200 if (clientStateEnabledVertexArray)
1201 GLState::enableClientState(GL_VERTEX_ARRAY);
1202 else
1203 GLState::disableClientState(GL_VERTEX_ARRAY);
1204
1205 if (clientStateEnabledColorArray)
1206 GLState::enableClientState(GL_COLOR_ARRAY);
1207 else
1208 GLState::disableClientState(GL_COLOR_ARRAY);
1209
1210 if (clientStateEnabledNormalArray)
1211 GLState::enableClientState(GL_NORMAL_ARRAY);
1212 else
1213 GLState::disableClientState(GL_NORMAL_ARRAY);
1214
1215 if (clientStateEnabledTexCoordArray)
1216 GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
1217 else
1218 GLState::disableClientState(GL_TEXTURE_COORD_ARRAY);
1219
1220 }
1221
1222 template<class VolumeMeshT>
1223 void VolumeMeshNodeT<VolumeMeshT>::clear_cut_planes()
1224 {
1225 cellsBufferManager_.clearCutPlanes();
1226 facesBufferManager_.clearCutPlanes();
1227 edgesBufferManager_.clearCutPlanes();
1228 verticesBufferManager_.clearCutPlanes();
1229
1230 cellSelectionBufferManager_.clearCutPlanes();
1231 faceSelectionBufferManager_.clearCutPlanes();
1232 edgeSelectionBufferManager_.clearCutPlanes();
1233 vertexSelectionBufferManager_.clearCutPlanes();
1234
1235 cellPickBufferManager_.clearCutPlanes();
1236 facePickBufferManager_.clearCutPlanes();
1237 edgePickBufferManager_.clearCutPlanes();
1238 vertexPickBufferManager_.clearCutPlanes();
1239 }
1240
1241 //----------------------------------------------------------------------------
1242
1243
1244
1245 template<class VolumeMeshT>
1246 void VolumeMeshNodeT<VolumeMeshT>::pickVertices(GLState& _state) {
1247
1248 if (lastDrawMode_ & drawModes_.vertexBasedDrawModes)
1249 vertexPickBufferManager_.enableVertexPrimitives();
1250 else if (lastDrawMode_ & drawModes_.cellBasedDrawModes)
1251 vertexPickBufferManager_.enableVertexOnCellPrimitives();
1252 else
1253 vertexPickBufferManager_.enableVertexPrimitives();
1254
1255 vertexPickBufferManager_.disableNormals();
1256 vertexPickBufferManager_.enablePickColors();
1257
1258
1259
1260 GLState::bindBuffer(GL_ARRAY_BUFFER, vertexPickBufferManager_.getPickBuffer(_state, 0));
1261
1262 GLState::enableClientState(GL_VERTEX_ARRAY);
1263 GLState::vertexPointer(3, GL_FLOAT, vertexPickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1264
1265 GLState::enableClientState(GL_COLOR_ARRAY);
1266 GLState::colorPointer(4, GL_UNSIGNED_BYTE, vertexPickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(vertexPickBufferManager_.getColorOffset()));
1267
1268 GLState::shadeModel(GL_SMOOTH);
1269 GLState::disable(GL_LIGHTING);
1270
1271 float oldPointSize = _state.point_size();
1272 _state.set_point_size(1.5*_state.point_size());
1273
1274 glDrawArrays(GL_POINTS, 0, vertexPickBufferManager_.getNumOfVertices());
1275
1276 _state.set_point_size(oldPointSize);
1277
1278 GLState::disableClientState(GL_COLOR_ARRAY);
1279 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1280
1281 }
1282
1283 //----------------------------------------------------------------------------
1284
1285
1286 template<class VolumeMeshT>
1287 void VolumeMeshNodeT<VolumeMeshT>::pickEdges(GLState& _state, unsigned int _offset) {
1288
1289 if ((lastDrawMode_ & (drawModes_.cellBasedDrawModes | drawModes_.edgesOnCells)) && !(lastDrawMode_ & (drawModes_.edgeBasedDrawModes & ~drawModes_.edgesOnCells)))
1290 edgePickBufferManager_.enableEdgeOnCellPrimitives();
1291 else
1292 edgePickBufferManager_.enableEdgePrimitives();
1293
1294 edgePickBufferManager_.enablePickColors();
1295 edgePickBufferManager_.disableNormals();
1296
1297 GLState::bindBuffer(GL_ARRAY_BUFFER, edgePickBufferManager_.getPickBuffer(_state, _offset));
1298
1299 GLState::enableClientState(GL_VERTEX_ARRAY);
1300 GLState::vertexPointer(3, GL_FLOAT, edgePickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1301
1302 GLState::enableClientState(GL_COLOR_ARRAY);
1303 GLState::colorPointer(4, GL_UNSIGNED_BYTE, edgePickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(edgePickBufferManager_.getColorOffset()));
1304
1305 GLState::shadeModel(GL_SMOOTH);
1306 GLState::disable(GL_LIGHTING);
1307
1308 float oldLineWidth = _state.line_width();
1309 _state.set_line_width(4.0*_state.line_width());
1310
1311 glDrawArrays(GL_LINES, 0, edgePickBufferManager_.getNumOfVertices());
1312
1313 _state.set_line_width(oldLineWidth);
1314
1315 GLState::disableClientState(GL_COLOR_ARRAY);
1316 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1317
1318 }
1319
1320 //----------------------------------------------------------------------------
1321
1322
1323 template<class VolumeMeshT>
1324 void VolumeMeshNodeT<VolumeMeshT>::pickFaces(GLState& _state, unsigned int _offset) {
1325
1326 if (lastDrawMode_ & (drawModes_.faceBasedDrawModes | drawModes_.halffaceBasedDrawModes))
1327 facePickBufferManager_.enableFacePrimitives();
1328 else if (lastDrawMode_ & drawModes_.cellBasedDrawModes)
1329 facePickBufferManager_.enableFaceOnCellPrimitives();
1330 else
1331 facePickBufferManager_.enableFacePrimitives();
1332
1333 facePickBufferManager_.disableNormals();
1334 facePickBufferManager_.enablePickColors();
1335
1336 GLState::bindBuffer(GL_ARRAY_BUFFER, facePickBufferManager_.getPickBuffer(_state, _offset));
1337
1338 GLState::enableClientState(GL_VERTEX_ARRAY);
1339 GLState::vertexPointer(3, GL_FLOAT, facePickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1340
1341 GLState::enableClientState(GL_COLOR_ARRAY);
1342 GLState::colorPointer(4, GL_UNSIGNED_BYTE, facePickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(facePickBufferManager_.getColorOffset()));
1343
1344 GLState::shadeModel(GL_SMOOTH);
1345 GLState::disable(GL_LIGHTING);
1346
1347 glDrawArrays(GL_TRIANGLES, 0, facePickBufferManager_.getNumOfVertices());
1348
1349 GLState::disableClientState(GL_COLOR_ARRAY);
1350 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1351 }
1352
1353 //----------------------------------------------------------------------------
1354
1355
1356 template<class VolumeMeshT>
1357 void VolumeMeshNodeT<VolumeMeshT>::pickCells(GLState& _state, unsigned int _offset) {
1358
1359 cellPickBufferManager_.enablePickColors();
1360 cellPickBufferManager_.disableNormals();
1361 cellPickBufferManager_.enableCellPrimitives();
1362
1363 GLState::bindBuffer(GL_ARRAY_BUFFER, cellPickBufferManager_.getPickBuffer(_state, _offset));
1364
1365 GLState::enableClientState(GL_VERTEX_ARRAY);
1366 GLState::vertexPointer(3, GL_FLOAT, cellPickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(0));
1367
1368 GLState::enableClientState(GL_COLOR_ARRAY);
1369 GLState::colorPointer(4, GL_UNSIGNED_BYTE, cellPickBufferManager_.getStride(), reinterpret_cast<GLvoid*>(cellPickBufferManager_.getColorOffset()));
1370
1371 GLState::shadeModel(GL_SMOOTH);
1372 GLState::disable(GL_LIGHTING);
1373
1374 glDrawArrays(GL_TRIANGLES, 0, cellPickBufferManager_.getNumOfVertices());
1375
1376 GLState::disableClientState(GL_COLOR_ARRAY);
1377 GLState::bindBuffer(GL_ARRAY_BUFFER, 0);
1378 }
1379
1380 //----------------------------------------------------------------------------
1381
1382 template<class VolumeMeshT>
1383 void VolumeMeshNodeT<VolumeMeshT>::update_face_normals()
1384 {
1385 normalAttrib_.update_face_normals();
1386 face_normals_calculated_ = true;
1387 }
1388
1389 //----------------------------------------------------------------------------
1390
1391 template<class VolumeMeshT>
1392 void VolumeMeshNodeT<VolumeMeshT>::update_vertex_normals()
1393 {
1394 normalAttrib_.update_vertex_normals();
1395 vertex_normals_calculated_ = true;
1396 //update_vertex_normals will also compute face normals
1397 face_normals_calculated_ = true;
1398 }
1399
1400 //----------------------------------------------------------------------------
1401
1402 template<class VolumeMeshT>
1403 void VolumeMeshNodeT<VolumeMeshT>::add_cut_plane(const Vec3d& _p, const Vec3d& _n, const Vec3d& _xsize,
1404 const Vec3d& _ysize) {
1405
1406 add_cut_plane(VolumeMeshBufferManager<VolumeMeshT>::Plane(_p, _n, _xsize, _ysize));
1407 }
1408
1409 template<class VolumeMeshT>
1410 void VolumeMeshNodeT<VolumeMeshT>::set_scaling(double _scale)
1411 {
1412 scale_ = _scale;
1413 cellsBufferManager_.setScale(scale_);
1414 edgesBufferManager_.setScale(scale_);
1415 cellSelectionBufferManager_.setScale(scale_);
1416 faceSelectionBufferManager_.setScale(scale_);
1417 edgeSelectionBufferManager_.setScale(scale_);
1418 vertexSelectionBufferManager_.setScale(scale_);
1419 cellPickBufferManager_.setScale(scale_);
1420 facePickBufferManager_.setScale(scale_);
1421 edgePickBufferManager_.setScale(scale_);
1422 vertexPickBufferManager_.setScale(scale_);
1423 }
1424
1425 template<class VolumeMeshT>
1426 void VolumeMeshNodeT<VolumeMeshT>::set_boundary_only(bool _boundary)
1427 {
1428 boundary_only_ = _boundary;
1429
1430 cellsBufferManager_.setBoundaryOnly(_boundary);
1431 facesBufferManager_.setBoundaryOnly(_boundary);
1432 edgesBufferManager_.setBoundaryOnly(_boundary);
1433 verticesBufferManager_.setBoundaryOnly(_boundary);
1434
1435 cellSelectionBufferManager_.setBoundaryOnly(_boundary);
1436 faceSelectionBufferManager_.setBoundaryOnly(_boundary);
1437 edgeSelectionBufferManager_.setBoundaryOnly(_boundary);
1438 vertexSelectionBufferManager_.setBoundaryOnly(_boundary);
1439
1440 cellPickBufferManager_.setBoundaryOnly(_boundary);
1441 facePickBufferManager_.setBoundaryOnly(_boundary);
1442 edgePickBufferManager_.setBoundaryOnly(_boundary);
1443 vertexPickBufferManager_.setScale(_boundary);
1444
1445 }
1446
1447 template<class VolumeMeshT>
1448 void VolumeMeshNodeT<VolumeMeshT>::set_topology_changed(bool _topology_changed)
1449 {
1450 if (_topology_changed)
1451 invalidateAllBuffers();
1452 }
1453
1454 template<class VolumeMeshT>
1455 void VolumeMeshNodeT<VolumeMeshT>::set_geometry_changed(bool _geom_changed)
1456 {
1457 if (_geom_changed)
1458 invalidateAllBuffers();
1459 }
1460
1461 template<class VolumeMeshT>
1462 void VolumeMeshNodeT<VolumeMeshT>::set_color_changed(bool _color_changed)
1463 {
1464 if (_color_changed)
1465 {
1466 cellsBufferManager_.invalidateColors();
1467 facesBufferManager_.invalidateColors();
1468 edgesBufferManager_.invalidateColors();
1469 verticesBufferManager_.invalidateColors();
1470 }
1471
1472 }
1473
1474 template<class VolumeMeshT>
1475 void VolumeMeshNodeT<VolumeMeshT>::set_texture_changed(bool _texture_changed)
1476 {
1477 if (_texture_changed)
1478 {
1479 cellsBufferManager_.invalidateTexCoords();
1480 facesBufferManager_.invalidateTexCoords();
1481 edgesBufferManager_.invalidateTexCoords();
1482 verticesBufferManager_.invalidateTexCoords();
1483 }
1484
1485 }
1486
1487 template<class VolumeMeshT>
1488 void VolumeMeshNodeT<VolumeMeshT>::set_selection_changed(bool _selection_changed)
1489 {
1490 if (_selection_changed)
1491 invalidateAllSelectionBuffers();
1492 }
1493
1494 //----------------------------------------------------------------------------
1495
1496
1497 template<class VolumeMeshT>
1498 void VolumeMeshNodeT<VolumeMeshT>::add_cut_plane(const Plane& _p) {
1499 cellsBufferManager_.addCutPlane(_p);
1500 facesBufferManager_.addCutPlane(_p);
1501 edgesBufferManager_.addCutPlane(_p);
1502 verticesBufferManager_.addCutPlane(_p);
1503
1504 cellSelectionBufferManager_.addCutPlane(_p);
1505 faceSelectionBufferManager_.addCutPlane(_p);
1506 edgeSelectionBufferManager_.addCutPlane(_p);
1507 vertexSelectionBufferManager_.addCutPlane(_p);
1508
1509 cellPickBufferManager_.addCutPlane(_p);
1510 facePickBufferManager_.addCutPlane(_p);
1511 edgePickBufferManager_.addCutPlane(_p);
1512 vertexPickBufferManager_.addCutPlane(_p);
1513 }
1514
1515
1516 //=============================================================================
1517 } // namespace SceneGraph
1518 } // namespace ACG
1519 //=============================================================================
OpenVolumeMesh::ColorAttrib
Definition: ColorAttrib.hh:58
ACG::Vec2f
VectorT< float, 2 > Vec2f
Definition: VectorT.hh:108
ACG::RenderObject::shaderDesc
ShaderGenDesc shaderDesc
Drawmode and other shader params.
Definition: RenderObject.hh:232
ACG::RenderObject::depthRange
Vec2f depthRange
glDepthRange: (znear, zmax)
Definition: RenderObject.hh:256
ACG::GLState::enable
static void enable(GLenum _cap)
replaces glEnable, but supports locking
Definition: GLState.cc:1490
ACG
Namespace providing different geometric functions concerning angles.
Definition: DBSCANT.cc:51
ACG::SceneGraph::ACG::GLState::enable
static void enable(GLenum _cap)
replaces glEnable, but supports locking
ACG::SceneGraph::BaseNode
Definition: BaseNode.hh:135
ACG::SceneGraph::VolumeMeshNodeT::invalidateAllDrawBuffers
void invalidateAllDrawBuffers()
invalidates all buffers used for normal rendering
Definition: VolumeMeshNodeT.cc:564
ACG::GLState::bindBuffer
static void bindBuffer(GLenum _target, GLuint _buffer)
replaces glBindBuffer, supports locking
Definition: GLState.cc:1764
ACG::SceneGraph::PickTarget
PickTarget
What target to use for picking.
Definition: BaseNode.hh:99
OpenVolumeMesh::StatusAttrib
Definition: StatusAttrib.hh:57
ACG::SceneGraph::VolumeMeshNodeT::invalidateAllPickingBuffers
void invalidateAllPickingBuffers()
invalidates all buffers used for picking
Definition: VolumeMeshNodeT.cc:573
ACG::GLState::clear_color
const Vec4f & clear_color() const
get background color
Definition: GLState.hh:924
ACG::SceneGraph::ACG::GLState::disable
static void disable(GLenum _cap)
replaces glDisable, but supports locking
ACG::GLState::pick_set_maximum
bool pick_set_maximum(unsigned int _idx)
Set the maximal number of primitives/components of your object.
Definition: GLState.cc:1047
ACG::SceneGraph::VolumeMeshNodeT::pickEdges
void pickEdges(GLState &_state, unsigned int _offset)
pick edges
Definition: VolumeMeshNodeT.cc:1287
ACG::SceneGraph::PICK_FACE
picks faces (should be implemented for all nodes)
Definition: BaseNode.hh:104
ACG::SceneGraph::PICK_ANYTHING
pick any of the prior targets (should be implemented for all nodes)
Definition: BaseNode.hh:110
ACG::RenderObject
Interface class between scenegraph and renderer.
Definition: RenderObject.hh:105
ACG::SceneGraph::VolumeMeshNodeT::~VolumeMeshNodeT
~VolumeMeshNodeT()
Destructor.
Definition: VolumeMeshNodeT.cc:132
ACG::SceneGraph::VolumeMeshNodeT::update_face_normals
void update_face_normals()
updates face normals
Definition: VolumeMeshNodeT.cc:1383
ACG::RenderObject::blendDest
GLenum blendDest
glBlendFunc: GL_SRC_ALPHA, GL_ZERO, GL_ONE, GL_ONE_MINUS_SRC_ALPHA ...
Definition: RenderObject.hh:254
ACG::RenderObject::setupPointRendering
void setupPointRendering(float _pointSize, const Vec2f &_screenSize)
Setup rendering of circle points.
Definition: RenderObject.cc:467
ACG::GLState::set_depthFunc
void set_depthFunc(const GLenum &_depth_func)
Call glDepthFunc() to actually change the depth comparison function, and store the new value in this ...
Definition: GLState.cc:944
ACG::GLState::colorPointer
static void colorPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glColorPointer, supports locking
Definition: GLState.cc:1906
ACG::RenderObject::vertexBuffer
GLuint vertexBuffer
VBO, IBO ids, ignored if VAO is provided.
Definition: RenderObject.hh:169
ACG::SceneGraph::VolumeMeshNodeT::drawEdges
void drawEdges(GLState &_state, const DrawModes::DrawMode &_drawMode)
renders the edges or halfedges of the mesh
Definition: VolumeMeshNodeT.cc:401
ACG::SceneGraph::VolumeMeshNodeT::drawSelection
void drawSelection(GLState &_state, const DrawModes::DrawMode &_drawMode)
draw selected primitves
Definition: VolumeMeshNodeT.cc:480
ACG::RenderObject::depthFunc
GLenum depthFunc
GL_LESS, GL_LEQUAL, GL_GREATER ..
Definition: RenderObject.hh:247
ACG::RenderObject::initFromState
void initFromState(GLState *_glState)
Initializes a RenderObject instance.
Definition: RenderObject.cc:69
ACG::Vec4f
VectorT< float, 4 > Vec4f
Definition: VectorT.hh:144
ACG::GLState::depthRange
static void depthRange(GLclampd _zNear, GLclampd _zFar)
replaces glDepthRange, supports locking
Definition: GLState.cc:1728
ACG::SceneGraph::ACG::GLState::shadeModel
static void shadeModel(GLenum _mode)
replaces glShadeModel, supports locking
ACG::SceneGraph::VolumeMeshNodeT::VolumeMeshNodeT
VolumeMeshNodeT(const VolumeMesh &_mesh, OpenVolumeMesh::StatusAttrib &_statusAttrib, OpenVolumeMesh::ColorAttrib< Vec4f > &_colorAttrib, OpenVolumeMesh::NormalAttrib< VolumeMesh > &_normalAttrib, OpenVolumeMesh::TexCoordAttrib< Vec2f > &_texcoordAttrib, const MaterialNode *_matNode, BaseNode *_parent=0, std::string _name="<VolumeMeshNode>")
Constructor.
Definition: VolumeMeshNodeT.cc:78
ACG::SceneGraph::VolumeMeshNodeT::boundingBox
void boundingBox(Vec3d &_bbMin, Vec3d &_bbMax)
update bounding box
Definition: VolumeMeshNodeT.cc:139
ACG::SceneGraph::VolumeMeshNodeT::getVertexRenderObjects
void getVertexRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
adds render objects for drawing vertices to the given renderer
Definition: VolumeMeshNodeT.cc:900
VolumeMeshBufferManager
This class creates buffers that can be used to render open volume meshs.
Definition: VolumeMeshBufferManager.hh:69
ACG::GLState
Definition: GLState.hh:220
ACG::SceneGraph::VolumeMeshNodeT::availableDrawModes
DrawModes::DrawMode availableDrawModes() const
static name of this class
Definition: VolumeMeshNodeT.cc:153
ACG::SceneGraph::PICK_VERTEX
picks verices (may not be implemented for all nodes)
Definition: BaseNode.hh:108
ACG::SceneGraph::VolumeMeshNodeT::drawCells
void drawCells(GLState &_state, const DrawModes::DrawMode &_drawMode)
renders the cells of the mesh
Definition: VolumeMeshNodeT.cc:243
ACG::GLState::enableClientState
static void enableClientState(GLenum _cap)
replaces glEnableClientState, supports locking
Definition: GLState.cc:1541
ACG::SceneGraph::PICK_EDGE
picks edges (may not be implemented for all nodes)
Definition: BaseNode.hh:106
ACG::RenderObject::vertexDecl
const VertexDeclaration * vertexDecl
Defines the vertex buffer layout, ignored if VAO is provided.
Definition: RenderObject.hh:215
ACG::IRenderer
Definition: IRenderer.hh:84
ACG::SceneGraph::DrawModes::DrawMode
Specifies a DrawMode.
Definition: DrawModes.hh:294
ACG::GLState::color
const Vec4f & color()
set color
Definition: GLState.hh:919
ACG::GLState::shadeModel
static void shadeModel(GLenum _mode)
replaces glShadeModel, supports locking
Definition: GLState.cc:1700
Plane
Definition: PlaneType.hh:77
ACG::GLState::viewport_width
int viewport_width() const
get viewport width
Definition: GLState.hh:825
ACG::SceneGraph::VolumeMeshNodeT::invalidateAllBuffers
void invalidateAllBuffers()
invalidates all buffers
Definition: VolumeMeshNodeT.cc:556
ACG::GLState::blendFunc
static void blendFunc(GLenum _sfactor, GLenum _dfactor)
replaces glBlendFunc, supports locking
Definition: GLState.hh:314
ACG::GLState::specular_color
const Vec4f & specular_color() const
get specular color
Definition: GLState.hh:944
ACG::GLState::set_twosided_lighting
void set_twosided_lighting(bool _b)
set whether transparent or solid objects should be drawn
Definition: GLState.cc:818
ACG::GLState::set_color
void set_color(const Vec4f &_col)
set color
Definition: GLState.cc:689
ACG::RenderObject::diffuse
Vec3f diffuse
material definitions
Definition: RenderObject.hh:267
ACG::GLState::line_width
float line_width() const
get line width
Definition: GLState.hh:978
ACG::Vec3f
VectorT< float, 3 > Vec3f
Definition: VectorT.hh:125
OpenVolumeMesh::TexCoordAttrib
Definition: TexCoordAttrib.hh:58
ACG::SceneGraph::Material::lineWidth
void lineWidth(float _sz)
set line width (default: 1.0)
Definition: MaterialNode.hh:216
ACG::GLState::isClientStateEnabled
static bool isClientStateEnabled(GLenum _cap)
returns true, if a client state is enabled
Definition: GLState.cc:1584
ACG::GLState::point_size
float point_size() const
get point size
Definition: GLState.hh:973
ACG::GLState::normalPointer
static void normalPointer(GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glNormalPointer, supports locking
Definition: GLState.cc:1884
OpenMesh::VectorT
Definition: Vector11T.hh:83
ACG::ShaderGenDesc::clearTextures
void clearTextures()
disables texture support and removes all texture types
Definition: ShaderGenerator.hh:200
ACG::IRenderer::addRenderObject
virtual void addRenderObject(RenderObject *_renderObject)
Callback for the scenegraph nodes, which send new render objects via this function.
Definition: IRenderer.cc:105
ACG::SceneGraph::VolumeMeshNodeT::getEdgeRenderObjects
void getEdgeRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
adds render objects for drawing edges or halfedges to the given renderer
Definition: VolumeMeshNodeT.cc:854
ACG::SceneGraph::VolumeMeshNodeT::update_vertex_normals
void update_vertex_normals()
updates vertex normals
Definition: VolumeMeshNodeT.cc:1392
VolumeMeshBufferManager::setSelectionOnly
void setSelectionOnly(bool _selectionOnly)
Set whether only selected primitves should be added to the buffer.
Definition: VolumeMeshBufferManager.hh:300
ACG::GLState::disableClientState
static void disableClientState(GLenum _cap)
replaces glDisableClientState, supports locking
Definition: GLState.cc:1555
ACG::SceneGraph::PICK_CELL
picks faces (may not be implemented for all nodes)
Definition: BaseNode.hh:102
ACG::GLState::set_line_width
void set_line_width(float _f)
set line width
Definition: GLState.cc:789
ACG::GLState::vertexPointer
static void vertexPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glVertexPointer, supports locking
Definition: GLState.cc:1862
OpenVolumeMesh::HexahedralMeshTopologyKernel
A data structure basing on PolyhedralMesh with specializations for hexahedra.
Definition: HexahedralMeshTopologyKernel.hh:86
ACG::GLState::disable
static void disable(GLenum _cap)
replaces glDisable, but supports locking
Definition: GLState.cc:1504
ACG::GLState::twosided_lighting
bool twosided_lighting()
get whether transparenet or solid objects should be drawn
Definition: GLState.hh:1043
ACG::SceneGraph::VolumeMeshNodeT
Definition: VolumeMeshNode.hh:87
ACG::SceneGraph::VolumeMeshNodeT::getFaceRenderObjects
void getFaceRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
adds render objects for drawing faces or halffaces to the given renderer
Definition: VolumeMeshNodeT.cc:792
ACG::SceneGraph::ACG::GLState::cullFace
static void cullFace(GLenum _mode)
replaces glCullFace, supports locking
OpenVolumeMesh::VertexHandle
Definition: OpenVolumeMeshHandle.hh:98
ACG::SceneGraph::ACG::GLState::texcoordPointer
static void texcoordPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid *_pointer)
replaces glTexcoordPointer, supports locking
ACG::SceneGraph::VolumeMeshNodeT::getRenderObjects
void getRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
Draws the object deferred.
Definition: VolumeMeshNodeT.cc:1042
ACG::SceneGraph::ACG::GLState::enableClientState
static void enableClientState(GLenum _cap)
replaces glEnableClientState, supports locking
ACG::GLState::depthFunc
const GLenum & depthFunc() const
get glDepthFunc() that is supposed to be active
Definition: GLState.cc:937
ACG::SceneGraph::ACG::GLState::useProgram
static void useProgram(GLuint _program)
replaces glUseProgram, supports locking
ACG::SceneGraph::Material
Definition: MaterialNode.hh:85
ACG::SceneGraph::VolumeMeshNodeT::drawFaces
void drawFaces(GLState &_state, const DrawModes::DrawMode &_drawMode)
renders the faces or halffaces of the mesh
Definition: VolumeMeshNodeT.cc:306
ACG::SceneGraph::ACG::GLState::depthRange
static void depthRange(GLclampd _zNear, GLclampd _zFar)
replaces glDepthRange, supports locking
ACG::SceneGraph::MaterialNode
Definition: MaterialNode.hh:321
ACG::GLState::set_point_size
void set_point_size(float _f)
set point size
Definition: GLState.cc:774
ACG::SceneGraph::VolumeMeshNodeT::drawVertices
void drawVertices(GLState &_state, const DrawModes::DrawMode &_drawMode)
renders the vertices of the mesh
Definition: VolumeMeshNodeT.cc:444
ACG::SceneGraph::VolumeMeshNodeT::pick
void pick(GLState &_state, PickTarget _target)
picking
Definition: VolumeMeshNodeT.cc:1092
ACG::SceneGraph::VolumeMeshNodeT::draw
void draw(GLState &_state, const DrawModes::DrawMode &_drawMode)
draw lines and normals
Definition: VolumeMeshNodeT.cc:591
ACG::GLState::base_color
const Vec4f & base_color() const
get base color (used when lighting is off)
Definition: GLState.hh:929
ACG::SceneGraph::VolumeMeshNodeT::pickVertices
void pickVertices(GLState &_state)
pick vertices
Definition: VolumeMeshNodeT.cc:1246
ACG::GLState::viewport_height
int viewport_height() const
get viewport height
Definition: GLState.hh:827
ACG::SceneGraph::VolumeMeshNodeT::pickFaces
void pickFaces(GLState &_state, unsigned int _offset)
pick faces
Definition: VolumeMeshNodeT.cc:1324
ACG::SceneGraph::VolumeMeshNodeT::pickCells
void pickCells(GLState &_state, unsigned int _offset)
pick cells
Definition: VolumeMeshNodeT.cc:1357
ACG::SceneGraph::VolumeMeshNodeT::getSelectionRenderObjects
void getSelectionRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
adds render objects for drawing selected primitves to the given renderer
Definition: VolumeMeshNodeT.cc:945
OpenVolumeMesh::NormalAttrib< VolumeMesh >
ACG::SceneGraph::VolumeMeshNodeT::invalidateAllSelectionBuffers
void invalidateAllSelectionBuffers()
invalidates all buffers used for rendering selected primitives
Definition: VolumeMeshNodeT.cc:582
ACG::RenderObject::setupLineRendering
void setupLineRendering(float _lineWidth, const Vec2f &_screenSize)
Setup rendering of thick lines.
Definition: RenderObject.cc:447
ACG::SceneGraph::Material::pointSize
void pointSize(float _sz)
set point size (default: 1.0)
Definition: MaterialNode.hh:211
ACG::GLState::cullFace
static void cullFace(GLenum _mode)
replaces glCullFace, supports locking
Definition: GLState.cc:1714
ACG::SceneGraph::VolumeMeshNodeT::getCellRenderObjects
void getCellRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
adds render objects for drawing cells to the given renderer
Definition: VolumeMeshNodeT.cc:728