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   myUseTransparency (Standard_False),
 160   myUseZBuffer (Standard_False),
 161   myUseDepthTest (Standard_True),
 162   myUseGLLight (Standard_True),
 163   myIsCullingEnabled (Standard_False),
 164   myFrameCounter (0),
 165   //
 166   AspectLine_set (&myDefaultAspectLine),
 167   AspectLine_applied (NULL),
 168   AspectFace_set (&myDefaultAspectFace),
 169   AspectFace_applied (NULL),
 170   AspectMarker_set (&myDefaultAspectMarker),
 171   AspectMarker_applied (NULL),
 172   AspectText_set (&myDefaultAspectText),
 173   AspectText_applied (NULL),
 174   TextParam_set (&myDefaultTextParam),
 175   TextParam_applied (NULL),
 176   ViewMatrix_applied (&myDefaultMatrix),
 177   StructureMatrix_applied (&myDefaultMatrix),
 178   myCullingMode (TelCullUndefined),
 179   myModelViewMatrix (myDefaultMatrix),
 180   PolygonOffset_applied (THE_DEFAULT_POFFSET)
 181 {
 182   myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 183
 184   if (!myGlContext->GetResource ("OpenGl_LineAttributes", myLineAttribs))
 185   {
 186     // share and register for release once the resource is no longer used
 187     myLineAttribs = new OpenGl_LineAttributes();
 188     myGlContext->ShareResource ("OpenGl_LineAttributes", myLineAttribs);
 189     myLineAttribs->Init (myGlContext);
 190   }
 191
 192   // General initialization of the context
 193
 194 #if !defined(GL_ES_VERSION_2_0)
 195   // Eviter d'avoir les faces mal orientees en noir.
 196   // Pourrait etre utiliser pour detecter les problemes d'orientation
 197   glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
 198
 199   // Optimisation pour le Fog et l'antialiasing
 200   glHint (GL_FOG_HINT,            GL_FASTEST);
 201   glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
 202   glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
 203   glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
 204 #endif
 205
 206   // AA mode
 207   const char* anAaEnv = ::getenv ("CALL_OPENGL_ANTIALIASING_MODE");
 208   if (anAaEnv != NULL)
 209   {
 210     int v;
 211     if (sscanf (anAaEnv, "%d", &v) > 0) myAntiAliasingMode = v;
 212   }
 213 }
 214
 215 // =======================================================================
 216 // function : SetImmediateModeDrawToFront
 217 // purpose  :
 218 // =======================================================================
 219 Standard_Boolean OpenGl_Workspace::SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer)
 220 {
 221   const Standard_Boolean aPrevMode = myTransientDrawToFront;
 222   myTransientDrawToFront = theDrawToFrontBuffer;
 223   return aPrevMode;
 224 }
 225
 226 // =======================================================================
 227 // function : ~OpenGl_Workspace
 228 // purpose  :
 229 // =======================================================================
 230 OpenGl_Workspace::~OpenGl_Workspace()
 231 {
 232   if (!myLineAttribs.IsNull())
 233   {
 234     myLineAttribs.Nullify();
 235     myGlContext->ReleaseResource ("OpenGl_LineAttributes", Standard_True);
 236   }
 237
 238   ReleaseRaytraceResources();
 239 }
 240
 241 // =======================================================================
 242 // function : Activate
 243 // purpose  :
 244 // =======================================================================
 245 Standard_Boolean OpenGl_Workspace::Activate()
 246 {
 247   if (!OpenGl_Window::Activate())
 248     return Standard_False;
 249
 250   ViewMatrix_applied      = &myDefaultMatrix;
 251   StructureMatrix_applied = &myDefaultMatrix;
 252
 253   ResetAppliedAspect();
 254
 255   return Standard_True;
 256 }
 257
 258 // =======================================================================
 259 // function : UseTransparency
 260 // purpose  : call_togl_transparency
 261 // =======================================================================
 262 void OpenGl_Workspace::UseTransparency (const Standard_Boolean theFlag)
 263 {
 264   myUseTransparency = theFlag;
 265 }
 266
 267 //=======================================================================
 268 //function : ResetAppliedAspect
 269 //purpose  : Sets default values of GL parameters in accordance with default aspects
 270 //=======================================================================
 271 void OpenGl_Workspace::ResetAppliedAspect()
 272 {
 273   NamedStatus           = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
 274   HighlightColor        = &THE_WHITE_COLOR;
 275   AspectLine_set        = &myDefaultAspectLine;
 276   AspectLine_applied    = NULL;
 277   AspectFace_set        = &myDefaultAspectFace;
 278   AspectFace_applied    = NULL;
 279   AspectMarker_set      = &myDefaultAspectMarker;
 280   AspectMarker_applied  = NULL;
 281   AspectText_set        = &myDefaultAspectText;
 282   AspectText_applied    = NULL;
 283   TextParam_set         = &myDefaultTextParam;
 284   TextParam_applied     = NULL;
 285   PolygonOffset_applied = THE_DEFAULT_POFFSET;
 286   myCullingMode         = TelCullUndefined;
 287
 288   AspectLine(Standard_True);
 289   AspectFace(Standard_True);
 290   AspectMarker(Standard_True);
 291   AspectText(Standard_True);
 292 }
 293
 294 // =======================================================================
 295 // function : DisableTexture
 296 // purpose  :
 297 // =======================================================================
 298 Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
 299 {
 300   if (myTextureBound.IsNull())
 301   {
 302     return myTextureBound;
 303   }
 304
 305 #if !defined(GL_ES_VERSION_2_0)
 306   // reset texture matrix because some code may expect it is identity
 307   GLint aMatrixMode = GL_TEXTURE;
 308   glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
 309   glMatrixMode (GL_TEXTURE);
 310   glLoadIdentity();
 311   glMatrixMode (aMatrixMode);
 312 #endif
 313
 314   myTextureBound->Unbind (myGlContext);
 315   switch (myTextureBound->GetTarget())
 316   {
 317   #if !defined(GL_ES_VERSION_2_0)
 318     case GL_TEXTURE_1D:
 319     {
 320
 321       if (myTextureBound->GetParams()->GenMode() != GL_NONE)
 322       {
 323         glDisable (GL_TEXTURE_GEN_S);
 324       }
 325       glDisable (GL_TEXTURE_1D);
 326       break;
 327     }
 328   #endif
 329     case GL_TEXTURE_2D:
 330     {
 331     #if !defined(GL_ES_VERSION_2_0)
 332       if (myTextureBound->GetParams()->GenMode() != GL_NONE)
 333       {
 334         glDisable (GL_TEXTURE_GEN_S);
 335         glDisable (GL_TEXTURE_GEN_T);
 336         if (myTextureBound->GetParams()->GenMode() == Graphic3d_TOTM_SPRITE)
 337         {
 338           glDisable (GL_POINT_SPRITE);
 339         }
 340       }
 341       glDisable (GL_TEXTURE_2D);
 342     #endif
 343       break;
 344     }
 345     default: break;
 346   }
 347
 348   Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
 349   myTextureBound.Nullify();
 350   return aPrevTexture;
 351 }
 352
 353 // =======================================================================
 354 // function : setTextureParams
 355 // purpose  :
 356 // =======================================================================
 357 void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&                theTexture,
 358                                          const Handle(Graphic3d_TextureParams)& theParams)
 359 {
 360   const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
 361   if (aParams.IsNull())
 362   {
 363     return;
 364   }
 365
 366 #if !defined(GL_ES_VERSION_2_0)
 367   GLint aMatrixMode = GL_TEXTURE;
 368   glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
 369
 370   // setup texture matrix
 371   glMatrixMode (GL_TEXTURE);
 372   OpenGl_Mat4 aTextureMat;
 373   const Graphic3d_Vec2& aScale = aParams->Scale();
 374   const Graphic3d_Vec2& aTrans = aParams->Translation();
 375   OpenGl_Utils::Scale     (aTextureMat,  aScale.x(),  aScale.y(), 1.0f);
 376   OpenGl_Utils::Translate (aTextureMat, -aTrans.x(), -aTrans.y(), 0.0f);
 377   OpenGl_Utils::Rotate    (aTextureMat, -aParams->Rotation(), 0.0f, 0.0f, 1.0f);
 378   glLoadMatrixf (aTextureMat);
 379
 380   // setup generation of texture coordinates
 381   switch (aParams->GenMode())
 382   {
 383     case Graphic3d_TOTM_OBJECT:
 384     {
 385       glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
 386       glTexGenfv (GL_S, GL_OBJECT_PLANE,     aParams->GenPlaneS().GetData());
 387       if (theTexture->GetTarget() != GL_TEXTURE_1D)
 388       {
 389         glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
 390         glTexGenfv (GL_T, GL_OBJECT_PLANE,     aParams->GenPlaneT().GetData());
 391       }
 392       break;
 393     }
 394     case Graphic3d_TOTM_SPHERE:
 395     {
 396       glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 397       if (theTexture->GetTarget() != GL_TEXTURE_1D)
 398       {
 399         glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 400       }
 401       break;
 402     }
 403     case Graphic3d_TOTM_EYE:
 404     {
 405       myGlContext->WorldViewState.Push();
 406
 407       myGlContext->WorldViewState.SetIdentity();
 408       myGlContext->ApplyWorldViewMatrix();
 409
 410       glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 411       glTexGenfv (GL_S, GL_EYE_PLANE,        aParams->GenPlaneS().GetData());
 412
 413       if (theTexture->GetTarget() != GL_TEXTURE_1D)
 414       {
 415         glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 416         glTexGenfv (GL_T, GL_EYE_PLANE,        aParams->GenPlaneT().GetData());
 417       }
 418
 419       myGlContext->WorldViewState.Pop();
 420
 421       break;
 422     }
 423     case Graphic3d_TOTM_SPRITE:
 424     {
 425       if (GetGlContext()->core20 != NULL)
 426       {
 427         glEnable  (GL_POINT_SPRITE);
 428         glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
 429         glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 430         GetGlContext()->core15->glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
 431       }
 432       break;
 433     }
 434     case Graphic3d_TOTM_MANUAL:
 435     default: break;
 436   }
 437
 438   // setup lighting
 439   if (aParams->GenMode() != Graphic3d_TOTM_SPRITE)
 440   {
 441     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, aParams->IsModulate() ? GL_MODULATE : GL_DECAL);
 442   }
 443 #endif
 444
 445   // get active sampler object to override default texture parameters
 446   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
 447
 448   // setup texture filtering and wrapping
 449   //if (theTexture->GetParams() != theParams)
 450   const GLenum aFilter   = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
 451   const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : myGlContext->TextureWrapClamp();
 452   switch (theTexture->GetTarget())
 453   {
 454   #if !defined(GL_ES_VERSION_2_0)
 455     case GL_TEXTURE_1D:
 456     {
 457       if (aSampler.IsNull() || !aSampler->IsValid())
 458       {
 459         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
 460         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
 461         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
 462       }
 463       else
 464       {
 465         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
 466         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilter);
 467         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
 468       }
 469
 470       break;
 471     }
 472   #endif
 473     case GL_TEXTURE_2D:
 474     {
 475       GLenum aFilterMin = aFilter;
 476       if (theTexture->HasMipmaps())
 477       {
 478         aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
 479         if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
 480         {
 481           aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
 482         }
 483         else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
 484         {
 485           aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
 486         }
 487
 488         if (myGlContext->extAnis)
 489         {
 490           // setup degree of anisotropy filter
 491           const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
 492           GLint aDegree;
 493           switch (aParams->AnisoFilter())
 494           {
 495             case Graphic3d_LOTA_QUALITY:
 496             {
 497               aDegree = aMaxDegree;
 498               break;
 499             }
 500             case Graphic3d_LOTA_MIDDLE:
 501             {
 502               aDegree = (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2);
 503               break;
 504             }
 505             case Graphic3d_LOTA_FAST:
 506             {
 507               aDegree = 2;
 508               break;
 509             }
 510             case Graphic3d_LOTA_OFF:
 511             default:
 512             {
 513               aDegree = 1;
 514               break;
 515             }
 516           }
 517
 518           if (aSampler.IsNull() || !aSampler->IsValid())
 519           {
 520             glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
 521           }
 522           else
 523           {
 524             aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
 525           }
 526         }
 527       }
 528
 529       if (aSampler.IsNull() || !aSampler->IsValid())
 530       {
 531         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
 532         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
 533         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
 534         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
 535       }
 536       else
 537       {
 538         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilterMin);
 539         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
 540         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
 541         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_T,     aWrapMode);
 542       }
 543
 544       break;
 545     }
 546     default: break;
 547   }
 548
 549   switch (theTexture->GetTarget())
 550   {
 551   #if !defined(GL_ES_VERSION_2_0)
 552     case GL_TEXTURE_1D:
 553     {
 554       if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
 555       {
 556         glEnable (GL_TEXTURE_GEN_S);
 557       }
 558       glEnable (GL_TEXTURE_1D);
 559       break;
 560     }
 561   #endif
 562     case GL_TEXTURE_2D:
 563     {
 564     #if !defined(GL_ES_VERSION_2_0)
 565       if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
 566       {
 567         glEnable (GL_TEXTURE_GEN_S);
 568         glEnable (GL_TEXTURE_GEN_T);
 569       }
 570       glEnable (GL_TEXTURE_2D);
 571     #endif
 572       break;
 573     }
 574     default: break;
 575   }
 576
 577 #if !defined(GL_ES_VERSION_2_0)
 578   glMatrixMode (aMatrixMode); // turn back active matrix
 579 #endif
 580   theTexture->SetParams (aParams);
 581 }
 582
 583 // =======================================================================
 584 // function : EnableTexture
 585 // purpose  :
 586 // =======================================================================
 587 Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
 588                                                         const Handle(Graphic3d_TextureParams)& theParams)
 589 {
 590   if (theTexture.IsNull() || !theTexture->IsValid())
 591   {
 592     return DisableTexture();
 593   }
 594
 595   if (myTextureBound == theTexture
 596    && (theParams.IsNull() || theParams == theTexture->GetParams()))
 597   {
 598     // already bound
 599     return myTextureBound;
 600   }
 601
 602   Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
 603   myTextureBound = theTexture;
 604   myTextureBound->Bind (myGlContext);
 605   setTextureParams (myTextureBound, theParams);
 606
 607   // If custom sampler object is available it will be
 608   // used for overriding default texture parameters
 609   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
 610
 611   if (!aSampler.IsNull() && aSampler->IsValid())
 612   {
 613     aSampler->Bind (*myGlContext);
 614   }
 615
 616   return aPrevTexture;
 617 }
 618
 619 // =======================================================================
 620 // function : Redraw
 621 // purpose  :
 622 // =======================================================================
 623 void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
 624                                const Aspect_CLayer2d& theCUnderLayer,
 625                                const Aspect_CLayer2d& theCOverLayer)
 626 {
 627   if (!Activate())
 628   {
 629     return;
 630   }
 631
 632   ++myFrameCounter;
 633   myIsCullingEnabled = theCView.IsCullingEnabled;
 634
 635   // release pending GL resources
 636   Handle(OpenGl_Context) aGlCtx = GetGlContext();
 637   aGlCtx->ReleaseDelayed();
 638
 639   // fetch OpenGl context state
 640   aGlCtx->FetchState();
 641
 642   Tint toSwap = (aGlCtx->IsRender() && !aGlCtx->caps->buffersNoSwap) ? 1 : 0; // swap buffers
 643   GLint aViewPortBack[4];
 644   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theCView.ptrFBO;
 645   if (aFrameBuffer != NULL)
 646   {
 647     glGetIntegerv (GL_VIEWPORT, aViewPortBack);
 648     aFrameBuffer->SetupViewport (aGlCtx);
 649     toSwap = 0; // no need to swap buffers
 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->ImmediateStructures().IsEmpty();
 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->ImmediateStructures().IsEmpty();
 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     glViewport (aViewPortBack[0], aViewPortBack[1], aViewPortBack[2], aViewPortBack[3]);
 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);
 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
 860   EnableFeatures();
 861
 862   myGlContext->WorldViewState.Pop();
 863   myGlContext->ProjectionState.Pop();
 864   myGlContext->ApplyProjectionMatrix();
 865   glDrawBuffer (GL_BACK);
 866
 867 #endif
 868   myIsImmediateDrawn = Standard_False;
 869 }
 870
 871 // =======================================================================
 872 // function : DisplayCallback
 873 // purpose  :
 874 // =======================================================================
 875 void OpenGl_Workspace::DisplayCallback (const Graphic3d_CView& theCView,
 876                                         Standard_Integer       theReason)
 877 {
 878   if (theCView.GDisplayCB == NULL)
 879   {
 880     return;
 881   }
 882
 883   Aspect_GraphicCallbackStruct aCallData;
 884   aCallData.reason    = theReason;
 885   aCallData.glContext = GetGlContext();
 886   aCallData.wsID      = theCView.WsId;
 887   aCallData.viewID    = theCView.ViewId;
 888   theCView.GDisplayCB (theCView.DefWindow.XWindow, theCView.GClientData, &aCallData);
 889 }
 890
 891 // =======================================================================
 892 // function : RedrawImmediate
 893 // purpose  :
 894 // =======================================================================
 895 void OpenGl_Workspace::RedrawImmediate (const Graphic3d_CView& theCView,
 896                                         const Aspect_CLayer2d& theCUnderLayer,
 897                                         const Aspect_CLayer2d& theCOverLayer,
 898                                         const Standard_Boolean theToForce)
 899 {
 900   if (!Activate())
 901   {
 902     return;
 903   }
 904
 905   GLboolean isDoubleBuffer = GL_FALSE;
 906 #if !defined(GL_ES_VERSION_2_0)
 907   glGetBooleanv (GL_DOUBLEBUFFER, &isDoubleBuffer);
 908 #endif
 909   if (myView->ImmediateStructures().IsEmpty())
 910   {
 911     if (theToForce
 912      || !myIsImmediateDrawn)
 913     {
 914       myIsImmediateDrawn = Standard_False;
 915       return;
 916     }
 917
 918     if (myBackBufferRestored
 919      && isDoubleBuffer)
 920     {
 921       copyBackToFront();
 922       glFlush();
 923     }
 924     else
 925     {
 926       Redraw (theCView, theCUnderLayer, theCOverLayer);
 927     }
 928     return;
 929   }
 930
 931   if (isDoubleBuffer && myTransientDrawToFront)
 932   {
 933     if (!myBackBufferRestored)
 934     {
 935       Redraw (theCView, theCUnderLayer, theCOverLayer);
 936       return;
 937     }
 938     copyBackToFront();
 939     MakeFrontBufCurrent();
 940   }
 941   else
 942   {
 943     myBackBufferRestored = Standard_False;
 944   }
 945   myIsImmediateDrawn = Standard_True;
 946
 947   NamedStatus |= OPENGL_NS_IMMEDIATE;
 948   ///glDisable (GL_LIGHTING);
 949   glDisable (GL_DEPTH_TEST);
 950
 951   Handle(OpenGl_Workspace) aWS (this);
 952   for (OpenGl_SequenceOfStructure::Iterator anIter (myView->ImmediateStructures());
 953        anIter.More(); anIter.Next())
 954   {
 955     const OpenGl_Structure* aStructure = anIter.Value();
 956     aStructure->Render (aWS);
 957   }
 958
 959   NamedStatus &= ~OPENGL_NS_IMMEDIATE;
 960
 961   if (isDoubleBuffer && myTransientDrawToFront)
 962   {
 963     glFlush();
 964     MakeBackBufCurrent();
 965   }
 966 }