0024394: Visualization - implement more general way for rendering of immediate objects
[occt.git] / src / OpenGl / OpenGl_Workspace.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_GlCore15.hxx>
17
18 #include <InterfaceGraphic.hxx>
19
20 #include <OpenGl_AspectLine.hxx>
21 #include <OpenGl_AspectFace.hxx>
22 #include <OpenGl_AspectMarker.hxx>
23 #include <OpenGl_AspectText.hxx>
24 #include <OpenGl_Context.hxx>
25 #include <OpenGl_Element.hxx>
26 #include <OpenGl_FrameBuffer.hxx>
27 #include <OpenGl_Structure.hxx>
28 #include <OpenGl_Sampler.hxx>
29 #include <OpenGl_Texture.hxx>
30 #include <OpenGl_Utils.hxx>
31 #include <OpenGl_View.hxx>
32 #include <OpenGl_Workspace.hxx>
33
34 #include <Graphic3d_TextureParams.hxx>
35
36 #if defined(_WIN32) && defined(HAVE_VIDEOCAPTURE)
37   #include <OpenGl_AVIWriter.hxx>
38 #endif
39
40 IMPLEMENT_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
41 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,OpenGl_Window)
42
43 namespace
44 {
45   static const TEL_COLOUR  THE_WHITE_COLOR = { { 1.0f, 1.0f, 1.0f, 1.0f } };
46   static const OpenGl_Vec4 THE_BLACK_COLOR      (0.0f, 0.0f, 0.0f, 1.0f);
47
48   static const OpenGl_AspectLine myDefaultAspectLine;
49   static const OpenGl_AspectFace myDefaultAspectFace;
50   static const OpenGl_AspectMarker myDefaultAspectMarker;
51   static const OpenGl_AspectText myDefaultAspectText;
52
53   static const OpenGl_TextParam myDefaultTextParam =
54   {
55     16, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM
56   };
57
58   static const OpenGl_Matrix myDefaultMatrix =
59   {
60     {{ 1.0F, 0.0F, 0.0F, 0.0F },
61      { 0.0F, 1.0F, 0.0F, 0.0F },
62      { 0.0F, 0.0F, 1.0F, 0.0F },
63      { 0.0F, 0.0F, 0.0F, 1.0F }}
64   };
65
66 };
67
68 // =======================================================================
69 // function : Init
70 // purpose  :
71 // =======================================================================
72 void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
73 {
74   // ambient component
75   if (theProp.color_mask & OPENGL_AMBIENT_MASK)
76   {
77     const float* aSrcAmb = theProp.isphysic ? theProp.ambcol.rgb : theProp.matcol.rgb;
78     Ambient = OpenGl_Vec4 (aSrcAmb[0] * theProp.amb,
79                            aSrcAmb[1] * theProp.amb,
80                            aSrcAmb[2] * theProp.amb,
81                            1.0f);
82   }
83   else
84   {
85     Ambient = THE_BLACK_COLOR;
86   }
87
88   // diffusion component
89   if (theProp.color_mask & OPENGL_DIFFUSE_MASK)
90   {
91     const float* aSrcDif = theProp.isphysic ? theProp.difcol.rgb : theProp.matcol.rgb;
92     Diffuse = OpenGl_Vec4 (aSrcDif[0] * theProp.diff,
93                            aSrcDif[1] * theProp.diff,
94                            aSrcDif[2] * theProp.diff,
95                            1.0f);
96   }
97   else
98   {
99     Diffuse = THE_BLACK_COLOR;
100   }
101
102   // specular component
103   if (theProp.color_mask & OPENGL_SPECULAR_MASK)
104   {
105     const float* aSrcSpe = theProp.isphysic ? theProp.speccol.rgb : THE_WHITE_COLOR.rgb;
106     Specular = OpenGl_Vec4 (aSrcSpe[0] * theProp.spec,
107                             aSrcSpe[1] * theProp.spec,
108                             aSrcSpe[2] * theProp.spec,
109                             1.0f);
110   }
111   else
112   {
113     Specular = THE_BLACK_COLOR;
114   }
115
116   // emission component
117   if (theProp.color_mask & OPENGL_EMISSIVE_MASK)
118   {
119     const float* aSrcEms = theProp.isphysic ? theProp.emscol.rgb : theProp.matcol.rgb;
120     Emission = OpenGl_Vec4 (aSrcEms[0] * theProp.emsv,
121                             aSrcEms[1] * theProp.emsv,
122                             aSrcEms[2] * theProp.emsv,
123                             1.0f);
124   }
125   else
126   {
127     Emission = THE_BLACK_COLOR;
128   }
129
130   ChangeShine()        = theProp.shine;
131   ChangeTransparency() = theProp.trans;
132 }
133
134 // =======================================================================
135 // function : OpenGl_Workspace
136 // purpose  :
137 // =======================================================================
138 OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_GraphicDriver)& theDriver,
139                                     const CALL_DEF_WINDOW&        theCWindow,
140                                     Aspect_RenderingContext       theGContext,
141                                     const Handle(OpenGl_Caps)&    theCaps,
142                                     const Handle(OpenGl_Context)& theShareCtx)
143 : OpenGl_Window (theDriver, theCWindow, theGContext, theCaps, theShareCtx),
144   NamedStatus (0),
145   HighlightColor (&THE_WHITE_COLOR),
146   //
147   myComputeInitStatus (OpenGl_RT_NONE),
148   myIsRaytraceDataValid (Standard_False),
149   myIsRaytraceWarnTextures (Standard_False),
150   myViewModificationStatus (0),
151   myLayersModificationStatus (0),
152   //
153   myRaytraceFilter       (new OpenGl_RaytraceFilter()),
154   myToRedrawGL           (Standard_True),
155   myAntiAliasingMode     (3),
156   myTransientDrawToFront (Standard_True),
157   myBackBufferRestored   (Standard_False),
158   myIsImmediateDrawn     (Standard_False),
159   myUseZBuffer (Standard_False),
160   myUseDepthTest (Standard_True),
161   myUseGLLight (Standard_True),
162   myIsCullingEnabled (Standard_False),
163   myFrameCounter (0),
164   //
165   AspectLine_set (&myDefaultAspectLine),
166   AspectLine_applied (NULL),
167   AspectFace_set (&myDefaultAspectFace),
168   AspectFace_applied (NULL),
169   AspectMarker_set (&myDefaultAspectMarker),
170   AspectMarker_applied (NULL),
171   AspectText_set (&myDefaultAspectText),
172   AspectText_applied (NULL),
173   TextParam_set (&myDefaultTextParam),
174   TextParam_applied (NULL),
175   ViewMatrix_applied (&myDefaultMatrix),
176   StructureMatrix_applied (&myDefaultMatrix),
177   myCullingMode (TelCullUndefined),
178   myModelViewMatrix (myDefaultMatrix),
179   PolygonOffset_applied (THE_DEFAULT_POFFSET)
180 {
181   myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
182
183   if (!myGlContext->GetResource ("OpenGl_LineAttributes", myLineAttribs))
184   {
185     // share and register for release once the resource is no longer used
186     myLineAttribs = new OpenGl_LineAttributes();
187     myGlContext->ShareResource ("OpenGl_LineAttributes", myLineAttribs);
188     myLineAttribs->Init (myGlContext);
189   }
190
191   // General initialization of the context
192
193 #if !defined(GL_ES_VERSION_2_0)
194   // Eviter d'avoir les faces mal orientees en noir.
195   // Pourrait etre utiliser pour detecter les problemes d'orientation
196   glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
197
198   // Optimisation pour le Fog et l'antialiasing
199   glHint (GL_FOG_HINT,            GL_FASTEST);
200   glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
201   glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
202   glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
203 #endif
204
205   // AA mode
206   const char* anAaEnv = ::getenv ("CALL_OPENGL_ANTIALIASING_MODE");
207   if (anAaEnv != NULL)
208   {
209     int v;
210     if (sscanf (anAaEnv, "%d", &v) > 0) myAntiAliasingMode = v;
211   }
212 }
213
214 // =======================================================================
215 // function : SetImmediateModeDrawToFront
216 // purpose  :
217 // =======================================================================
218 Standard_Boolean OpenGl_Workspace::SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer)
219 {
220   const Standard_Boolean aPrevMode = myTransientDrawToFront;
221   myTransientDrawToFront = theDrawToFrontBuffer;
222   return aPrevMode;
223 }
224
225 // =======================================================================
226 // function : ~OpenGl_Workspace
227 // purpose  :
228 // =======================================================================
229 OpenGl_Workspace::~OpenGl_Workspace()
230 {
231   if (!myLineAttribs.IsNull())
232   {
233     myLineAttribs.Nullify();
234     myGlContext->ReleaseResource ("OpenGl_LineAttributes", Standard_True);
235   }
236
237   ReleaseRaytraceResources();
238 }
239
240 // =======================================================================
241 // function : Activate
242 // purpose  :
243 // =======================================================================
244 Standard_Boolean OpenGl_Workspace::Activate()
245 {
246   if (!OpenGl_Window::Activate())
247     return Standard_False;
248
249   ViewMatrix_applied      = &myDefaultMatrix;
250   StructureMatrix_applied = &myDefaultMatrix;
251
252   ResetAppliedAspect();
253
254   return Standard_True;
255 }
256
257 //=======================================================================
258 //function : ResetAppliedAspect
259 //purpose  : Sets default values of GL parameters in accordance with default aspects
260 //=======================================================================
261 void OpenGl_Workspace::ResetAppliedAspect()
262 {
263   NamedStatus           = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
264   HighlightColor        = &THE_WHITE_COLOR;
265   AspectLine_set        = &myDefaultAspectLine;
266   AspectLine_applied    = NULL;
267   AspectFace_set        = &myDefaultAspectFace;
268   AspectFace_applied    = NULL;
269   AspectMarker_set      = &myDefaultAspectMarker;
270   AspectMarker_applied  = NULL;
271   AspectText_set        = &myDefaultAspectText;
272   AspectText_applied    = NULL;
273   TextParam_set         = &myDefaultTextParam;
274   TextParam_applied     = NULL;
275   PolygonOffset_applied = THE_DEFAULT_POFFSET;
276   myCullingMode         = TelCullUndefined;
277
278   AspectLine(Standard_True);
279   AspectFace(Standard_True);
280   AspectMarker(Standard_True);
281   AspectText(Standard_True);
282 }
283
284 // =======================================================================
285 // function : DisableTexture
286 // purpose  :
287 // =======================================================================
288 Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
289 {
290   if (myTextureBound.IsNull())
291   {
292     return myTextureBound;
293   }
294
295 #if !defined(GL_ES_VERSION_2_0)
296   // reset texture matrix because some code may expect it is identity
297   GLint aMatrixMode = GL_TEXTURE;
298   glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
299   glMatrixMode (GL_TEXTURE);
300   glLoadIdentity();
301   glMatrixMode (aMatrixMode);
302 #endif
303
304   myTextureBound->Unbind (myGlContext);
305   switch (myTextureBound->GetTarget())
306   {
307   #if !defined(GL_ES_VERSION_2_0)
308     case GL_TEXTURE_1D:
309     {
310
311       if (myTextureBound->GetParams()->GenMode() != GL_NONE)
312       {
313         glDisable (GL_TEXTURE_GEN_S);
314       }
315       glDisable (GL_TEXTURE_1D);
316       break;
317     }
318   #endif
319     case GL_TEXTURE_2D:
320     {
321     #if !defined(GL_ES_VERSION_2_0)
322       if (myTextureBound->GetParams()->GenMode() != GL_NONE)
323       {
324         glDisable (GL_TEXTURE_GEN_S);
325         glDisable (GL_TEXTURE_GEN_T);
326         if (myTextureBound->GetParams()->GenMode() == Graphic3d_TOTM_SPRITE)
327         {
328           glDisable (GL_POINT_SPRITE);
329         }
330       }
331       glDisable (GL_TEXTURE_2D);
332     #endif
333       break;
334     }
335     default: break;
336   }
337
338   Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
339   myTextureBound.Nullify();
340   return aPrevTexture;
341 }
342
343 // =======================================================================
344 // function : setTextureParams
345 // purpose  :
346 // =======================================================================
347 void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&                theTexture,
348                                          const Handle(Graphic3d_TextureParams)& theParams)
349 {
350   const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
351   if (aParams.IsNull())
352   {
353     return;
354   }
355
356 #if !defined(GL_ES_VERSION_2_0)
357   GLint aMatrixMode = GL_TEXTURE;
358   glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
359
360   // setup texture matrix
361   glMatrixMode (GL_TEXTURE);
362   OpenGl_Mat4 aTextureMat;
363   const Graphic3d_Vec2& aScale = aParams->Scale();
364   const Graphic3d_Vec2& aTrans = aParams->Translation();
365   OpenGl_Utils::Scale     (aTextureMat,  aScale.x(),  aScale.y(), 1.0f);
366   OpenGl_Utils::Translate (aTextureMat, -aTrans.x(), -aTrans.y(), 0.0f);
367   OpenGl_Utils::Rotate    (aTextureMat, -aParams->Rotation(), 0.0f, 0.0f, 1.0f);
368   glLoadMatrixf (aTextureMat);
369
370   GLint anEnvMode = GL_MODULATE; // lighting mode
371   if (!aParams->IsModulate())
372   {
373     anEnvMode = GL_DECAL;
374     if (theTexture->GetFormat() == GL_ALPHA
375      || theTexture->GetFormat() == GL_LUMINANCE)
376     {
377       anEnvMode = GL_REPLACE;
378     }
379   }
380
381   // setup generation of texture coordinates
382   switch (aParams->GenMode())
383   {
384     case Graphic3d_TOTM_OBJECT:
385     {
386       glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
387       glTexGenfv (GL_S, GL_OBJECT_PLANE,     aParams->GenPlaneS().GetData());
388       if (theTexture->GetTarget() != GL_TEXTURE_1D)
389       {
390         glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
391         glTexGenfv (GL_T, GL_OBJECT_PLANE,     aParams->GenPlaneT().GetData());
392       }
393       break;
394     }
395     case Graphic3d_TOTM_SPHERE:
396     {
397       glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
398       if (theTexture->GetTarget() != GL_TEXTURE_1D)
399       {
400         glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
401       }
402       break;
403     }
404     case Graphic3d_TOTM_EYE:
405     {
406       myGlContext->WorldViewState.Push();
407
408       myGlContext->WorldViewState.SetIdentity();
409       myGlContext->ApplyWorldViewMatrix();
410
411       glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
412       glTexGenfv (GL_S, GL_EYE_PLANE,        aParams->GenPlaneS().GetData());
413
414       if (theTexture->GetTarget() != GL_TEXTURE_1D)
415       {
416         glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
417         glTexGenfv (GL_T, GL_EYE_PLANE,        aParams->GenPlaneT().GetData());
418       }
419
420       myGlContext->WorldViewState.Pop();
421
422       break;
423     }
424     case Graphic3d_TOTM_SPRITE:
425     {
426       if (GetGlContext()->core20 != NULL)
427       {
428         glEnable  (GL_POINT_SPRITE);
429         glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
430         anEnvMode = GL_REPLACE;
431         GetGlContext()->core15->glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
432       }
433       break;
434     }
435     case Graphic3d_TOTM_MANUAL:
436     default: break;
437   }
438
439   // setup lighting
440   glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, anEnvMode);
441 #endif
442
443   // get active sampler object to override default texture parameters
444   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
445
446   // setup texture filtering and wrapping
447   //if (theTexture->GetParams() != theParams)
448   const GLenum aFilter   = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
449   const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : myGlContext->TextureWrapClamp();
450   switch (theTexture->GetTarget())
451   {
452   #if !defined(GL_ES_VERSION_2_0)
453     case GL_TEXTURE_1D:
454     {
455       if (aSampler.IsNull() || !aSampler->IsValid())
456       {
457         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
458         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
459         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
460       }
461       else
462       {
463         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
464         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilter);
465         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
466       }
467
468       break;
469     }
470   #endif
471     case GL_TEXTURE_2D:
472     {
473       GLenum aFilterMin = aFilter;
474       if (theTexture->HasMipmaps())
475       {
476         aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
477         if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
478         {
479           aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
480         }
481         else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
482         {
483           aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
484         }
485
486         if (myGlContext->extAnis)
487         {
488           // setup degree of anisotropy filter
489           const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
490           GLint aDegree;
491           switch (aParams->AnisoFilter())
492           {
493             case Graphic3d_LOTA_QUALITY:
494             {
495               aDegree = aMaxDegree;
496               break;
497             }
498             case Graphic3d_LOTA_MIDDLE:
499             {
500               aDegree = (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2);
501               break;
502             }
503             case Graphic3d_LOTA_FAST:
504             {
505               aDegree = 2;
506               break;
507             }
508             case Graphic3d_LOTA_OFF:
509             default:
510             {
511               aDegree = 1;
512               break;
513             }
514           }
515
516           if (aSampler.IsNull() || !aSampler->IsValid())
517           {
518             glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
519           }
520           else
521           {
522             aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
523           }
524         }
525       }
526
527       if (aSampler.IsNull() || !aSampler->IsValid())
528       {
529         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
530         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
531         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
532         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
533       }
534       else
535       {
536         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilterMin);
537         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
538         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
539         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_T,     aWrapMode);
540       }
541
542       break;
543     }
544     default: break;
545   }
546
547   switch (theTexture->GetTarget())
548   {
549   #if !defined(GL_ES_VERSION_2_0)
550     case GL_TEXTURE_1D:
551     {
552       if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
553       {
554         glEnable (GL_TEXTURE_GEN_S);
555       }
556       glEnable (GL_TEXTURE_1D);
557       break;
558     }
559   #endif
560     case GL_TEXTURE_2D:
561     {
562     #if !defined(GL_ES_VERSION_2_0)
563       if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
564       {
565         glEnable (GL_TEXTURE_GEN_S);
566         glEnable (GL_TEXTURE_GEN_T);
567       }
568       glEnable (GL_TEXTURE_2D);
569     #endif
570       break;
571     }
572     default: break;
573   }
574
575 #if !defined(GL_ES_VERSION_2_0)
576   glMatrixMode (aMatrixMode); // turn back active matrix
577 #endif
578   theTexture->SetParams (aParams);
579 }
580
581 // =======================================================================
582 // function : EnableTexture
583 // purpose  :
584 // =======================================================================
585 Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
586                                                         const Handle(Graphic3d_TextureParams)& theParams)
587 {
588   if (theTexture.IsNull() || !theTexture->IsValid())
589   {
590     return DisableTexture();
591   }
592
593   if (myTextureBound == theTexture
594    && (theParams.IsNull() || theParams == theTexture->GetParams()))
595   {
596     // already bound
597     return myTextureBound;
598   }
599
600   Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
601   myTextureBound = theTexture;
602   myTextureBound->Bind (myGlContext);
603   setTextureParams (myTextureBound, theParams);
604
605   // If custom sampler object is available it will be
606   // used for overriding default texture parameters
607   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
608
609   if (!aSampler.IsNull() && aSampler->IsValid())
610   {
611     aSampler->Bind (*myGlContext);
612   }
613
614   return aPrevTexture;
615 }
616
617 // =======================================================================
618 // function : Redraw
619 // purpose  :
620 // =======================================================================
621 void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
622                                const Aspect_CLayer2d& theCUnderLayer,
623                                const Aspect_CLayer2d& theCOverLayer)
624 {
625   if (!Activate())
626   {
627     return;
628   }
629
630   ++myFrameCounter;
631   myIsCullingEnabled = theCView.IsCullingEnabled;
632
633   // release pending GL resources
634   Handle(OpenGl_Context) aGlCtx = GetGlContext();
635   aGlCtx->ReleaseDelayed();
636
637   // fetch OpenGl context state
638   aGlCtx->FetchState();
639
640   Tint toSwap = (aGlCtx->IsRender() && !aGlCtx->caps->buffersNoSwap) ? 1 : 0; // swap buffers
641   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theCView.ptrFBO;
642   if (aFrameBuffer != NULL)
643   {
644     aFrameBuffer->SetupViewport (aGlCtx);
645     toSwap = 0; // no need to swap buffers
646   }
647   else
648   {
649     aGlCtx->core11fwd->glViewport (0, 0, myWidth, myHeight);
650   }
651
652   myToRedrawGL = Standard_True;
653   if (theCView.RenderParams.Method == Graphic3d_RM_RAYTRACING
654    && myComputeInitStatus != OpenGl_RT_FAIL)
655   {
656     if (UpdateRaytraceGeometry (OpenGl_GUM_CHECK) && myIsRaytraceDataValid)
657     {
658       myToRedrawGL = Standard_False;
659
660       // Only non-raytracable structures should be rendered in OpenGL mode.
661       Handle(OpenGl_RenderFilter) aRenderFilter = GetRenderFilter();
662       myRaytraceFilter->SetPrevRenderFilter (aRenderFilter);
663       SetRenderFilter (myRaytraceFilter);
664
665       Standard_Integer aSizeX = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeX() : myWidth;
666       Standard_Integer aSizeY = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeY() : myHeight;
667
668       if (myOpenGlFBO.IsNull())
669       {
670         myOpenGlFBO = new OpenGl_FrameBuffer();
671       }
672       if (myOpenGlFBO->GetVPSizeX() != aSizeX
673        || myOpenGlFBO->GetVPSizeY() != aSizeY)
674       {
675         myOpenGlFBO->Init (aGlCtx, aSizeX, aSizeY);
676       }
677
678       // OverLayer and UnderLayer shouldn't be drawn by OpenGL.
679       // They will be drawn during ray-tracing.
680       Aspect_CLayer2d anEmptyCLayer;
681       anEmptyCLayer.ptrLayer = NULL;
682
683       myOpenGlFBO->BindBuffer (aGlCtx);
684       redraw1 (theCView, anEmptyCLayer, anEmptyCLayer, 0);
685       myOpenGlFBO->UnbindBuffer (aGlCtx);
686
687       const Standard_Boolean isImmediate = myView->HasImmediateStructures();
688       Raytrace (theCView, aSizeX, aSizeY, isImmediate ? 0 : toSwap,
689                 theCOverLayer, theCUnderLayer, aFrameBuffer);
690
691       if (isImmediate)
692       {
693         RedrawImmediate (theCView, theCUnderLayer, theCOverLayer, Standard_True);
694       }
695
696       SetRenderFilter (aRenderFilter);
697
698       theCView.WasRedrawnGL = Standard_False;
699     }
700   }
701
702   if (myToRedrawGL)
703   {
704     // draw entire frame using normal OpenGL pipeline
705     if (aFrameBuffer != NULL)
706     {
707       aFrameBuffer->BindBuffer (aGlCtx);
708     }
709
710     const Standard_Boolean isImmediate = myView->HasImmediateStructures();
711     redraw1 (theCView, theCUnderLayer, theCOverLayer, isImmediate ? 0 : toSwap);
712     if (isImmediate)
713     {
714       RedrawImmediate (theCView, theCUnderLayer, theCOverLayer, Standard_True);
715     }
716
717     theCView.WasRedrawnGL = Standard_True;
718   }
719
720   if (aFrameBuffer != NULL)
721   {
722     aFrameBuffer->UnbindBuffer (aGlCtx);
723     // move back original viewport
724     aGlCtx->core11fwd->glViewport (0, 0, myWidth, myHeight);
725   }
726
727 #if defined(_WIN32) && defined(HAVE_VIDEOCAPTURE)
728   if (OpenGl_AVIWriter_AllowWriting (theCView.DefWindow.XWindow))
729   {
730     GLint params[4];
731     glGetIntegerv (GL_VIEWPORT, params);
732     int nWidth  = params[2] & ~0x7;
733     int nHeight = params[3] & ~0x7;
734
735     const int nBitsPerPixel = 24;
736     GLubyte* aDumpData = new GLubyte[nWidth * nHeight * nBitsPerPixel / 8];
737
738     glPixelStorei (GL_PACK_ALIGNMENT, 1);
739     glReadPixels (0, 0, nWidth, nHeight, GL_BGR_EXT, GL_UNSIGNED_BYTE, aDumpData);
740     OpenGl_AVIWriter_AVIWriter (aDumpData, nWidth, nHeight, nBitsPerPixel);
741     delete[] aDumpData;
742   }
743 #endif
744
745   // reset render mode state
746   aGlCtx->FetchState();
747 }
748
749 // =======================================================================
750 // function : redraw1
751 // purpose  :
752 // =======================================================================
753 void OpenGl_Workspace::redraw1 (const Graphic3d_CView& theCView,
754                                 const Aspect_CLayer2d& theCUnderLayer,
755                                 const Aspect_CLayer2d& theCOverLayer,
756                                 const int              theToSwap)
757 {
758   if (myView.IsNull())
759   {
760     return;
761   }
762
763   // request reset of material
764   NamedStatus |= OPENGL_NS_RESMAT;
765
766   GLbitfield toClear = GL_COLOR_BUFFER_BIT;
767   if (myUseZBuffer)
768   {
769     glDepthFunc (GL_LEQUAL);
770     glDepthMask (GL_TRUE);
771     if (myUseDepthTest)
772     {
773       glEnable (GL_DEPTH_TEST);
774     }
775     else
776     {
777       glDisable (GL_DEPTH_TEST);
778     }
779
780   #if !defined(GL_ES_VERSION_2_0)
781     glClearDepth (1.0);
782   #else
783     glClearDepthf (1.0f);
784   #endif
785     toClear |= GL_DEPTH_BUFFER_BIT;
786   }
787   else
788   {
789     glDisable (GL_DEPTH_TEST);
790   }
791
792   if (!ToRedrawGL())
793   {
794     // set background to black
795     glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
796     toClear |= GL_DEPTH_BUFFER_BIT; //
797   }
798   else
799   {
800     if (NamedStatus & OPENGL_NS_WHITEBACK)
801     {
802         // set background to white
803       glClearColor (1.0f, 1.0f, 1.0f, 1.0f);
804       toClear |= GL_DEPTH_BUFFER_BIT;
805     }
806     else
807     {
808       glClearColor (myBgColor.rgb[0], myBgColor.rgb[1], myBgColor.rgb[2], 0.0f);
809     }
810   }
811   glClear (toClear);
812
813   Handle(OpenGl_Workspace) aWS (this);
814   myView->Render (myPrintContext, aWS, theCView, theCUnderLayer, theCOverLayer, Standard_False);
815
816   // swap the buffers
817   if (theToSwap)
818   {
819     GetGlContext()->SwapBuffers();
820     myBackBufferRestored = Standard_False;
821     myIsImmediateDrawn   = Standard_False;
822   }
823   else
824   {
825     glFlush(); //
826     myBackBufferRestored = Standard_True;//
827     myIsImmediateDrawn   = Standard_False;//
828   }
829 }
830
831 // =======================================================================
832 // function : copyBackToFront
833 // purpose  :
834 // =======================================================================
835 void OpenGl_Workspace::copyBackToFront()
836 {
837 #if !defined(GL_ES_VERSION_2_0)
838
839   OpenGl_Mat4 aProjectMat;
840   OpenGl_Utils::Ortho2D<Standard_ShortReal> (aProjectMat,
841     0.f, static_cast<GLfloat> (myWidth), 0.f, static_cast<GLfloat> (myHeight));
842
843   myGlContext->WorldViewState.Push();
844   myGlContext->ProjectionState.Push();
845
846   myGlContext->WorldViewState.SetIdentity();
847   myGlContext->ProjectionState.SetCurrent (aProjectMat);
848
849   myGlContext->ApplyProjectionMatrix();
850   myGlContext->ApplyWorldViewMatrix();
851
852   DisableFeatures();
853
854   glDrawBuffer (GL_FRONT);
855   glReadBuffer (GL_BACK);
856
857   glRasterPos2i (0, 0);
858   glCopyPixels  (0, 0, myWidth + 1, myHeight + 1, GL_COLOR);
859   //glCopyPixels  (0, 0, myWidth + 1, myHeight + 1, GL_DEPTH);
860
861   EnableFeatures();
862
863   myGlContext->WorldViewState.Pop();
864   myGlContext->ProjectionState.Pop();
865   myGlContext->ApplyProjectionMatrix();
866   glDrawBuffer (GL_BACK);
867
868 #endif
869   myIsImmediateDrawn = Standard_False;
870 }
871
872 // =======================================================================
873 // function : DisplayCallback
874 // purpose  :
875 // =======================================================================
876 void OpenGl_Workspace::DisplayCallback (const Graphic3d_CView& theCView,
877                                         Standard_Integer       theReason)
878 {
879   if (theCView.GDisplayCB == NULL)
880   {
881     return;
882   }
883
884   Aspect_GraphicCallbackStruct aCallData;
885   aCallData.reason    = theReason;
886   aCallData.glContext = GetGlContext();
887   aCallData.wsID      = theCView.WsId;
888   aCallData.viewID    = theCView.ViewId;
889   theCView.GDisplayCB (theCView.DefWindow.XWindow, theCView.GClientData, &aCallData);
890 }
891
892 // =======================================================================
893 // function : RedrawImmediate
894 // purpose  :
895 // =======================================================================
896 void OpenGl_Workspace::RedrawImmediate (const Graphic3d_CView& theCView,
897                                         const Aspect_CLayer2d& theCUnderLayer,
898                                         const Aspect_CLayer2d& theCOverLayer,
899                                         const Standard_Boolean theToForce)
900 {
901   if (!Activate())
902   {
903     return;
904   }
905
906   GLboolean isDoubleBuffer = GL_FALSE;
907 #if !defined(GL_ES_VERSION_2_0)
908   glGetBooleanv (GL_DOUBLEBUFFER, &isDoubleBuffer);
909 #endif
910   if (!myView->HasImmediateStructures())
911   {
912     if (theToForce
913      || !myIsImmediateDrawn)
914     {
915       myIsImmediateDrawn = Standard_False;
916       return;
917     }
918
919     if (myBackBufferRestored
920      && isDoubleBuffer)
921     {
922       copyBackToFront();
923       glFlush();
924     }
925     else
926     {
927       Redraw (theCView, theCUnderLayer, theCOverLayer);
928     }
929     return;
930   }
931
932   if (isDoubleBuffer && myTransientDrawToFront)
933   {
934     if (!myBackBufferRestored)
935     {
936       Redraw (theCView, theCUnderLayer, theCOverLayer);
937       return;
938     }
939     copyBackToFront();
940     MakeFrontBufCurrent();
941   }
942   else
943   {
944     myBackBufferRestored = Standard_False;
945   }
946   myIsImmediateDrawn = Standard_True;
947
948   Handle(OpenGl_Workspace) aWS (this);
949
950   if (myUseZBuffer)
951   {
952     glDepthFunc (GL_LEQUAL);
953     glDepthMask (GL_TRUE);
954     if (myUseDepthTest)
955     {
956       glEnable (GL_DEPTH_TEST);
957     }
958     else
959     {
960       glDisable (GL_DEPTH_TEST);
961     }
962
963   #if !defined(GL_ES_VERSION_2_0)
964     glClearDepth (1.0);
965   #else
966     glClearDepthf (1.0f);
967   #endif
968   }
969   else
970   {
971     glDisable (GL_DEPTH_TEST);
972   }
973
974   myView->Render (myPrintContext, aWS, theCView, theCUnderLayer, theCOverLayer, Standard_True);
975   if (!myView->ImmediateStructures().IsEmpty())
976   {
977     glDisable (GL_DEPTH_TEST);
978   }
979   for (OpenGl_SequenceOfStructure::Iterator anIter (myView->ImmediateStructures());
980        anIter.More(); anIter.Next())
981   {
982     const OpenGl_Structure* aStructure = anIter.Value();
983     if (!aStructure->IsVisible())
984     {
985       continue;
986     }
987
988     aStructure->Render (aWS);
989   }
990
991   if (isDoubleBuffer && myTransientDrawToFront)
992   {
993     glFlush();
994     MakeBackBufCurrent();
995   }
996 }