* Make sure freestyle branch compiles with SCons/msvc9 on Windows. This was joint...
[blender.git] / source / blender / freestyle / intern / app_blender / AppGLWidget.cpp
1
2 //
3 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
4 //   with this source distribution. 
5 //
6 //  This program is free software; you can redistribute it and/or
7 //  modify it under the terms of the GNU General Public License
8 //  as published by the Free Software Foundation; either version 2
9 //  of the License, or (at your option) any later version.
10 //
11 //  This program is distributed in the hope that it will be useful,
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 //  GNU General Public License for more details.
15 //
16 //  You should have received a copy of the GNU General Public License
17 //  along with this program; if not, write to the Free Software
18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19 //
20 ///////////////////////////////////////////////////////////////////////////////
21
22 #include <iostream>
23 #include "../stroke/Canvas.h"
24 #include "AppGLWidget.h"
25 #include "../scene_graph/NodeLight.h"
26 #include "../rendering/GLRenderer.h"
27 #include "../rendering/GLSelectRenderer.h"
28 #include "../rendering/GLBBoxRenderer.h"
29 #include "../rendering/GLMonoColorRenderer.h"
30 #include "Controller.h"
31 #include "../view_map/Silhouette.h"
32 #include "../view_map/ViewMap.h"
33 #include "../scene_graph/LineRep.h"
34 #include "../scene_graph/NodeShape.h"
35 #include "../scene_graph/VertexRep.h"
36 #include "AppConfig.h"
37
38 #include "../system/StringUtils.h"
39
40 extern "C" {
41 #include "BLI_blenlib.h"
42 #include "IMB_imbuf.h"
43 #include "IMB_imbuf_types.h"
44 }
45
46 // glut.h must be included last to avoid a conflict with stdlib.h on vc .net 2003 and 2005
47 #ifdef __MACH__
48 # include <GLUT/glut.h>
49 #else
50 # ifdef _WIN32
51 # include <GL/glu.h>
52 # else
53 # include <GL/glut.h>
54 # endif
55 #endif
56
57 GLuint texture = 0;
58
59 bool AppGLWidget::_frontBufferFlag = false;
60 bool AppGLWidget::_backBufferFlag = true;
61
62 AppGLWidget::AppGLWidget(const char *iName)
63 {
64   //soc
65   _camera = new AppGLWidget_Camera;     
66
67   _Fovy        = 30.f;
68   //_SceneDepth = 2.f;
69   _RenderStyle = LINE;
70   //_ModelRootNode->setBBox(BBox<Vec3f>(Vec3f(-10.f, -10.f, -10.f), Vec3f(10.f, 10.f, 10.f)));
71   _ModelRootNode = new NodeDrawingStyle;
72   _SilhouetteRootNode = new NodeDrawingStyle;
73   _DebugRootNode = new NodeDrawingStyle;
74   
75   _RootNode.AddChild(_ModelRootNode);
76   _SilhouetteRootNode->setStyle(DrawingStyle::LINES);
77   _SilhouetteRootNode->setLightingEnabled(false);
78   _SilhouetteRootNode->setLineWidth(2.f);
79   _SilhouetteRootNode->setPointSize(3.f);
80
81   _RootNode.AddChild(_SilhouetteRootNode);
82
83   _DebugRootNode->setStyle(DrawingStyle::LINES);
84   _DebugRootNode->setLightingEnabled(false);
85   _DebugRootNode->setLineWidth(1.f);
86   
87   _RootNode.AddChild(_DebugRootNode);
88
89   _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
90                             _ModelRootNode->bbox().getMin()[1]),
91                       _ModelRootNode->bbox().getMin()[2]);
92   _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
93                             _ModelRootNode->bbox().getMax()[1]),
94                       _ModelRootNode->bbox().getMax()[2]);
95
96   _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
97   _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
98
99   _camera->setZNearCoefficient(0.1);
100
101   // 2D Scene
102   //  _pFENode = new NodeDrawingStyle;
103   //  _pFENode->setStyle(DrawingStyle::LINES);
104   //  _pFENode->setLightingEnabled(false);
105   //  _pFENode->setLineWidth(1.f);
106   //
107   //  _p2DNode.AddChild(_pFENode);
108   //  
109   //  _pVisibleSilhouetteNode = new NodeDrawingStyle;
110   //  _pVisibleSilhouetteNode->setStyle(DrawingStyle::LINES);
111   //  _pVisibleSilhouetteNode->setLightingEnabled(false);
112   //  _pVisibleSilhouetteNode->setLineWidth(3.f);
113   //
114   //  _p2DNode.AddChild(_pVisibleSilhouetteNode);
115   //  
116   _p2DSelectionNode = new NodeDrawingStyle;
117   _p2DSelectionNode->setLightingEnabled(false);
118   _p2DSelectionNode->setStyle(DrawingStyle::LINES);
119   _p2DSelectionNode->setLineWidth(5.f);
120   
121   _p2DNode.AddChild(_p2DSelectionNode);
122
123   _pGLRenderer = new GLRenderer;
124   _pSelectRenderer = new GLSelectRenderer;
125   _pBBoxRenderer = new GLBBoxRenderer;
126   _pMonoColorRenderer = new GLMonoColorRenderer;
127   _pDebugRenderer = new GLDebugRenderer;
128
129   _pMainWindow = NULL;
130   _cameraStateSaved = false;
131   _drawBBox = false;
132   _silhouette = false;
133   _fedges = false;
134   _debug = false;
135   _selection_mode = false;
136   _Draw2DScene = true;
137   _Draw3DScene = false;
138   _drawEnvMap = false;
139   _currentEnvMap = 1;
140   _maxId = 0;
141   _blendFunc = 0;
142
143   const string sep(Config::DIR_SEP);
144   const string filename = Config::Path::getInstance()->getHomeDir() + sep +
145     Config::OPTIONS_DIR + sep + Config::OPTIONS_QGLVIEWER_FILE;
146   setStateFileName(filename);  
147
148   //get camera frame:
149   //qglviewer::Camera * cam = camera();
150   //qglviewer::ManipulatedFrame *  fr = cam->frame() ;
151   
152   //soc _enableupdateSilhouettes = false;
153
154   _captureMovie = false;
155   //  _frontBufferFlag = false;
156   //  _backBufferFlag = true;
157   _record = false;
158
159
160         workingBuffer = GL_BACK; //soc
161
162 }
163
164 AppGLWidget::~AppGLWidget()
165 {
166   int ref = _RootNode.destroy();
167   
168   _Light.destroy();
169   ref = _p2DNode.destroy();
170   
171   if(NULL != _pGLRenderer)
172     {
173       delete _pGLRenderer;
174       _pGLRenderer = NULL;
175     }
176
177   if(NULL != _pSelectRenderer)
178     {
179       delete _pSelectRenderer;
180       _pSelectRenderer = NULL;
181     }
182
183   if(NULL != _pBBoxRenderer)
184     {
185       delete _pBBoxRenderer;
186       _pBBoxRenderer = NULL;
187     }
188
189   if(NULL != _pMonoColorRenderer)
190     {
191       delete _pMonoColorRenderer;
192       _pMonoColorRenderer = NULL;
193     }
194
195   if(NULL != _pDebugRenderer)
196     {
197       delete _pDebugRenderer;
198       _pDebugRenderer = NULL;
199     }
200
201   makeCurrent();
202   //saveToFile(filename);
203 }
204
205
206
207 void AppGLWidget::LoadEnvMap(const char *filename)
208 {
209   GLuint textureId;
210   //sgiImage img;
211   //cout << filename << endl;
212         ImBuf *image = IMB_loadiffname(filename, 0);
213
214   //data = img.read(filename); // tres beau bleu gris mauve!!
215   // allocate a texture name
216   glGenTextures( 1, &textureId );
217   if(textureId > (GLuint) _maxId)
218     _maxId = textureId;
219
220   // select our current texture
221   glBindTexture( GL_TEXTURE_2D, textureId );
222   
223   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
224   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
225   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
226   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
227                    GL_NEAREST);
228
229   glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, image->x, image->y, 0,
230     GL_RGBA, GL_UNSIGNED_BYTE, image->rect );
231 }
232
233 void AppGLWidget::init()
234 {
235   //setShortcut(QGLViewer::EXIT_VIEWER, 0);
236 //  setShortcut(QGLViewer::DISPLAY_Z_BUFFER, 0);
237   //setShortcut(QGLViewer::STEREO, 0);
238   //setShortcut(QGLViewer::ANIMATION, 0);
239   //setShortcut(QGLViewer::EDIT_CAMERA, 0);
240
241   //restoreStateFromFile();
242
243   //trackball().fitBBox(_ModelRootNode->bbox().getMin(), _ModelRootNode->bbox().getMax(), _Fovy);
244
245    glClearColor(1,1,1,0);
246    glShadeModel(GL_SMOOTH);
247   
248    glCullFace(GL_BACK);
249    glEnable(GL_CULL_FACE);
250    glEnable(GL_DEPTH_TEST);
251
252    // open and read texture data
253    Config::Path * cpath = Config::Path::getInstance();
254    string envmapDir = cpath->getEnvMapDir();
255         LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray00.png")).c_str() );
256    //LoadEnvMap(Config::ENV_MAP_DIR + "gray01.bmp");
257    LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray02.png")).c_str() );
258    LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray03.png")).c_str() );
259    LoadEnvMap( StringUtils::toAscii(envmapDir + string("brown00.png")).c_str() );
260    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
261    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
262
263    // gl settings for Environmental Texturing:
264    glColor3f(1, 1, 1);
265
266    // Use GL auto-computed enviroment texture coordinates
267    //glEnable(GL_TEXTURE_GEN_S);
268    //glEnable(GL_TEXTURE_GEN_T);
269
270    // Bind the texture to use
271    //glBindTexture(GL_TEXTURE_2D,texture);
272    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
273    //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
274    
275    // parametres de melange
276    //glBlendFunc(GL_ONE, GL_ONE);
277    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
278    //glBlendEquatio(GL_FUNC_ADD);
279      
280    //glEnable(GL_BLEND);
281    NodeLight *light = new NodeLight;
282    _Light.AddChild(light);
283
284    // Change QGLViewer's default shortcut for snapshots
285    //setShortcut(QGLViewer::SAVE_SCREENSHOT, Qt::CTRL + Qt::Key_W);
286    //   setShortcutKey (QGLViewer::SAVE_SCREENSHOT, Key_W);
287    //   setShortcutStateKey(QGLViewer::SAVE_SCREENSHOT, ControlButton);
288   
289    cout << "Renderer (GL)    : " << glGetString(GL_RENDERER) << endl
290         << "Vendor (GL)      : " << glGetString(GL_VENDOR) << endl << endl;
291 }
292
293 void AppGLWidget::draw()
294 {
295   if (true == _Draw3DScene)
296     {
297       if (true == _selection_mode) {
298         _pSelectRenderer->setSelectRendering(false);
299         _pSelectRenderer->resetColor();
300         DrawScene(_pSelectRenderer);
301       } else
302         DrawScene(_pGLRenderer);
303   
304       if (true == _silhouette)
305         DrawSilhouette();
306   
307       if (true == _drawBBox) {
308         glPushAttrib(GL_ALL_ATTRIB_BITS);
309         _ModelRootNode->accept(*_pBBoxRenderer);
310         glPopAttrib();
311       }
312
313       if (true == _debug) {
314         glPushAttrib(GL_ALL_ATTRIB_BITS);
315         _DebugRootNode->accept(*_pDebugRenderer);
316         glPopAttrib();
317       }
318     }
319
320   if (true == _Draw2DScene) {
321     Draw2DScene(_pGLRenderer);
322     set3DContext();
323   }
324   if(_record){
325     saveSnapshot(true);
326   }
327 }
328
329 void AppGLWidget::DrawScene(SceneVisitor *iRenderer)
330 {
331   glPushAttrib(GL_ALL_ATTRIB_BITS);
332
333   if(_drawEnvMap)
334   {
335     _ModelRootNode->setLightingEnabled(false);
336     glEnable(GL_COLOR_MATERIAL);
337
338     glEnable(GL_TEXTURE_2D);
339     // Bind the texture to use
340     glBindTexture(GL_TEXTURE_2D,_currentEnvMap); 
341     switch(_blendFunc)
342     {
343     case 0:
344       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
345       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
346       glEnable(GL_BLEND);
347       break;
348     case 1:
349       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) ;
350       glDisable(GL_BLEND);
351       break;
352       //    case 2:
353       //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
354       //      glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
355       //      glEnable(GL_BLEND);
356       //      break;
357       //    case 3:
358       //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
359       //      glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR); 
360       //      glEnable(GL_BLEND);
361       //      break;
362       //    case 4:
363       //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
364       //      glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA); 
365       //      glEnable(GL_BLEND);
366       //      break;
367     default:
368       break;
369     }
370
371     glEnable(GL_TEXTURE_GEN_S);
372     glEnable(GL_TEXTURE_GEN_T);
373   }
374
375   // FIXME
376   //  //_ModelRootNode->setLightingEnabled(true);
377   //  if(_ModelRootNode->style() == DrawingStyle::LINES){
378   //    glPushAttrib(GL_ALL_ATTRIB_BITS);
379   //    //glDisable(GL_COLOR_MATERIAL);
380   //    _ModelRootNode->setStyle(DrawingStyle::FILLED);
381   //    _ModelRootNode->setLightingEnabled(true);
382   //    _ModelRootNode->accept(*iRenderer);  
383   //    _ModelRootNode->setStyle(DrawingStyle::LINES);
384   //    _ModelRootNode->setLightingEnabled(false);
385   //    _ModelRootNode->accept(*iRenderer);  
386   //    glPopAttrib();
387   //  }
388   //  else
389   _ModelRootNode->accept(*iRenderer);
390
391   glDisable(GL_TEXTURE_GEN_S);
392   glDisable(GL_TEXTURE_GEN_T);
393   glDisable(GL_TEXTURE_2D);
394   glDisable(GL_COLOR_MATERIAL);
395   _ModelRootNode->setLightingEnabled(true);
396
397   if(_fedges == true)
398     _SilhouetteRootNode->accept(*iRenderer);
399
400   // FIXME: deprecated
401 //   if(_debug == true)
402 //     _DebugRootNode->accept(*iRenderer);
403   
404   glPopAttrib();
405 }
406
407 void AppGLWidget::prepareCanvas()
408 {
409   makeCurrent();
410   glPushAttrib(GL_ALL_ATTRIB_BITS);
411
412   // if(_frontBufferFlag){
413   //   if(_backBufferFlag)
414   //     glDrawBuffer(GL_FRONT_AND_BACK);
415   //   else
416   //     glDrawBuffer(GL_FRONT);
417   // }
418   // else if(_backBufferFlag)
419   //   glDrawBuffer(GL_BACK);
420         //glDrawBuffer( workingBuffer ); //soc
421
422   // Projection Matrix
423   //==================
424   glMatrixMode(GL_PROJECTION);
425   glLoadIdentity();
426   
427   glOrtho(0,width(), 0, height(), -1.0, 1.0);
428   
429   //Modelview Matrix
430   //================
431   glMatrixMode(GL_MODELVIEW);
432   glLoadIdentity();
433 }
434
435 void AppGLWidget::releaseCanvas()
436 {
437   makeCurrent();
438   //glDrawBuffer( workingBuffer ); //soc
439   glPopAttrib();
440 }
441
442 void AppGLWidget::Draw2DScene(SceneVisitor *iRenderer)
443 {
444   static bool first = 1;
445   glPushAttrib(GL_ALL_ATTRIB_BITS);
446
447 //    // Projection Matrix
448 //    //==================
449   glMatrixMode(GL_PROJECTION);
450   glLoadIdentity();
451   glOrtho(0,width(), 0, height(), -1.0, 1.0);
452
453 //    //Modelview Matrix
454 //    //================
455   glMatrixMode(GL_MODELVIEW);
456   glLoadIdentity();
457
458   //  glBegin(GL_LINE_LOOP);
459   //  glVertex2f(0,0);
460   //  glVertex2f(100,0);
461   //  glVertex2f(100,100);
462   //  glVertex2f(0,100);
463   //  glEnd();
464
465   //glDrawBuffer(GL_FRONT_AND_BACK);
466   // Draw visible silhouette
467   //_pVisibleSilhouetteNode->Render(iRenderer);
468   Canvas * canvas = Canvas::getInstance();
469   if((canvas) && (!canvas->isEmpty()))
470   {
471     if (first)
472     {
473       canvas->init();
474       first = false;
475     }
476     canvas->Render(canvas->renderer());
477   }
478   
479   glLoadIdentity();
480   //  glColor3f(0.f,1.f,0.f);
481   //  glLineWidth(5.f);
482   //glPolygonOffset(0.5f, 0.5f);
483   glPushAttrib(GL_DEPTH_BUFFER_BIT);
484   glDisable(GL_DEPTH_TEST);
485   _p2DSelectionNode->accept(*iRenderer);
486   glPopAttrib();
487   // Draw Feature edges
488   //  if(_fedges == true)
489   //  {
490   //    _pFENode->Render(iRenderer);
491   //  }
492  
493   glPopAttrib();
494 }
495
496 void AppGLWidget::DrawSilhouette()
497 {
498   glPushAttrib(GL_ALL_ATTRIB_BITS);
499   
500   glDepthFunc(GL_LESS);
501   glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
502   DrawScene(_pMonoColorRenderer);
503
504   glCullFace(GL_FRONT);
505   glDepthFunc(GL_LEQUAL);
506   glEnable(GL_POLYGON_OFFSET_FILL);
507   glLineWidth(3.0);
508   //glPolygonOffset(10.f, 10.f);
509   glPolygonOffset(0.5f, 0.5f);
510  
511   glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
512   _pMonoColorRenderer->setColor(0.f, 0.f, 0.f);
513   DrawScene(_pMonoColorRenderer);
514
515   //Restore old context
516   glPopAttrib();
517
518 }
519
520 void AppGLWidget::ReInitRenderers()
521 {
522   // Debug Renderer
523   if(NULL != _pDebugRenderer)
524     _pDebugRenderer->ReInit(rabs(_ModelRootNode->bbox().getMax()[1] -
525                                  _ModelRootNode->bbox().getMin()[1]));
526 }
527
528 void AppGLWidget::setFrontBufferFlag(bool iBool){
529   _frontBufferFlag = iBool;
530 }
531 bool AppGLWidget::getFrontBufferFlag() {
532   return _frontBufferFlag;
533 }
534 void AppGLWidget::setBackBufferFlag(bool iBool){
535   _backBufferFlag = iBool;
536 }
537 bool AppGLWidget::getBackBufferFlag() {
538   return _backBufferFlag;
539 }
540
541 //void AppGLWidget::DrawLines()
542 //{
543 //  //Antialiasing:
544 //  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
545 //  glEnable(GL_BLEND);
546 //  glEnable(GL_LINE_SMOOTH);
547 //  glPolygonMode(GL_FRONT, GL_LINE);
548 //
549 //  glColor3f(0.f, 0.f, 0.f);
550 //  glLineWidth(2.f);
551 //
552 //  DrawScene();
553 //}
554 //
555 //void AppGLWidget::DrawSurfacic()
556 //{
557 //  glPolygonMode(GL_FRONT, GL_FILL);
558 //  glShadeModel(GL_SMOOTH);
559 //  
560 //  glEnable(GL_LIGHTING);
561 //  glEnable(GL_LIGHT0);
562 //
563 //  
564 //  GLreal diffuseV[] = {0.5, 0.7, 0.5, 1.0};
565 //  glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseV);
566 //
567 //  //glColor3f(0.f, 0.f, 0.f);
568 //
569 //  DrawScene();
570 //
571 //  glDisable(GL_LIGHTING);
572 //}
573 //
574 //void AppGLWidget::DrawDepthBuffer()
575 //{
576 //  GLint w = width();
577 //  GLint h = height();
578 //
579 //  glPolygonMode(GL_FRONT, GL_FILL);
580 //  
581 //  //Disable the writing in the frame buffer
582 //  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
583 //
584 //  //This rendering will only fills the depth buffer
585 //  DrawScene();
586 //
587 //  //Re-enable the frame buffer writing
588 //  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
589 //
590 //
591 //  GLreal *zPixels = new real[w*h];
592 //  GLreal *colorPixels = new real[4*w*h];
593 //
594 // // glReadBuffer(GL_FRONT); //in reality: glReadBuffer and glDrawBuffer are both set to GL_BACK
595 //  glReadPixels(0,0,w, h, GL_DEPTH_COMPONENT, GL_real, (GLreal*)zPixels);
596 //
597 //  real *tmpZ = zPixels;
598 //  real *tmpColor = colorPixels;
599 //
600 //  for(int i=0; i<h; i++)
601 //  {
602 //    for(int j=0; j<w; j++)
603 //    {
604 //      //fprintf(test, " %.5f ", pixels[i*w+j]);
605 //      tmpColor[0] = *tmpZ;
606 //      tmpColor[1] = *tmpZ;
607 //      tmpColor[2] = *tmpZ;
608 //      tmpColor[3] = 1.f;
609 //
610 //      tmpColor += 4;
611 //      tmpZ++;
612 //    }
613 //  }
614 //  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
615 // // glDrawBuffer(GL_FRONT_AND_BACK);
616 //  //glRasterPos2i(0, 0);
617 //  //glLoadIdentity();
618 //  glDrawPixels(w, h, GL_RGBA, GL_real, (GLreal *)colorPixels);
619 //    
620 //  delete [] zPixels;
621 //  delete [] colorPixels;  
622 //}
623
624
625 //*******************************
626 // COPIED FROM LIBQGLVIEWER
627 //*******************************
628
629         // inherited    
630         //Updates the display. Do not call draw() directly, use this method instead. 
631         void AppGLWidget::updateGL() {}
632
633         //Makes this widget's rendering context the current OpenGL rendering context. Useful with several viewers
634         void AppGLWidget::makeCurrent() { }
635
636         // not-inherited
637          void AppGLWidget::setStateFileName(const string& name) { stateFileName_ = name; };
638         void AppGLWidget::saveSnapshot(bool b) {}