src/OpenGl/OpenGl_GraphicDriver_7.cxx

   1 // Created on: 2011-10-20
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-2012 OPEN CASCADE SAS
   4 //
   5 // The content of this file is subject to the Open CASCADE Technology Public
   6 // License Version 6.5 (the "License"). You may not use the content of this file
   7 // except in compliance with the License. Please obtain a copy of the License
   8 // at http://www.opencascade.org and read it completely before using this file.
   9 //
  10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  12 //
  13 // The Original Code and all software distributed under the License is
  14 // distributed on an "AS IS" basis, without warranty of any kind, and the
  15 // Initial Developer hereby disclaims all such warranties, including without
  16 // limitation, any warranties of merchantability, fitness for a particular
  17 // purpose or non-infringement. Please see the License for the specific terms
  18 // and conditions governing the rights and limitations under the License.
  19
  20
  21 #include <OpenGl_GraphicDriver.hxx>
  22
  23 #include <OpenGl_FrameBuffer.hxx>
  24
  25 #include <OpenGl_Structure.hxx>
  26 #include <OpenGl_CView.hxx>
  27 #include <OpenGl_Display.hxx>
  28
  29 /*----------------------------------------------------------------------*/
  30
  31 void OpenGl_GraphicDriver::ActivateView (const Graphic3d_CView& ACView)
  32 {
  33   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
  34   if (aCView)
  35     aCView->WS->SetActiveView(aCView->View);
  36 }
  37
  38 void OpenGl_GraphicDriver::AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
  39 {
  40   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
  41   if (aCView)
  42     aCView->View->SetAntiAliasing(AFlag);
  43 }
  44
  45 void OpenGl_GraphicDriver::Background (const Graphic3d_CView& ACView)
  46 {
  47   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
  48   if (aCView)
  49   {
  50     aCView->WS->SetBackgroundColor(ACView.DefWindow.Background.r,ACView.DefWindow.Background.g,ACView.DefWindow.Background.b);
  51   }
  52 }
  53
  54 void OpenGl_GraphicDriver::GradientBackground (const Graphic3d_CView& ACView,
  55                                               const Quantity_Color& AColor1,
  56                                               const Quantity_Color& AColor2,
  57                                               const Aspect_GradientFillMethod AType)
  58 {
  59   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
  60   if (aCView)
  61   {
  62     aCView->View->SetBackgroundGradient(AColor1,AColor2,AType);
  63   }
  64 }
  65
  66 void OpenGl_GraphicDriver::Blink (const Graphic3d_CStructure &, const Standard_Boolean)
  67 {
  68   // Do nothing
  69 }
  70
  71 void OpenGl_GraphicDriver::BoundaryBox (const Graphic3d_CStructure& theCStructure,
  72                                         const Standard_Boolean      toCreate)
  73 {
  74   OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
  75   if (aStructure == NULL)
  76     return;
  77
  78   if (toCreate)
  79     aStructure->SetHighlightBox (GetSharedContext(), theCStructure.BoundBox);
  80   else
  81     aStructure->ClearHighlightBox (GetSharedContext());
  82 }
  83
  84 void OpenGl_GraphicDriver::HighlightColor (const Graphic3d_CStructure& theCStructure,
  85                                            const Standard_ShortReal R,
  86                                            const Standard_ShortReal G,
  87                                            const Standard_ShortReal B,
  88                                            const Standard_Boolean   toCreate)
  89 {
  90   OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
  91   if (aStructure == NULL)
  92     return;
  93
  94   if (toCreate)
  95     aStructure->SetHighlightColor (GetSharedContext(), R, G, B);
  96   else
  97     aStructure->ClearHighlightColor (GetSharedContext());
  98 }
  99
 100 void OpenGl_GraphicDriver::NameSetStructure (const Graphic3d_CStructure& ACStructure)
 101 {
 102   OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
 103   if (astructure)
 104   {
 105     Standard_Integer aStatus = 0;
 106     if (ACStructure.highlight) aStatus |= OPENGL_NS_HIGHLIGHT;
 107     if (!ACStructure.visible) aStatus |= OPENGL_NS_HIDE;
 108     astructure->SetNamedStatus( aStatus );
 109   }
 110 }
 111
 112 void OpenGl_GraphicDriver::ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
 113 {
 114   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 115   if (aCView)
 116   {
 117     aCView->View->SetClipLimit(ACView);
 118     if (!AWait)
 119     {
 120       aCView->WS->Resize(ACView.DefWindow);
 121     }
 122   }
 123 }
 124
 125 void OpenGl_GraphicDriver::DeactivateView (const Graphic3d_CView& ACView)
 126 {
 127   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 128   if (aCView)
 129   {
 130     const Handle(OpenGl_View) aDummyView;
 131     aCView->WS->SetActiveView(aDummyView);
 132   }
 133 }
 134
 135 void OpenGl_GraphicDriver::DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
 136 {
 137   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 138   if (aCView)
 139     aCView->View->SetFog(ACView, AFlag);
 140 }
 141
 142 Standard_Boolean OpenGl_GraphicDriver::ProjectRaster (const Graphic3d_CView& ACView, const Standard_ShortReal AX, const Standard_ShortReal AY, const Standard_ShortReal AZ, Standard_Integer& AU, Standard_Integer& AV)
 143 {
 144   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 145   if (!aCView)
 146     return Standard_False;
 147
 148   Standard_Integer aWidth = aCView->WS->Width();
 149   Standard_Integer aHeight = aCView->WS->Height();
 150   Standard_ShortReal xr, yr;
 151   if (aCView->View->ProjectObjectToRaster(aWidth, aHeight, AX, AY, AZ, xr, yr))
 152   {
 153     AU = (Standard_Integer) xr;
 154     AV = aHeight - (Standard_Integer) yr;
 155     return Standard_True;
 156   }
 157
 158   return Standard_False;
 159 }
 160
 161 Standard_Boolean OpenGl_GraphicDriver::UnProjectRaster (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az)
 162 {
 163   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 164   if (!aCView)
 165     return Standard_False;
 166
 167   const Standard_Integer aWidth = aCView->WS->Width();
 168   const Standard_Integer aHeight = aCView->WS->Height();
 169
 170   /*
 171   Patched by P.Dolbey: the window pixel height decreased by one
 172   in order for yr to remain within valid coordinate range [0; Ym -1]
 173   where Ym means window pixel height.
 174   */
 175   return aCView->View->ProjectRasterToObject( aWidth, aHeight, AU, (AYM-1)-Aym-AV, Ax, Ay, Az );
 176 }
 177
 178 Standard_Boolean OpenGl_GraphicDriver::UnProjectRasterWithRay (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az, Standard_ShortReal& Dx, Standard_ShortReal& Dy, Standard_ShortReal& Dz)
 179 {
 180   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 181   if (!aCView)
 182     return Standard_False;
 183
 184   const Standard_Integer aWidth = aCView->WS->Width();
 185   const Standard_Integer aHeight = aCView->WS->Height();
 186
 187   return aCView->View->ProjectRasterToObjectWithRay( aWidth, aHeight, AU, AYM-Aym-AV, Ax, Ay, Az, Dx, Dy, Dz );
 188 }
 189
 190 void OpenGl_GraphicDriver::RatioWindow (const Graphic3d_CView& theCView)
 191 {
 192   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
 193   if (aCView != NULL)
 194     aCView->WS->Resize (theCView.DefWindow);
 195 }
 196
 197 void OpenGl_GraphicDriver::Redraw (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height)
 198 {
 199   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 200   if (aCView)
 201   {
 202     /*if( width <= 0 || height <= 0  )
 203       aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
 204     else
 205       aCView->WS->RedrawArea(ACView, ACUnderLayer, ACOverLayer, x, y, width, height);*/
 206     // Always do full redraw
 207     aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
 208   }
 209 }
 210
 211 Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView& ACView, const Standard_Integer theWidth, const Standard_Integer theHeight)
 212 {
 213   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 214   if (aCView)
 215     return aCView->WS->FBOCreate(theWidth, theHeight);
 216   return (Graphic3d_PtrFrameBuffer)NULL;
 217 }
 218
 219 Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight)
 220 {
 221   // activate OpenGL context
 222   if (!Activate())
 223     return NULL;
 224
 225   // create the FBO
 226   OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
 227   if (!aFrameBuffer->Init (GetGlContext(), theWidth, theHeight))
 228   {
 229     delete aFrameBuffer;
 230     return NULL;
 231   }
 232   return (Graphic3d_PtrFrameBuffer )aFrameBuffer;
 233 }
 234
 235 void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& ACView, Graphic3d_PtrFrameBuffer& theFBOPtr)
 236 {
 237   if (theFBOPtr == NULL)
 238     return;
 239   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 240   if (aCView)
 241   {
 242     aCView->WS->FBORelease(theFBOPtr);
 243     theFBOPtr = NULL;
 244   }
 245 }
 246
 247 void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr)
 248 {
 249   // activate OpenGL context
 250   if (!Activate())
 251     return;
 252
 253   // release the object
 254   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
 255   aFrameBuffer->Release (GetGlContext());
 256   delete aFrameBuffer;
 257 }
 258
 259 void OpenGl_GraphicDriver::FBOGetDimensions (const Graphic3d_CView& ,
 260                                              const Graphic3d_PtrFrameBuffer theFBOPtr,
 261                                              Standard_Integer& theWidth,    Standard_Integer& theHeight,
 262                                              Standard_Integer& theWidthMax, Standard_Integer& theHeightMax)
 263 {
 264   if (theFBOPtr == NULL)
 265   {
 266     return;
 267   }
 268   const OpenGl_FrameBuffer* aFrameBuffer = (const OpenGl_FrameBuffer* )theFBOPtr;
 269   theWidth  = aFrameBuffer->GetVPSizeX(); // current viewport size
 270   theHeight = aFrameBuffer->GetVPSizeY();
 271   theWidthMax  = aFrameBuffer->GetSizeX(); // texture size
 272   theHeightMax = aFrameBuffer->GetSizeY();
 273 }
 274
 275 void OpenGl_GraphicDriver::FBOChangeViewport (const Graphic3d_CView& ,
 276                                               Graphic3d_PtrFrameBuffer& theFBOPtr,
 277                                               const Standard_Integer theWidth, const Standard_Integer theHeight)
 278 {
 279   if (theFBOPtr == NULL)
 280   {
 281     return;
 282   }
 283   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theFBOPtr;
 284   aFrameBuffer->ChangeViewport (theWidth, theHeight);
 285 }
 286
 287 inline bool getDataFormat (const Image_PixMap& theData,
 288                            GLenum&             thePixelFormat,
 289                            GLenum&             theDataType)
 290 {
 291   thePixelFormat = GL_RGB;
 292   theDataType    = GL_UNSIGNED_BYTE;
 293   switch (theData.Format())
 294   {
 295     case Image_PixMap::ImgGray:
 296       thePixelFormat = GL_DEPTH_COMPONENT;
 297       theDataType    = GL_UNSIGNED_BYTE;
 298       return true;
 299     case Image_PixMap::ImgRGB:
 300       thePixelFormat = GL_RGB;
 301       theDataType    = GL_UNSIGNED_BYTE;
 302       return true;
 303     case Image_PixMap::ImgBGR:
 304       thePixelFormat = GL_BGR;
 305       theDataType    = GL_UNSIGNED_BYTE;
 306       return true;
 307     case Image_PixMap::ImgRGBA:
 308     case Image_PixMap::ImgRGB32:
 309       thePixelFormat = GL_RGBA;
 310       theDataType    = GL_UNSIGNED_BYTE;
 311       return true;
 312     case Image_PixMap::ImgBGRA:
 313     case Image_PixMap::ImgBGR32:
 314       thePixelFormat = GL_BGRA;
 315       theDataType    = GL_UNSIGNED_BYTE;
 316       return true;
 317     case Image_PixMap::ImgGrayF:
 318       thePixelFormat = GL_DEPTH_COMPONENT;
 319       theDataType    = GL_FLOAT;
 320       return true;
 321     case Image_PixMap::ImgRGBF:
 322       thePixelFormat = GL_RGB;
 323       theDataType    = GL_FLOAT;
 324       return true;
 325     case Image_PixMap::ImgBGRF:
 326       thePixelFormat = GL_BGR;
 327       theDataType    = GL_FLOAT;
 328       return true;
 329     case Image_PixMap::ImgRGBAF:
 330       thePixelFormat = GL_RGBA;
 331       theDataType    = GL_FLOAT;
 332       return true;
 333     case Image_PixMap::ImgBGRAF:
 334       thePixelFormat = GL_BGRA;
 335       theDataType    = GL_FLOAT;
 336       return true;
 337     default:
 338       return false;
 339   }
 340 }
 341
 342 Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView&      theCView,
 343                                                    Image_PixMap&               theImage,
 344                                                    const Graphic3d_BufferType& theBufferType)
 345 {
 346   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
 347   return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType);
 348   return Standard_False;
 349 }
 350
 351 Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFBOPtr,
 352                                                Image_PixMap&               theImage,
 353                                                const Graphic3d_BufferType& theBufferType)
 354 {
 355   GLenum aFormat, aType;
 356   if (theImage.IsEmpty()
 357    || !getDataFormat (theImage, aFormat, aType)
 358    || ((theBufferType == Graphic3d_BT_Depth) && (aFormat != GL_DEPTH_COMPONENT))
 359    || !Activate())
 360   {
 361     return Standard_False;
 362   }
 363
 364   // bind FBO if used
 365   GLint aReadBufferPrev = GL_BACK;
 366   if (theFBOPtr != NULL && theFBOPtr->IsValid())
 367   {
 368     theFBOPtr->BindBuffer (GetGlContext());
 369   }
 370   else
 371   {
 372     glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
 373     GLint aDrawBufferPrev = GL_BACK;
 374     glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
 375     glReadBuffer (aDrawBufferPrev);
 376   }
 377
 378   GLint anAlignBack = 1;
 379   glGetIntegerv (GL_PACK_ALIGNMENT, &anAlignBack);
 380   GLint anExtraBytes = (GLint )theImage.RowExtraBytes();
 381   GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
 382   glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
 383
 384   if (anExtraBytes >= anAligment)
 385   {
 386     // copy row by row
 387     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
 388     {
 389       glReadPixels (0, GLint(aRow), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
 390     }
 391   }
 392   else
 393   {
 394     // read pixels
 395     glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
 396     theImage.SetTopDown (false); // image bottom-up in OpenGL
 397   }
 398
 399   glPixelStorei (GL_PACK_ALIGNMENT, anAlignBack);
 400
 401   if (theFBOPtr != NULL && theFBOPtr->IsValid())
 402   {
 403     theFBOPtr->UnbindBuffer (GetGlContext());
 404   }
 405   else
 406   {
 407     glReadBuffer (aReadBufferPrev);
 408   }
 409   return Standard_True;
 410 }
 411
 412 void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView)
 413 {
 414   Handle(OpenGl_Context) aShareCtx = GetSharedContext();
 415   if (myMapOfView.IsBound (theCView.ViewId))
 416     myMapOfView.UnBind (theCView.ViewId);
 417
 418   if (myMapOfWS.IsBound (theCView.WsId))
 419     myMapOfWS.UnBind (theCView.WsId);
 420
 421   if (myMapOfWS.IsEmpty() && !myMapOfStructure.IsEmpty())
 422   {
 423     // The last view removed but some objects still present.
 424     // Release GL resources now without object destruction.
 425     for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
 426          aStructIt.More (); aStructIt.Next())
 427     {
 428       OpenGl_Structure* aStruct = aStructIt.ChangeValue();
 429       aStruct->ReleaseGlResources (aShareCtx);
 430     }
 431   }
 432
 433   OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
 434   aCView->View->ReleaseGlResources (aShareCtx);
 435   delete aCView;
 436   ((Graphic3d_CView *)&theCView)->ptrView = NULL;
 437 }
 438
 439 void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView)
 440 {
 441   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 442   if (aCView)
 443     aCView->View->SetLights(ACView.Context);
 444 }
 445
 446 void OpenGl_GraphicDriver::SetPlane (const Graphic3d_CView& ACView)
 447 {
 448   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 449   if (aCView)
 450     aCView->View->SetClippingPlanes(ACView.Context);
 451 }
 452
 453 void OpenGl_GraphicDriver::SetVisualisation (const Graphic3d_CView& ACView)
 454 {
 455   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 456   if (aCView)
 457   {
 458     aCView->View->SetVisualisation(ACView.Context);
 459     aCView->WS->UseZBuffer() = ( ACView.Context.Visualization == 0? (ACView.Context.ZBufferActivity == 1) : (ACView.Context.ZBufferActivity != 0) );
 460   }
 461 }
 462
 463 void OpenGl_GraphicDriver::TransformStructure (const Graphic3d_CStructure& ACStructure)
 464 {
 465   OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
 466   if (astructure)
 467     astructure->SetTransformation(&(ACStructure.Transformation[0][0]));
 468 }
 469
 470 void OpenGl_GraphicDriver::DegenerateStructure (const Graphic3d_CStructure& ACStructure)
 471 {
 472   OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
 473   if (astructure)
 474     astructure->SetDegenerateModel( ACStructure.ContextFillArea.DegenerationMode, ACStructure.ContextFillArea.SkipRatio );
 475 }
 476
 477 void OpenGl_GraphicDriver::Transparency (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
 478 {
 479   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 480   if (aCView)
 481     aCView->WS->UseTransparency(AFlag);
 482 }
 483
 484 void OpenGl_GraphicDriver::Update (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer)
 485 {
 486   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 487   if (aCView)
 488     aCView->WS->Update(ACView,ACUnderLayer,ACOverLayer);
 489 }
 490
 491 Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& theCView)
 492 {
 493   if (openglDisplay.IsNull())
 494     return Standard_False;
 495
 496   if (myMapOfView.IsBound (theCView.ViewId))
 497     myMapOfView.UnBind (theCView.ViewId);
 498
 499   if (myMapOfWS.IsBound (theCView.WsId))
 500     myMapOfWS.UnBind (theCView.WsId);
 501
 502   Handle(OpenGl_Workspace) aWS = Handle(OpenGl_Workspace)::DownCast(openglDisplay->GetWindow (theCView.DefWindow.XWindow));
 503   if (aWS.IsNull())
 504   {
 505     Handle(OpenGl_Context) aShareCtx = GetSharedContext();
 506     aWS = new OpenGl_Workspace (openglDisplay, theCView.DefWindow, theCView.GContext, aShareCtx);
 507     openglDisplay->SetWindow (theCView.DefWindow.XWindow, aWS);
 508   }
 509
 510   myMapOfWS.Bind (theCView.WsId, aWS);
 511
 512   Handle(OpenGl_View) aView = new OpenGl_View (theCView.Context);
 513   myMapOfView.Bind (theCView.ViewId, aView);
 514
 515   OpenGl_CView* aCView = new OpenGl_CView();
 516   aCView->View = aView;
 517   aCView->WS = aWS;
 518   theCView.ptrView = aCView;
 519
 520   return Standard_True;
 521 }
 522
 523 void OpenGl_GraphicDriver::ViewMapping (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
 524 {
 525   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 526   if (aCView)
 527   {
 528     aCView->View->SetMapping(ACView);
 529     if (!AWait)
 530     {
 531       aCView->WS->Resize(ACView.DefWindow);
 532     }
 533   }
 534 }
 535
 536 void OpenGl_GraphicDriver::ViewOrientation (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
 537 {
 538   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 539   if (aCView)
 540   {
 541     aCView->View->SetOrientation(ACView);
 542     if (!AWait)
 543     {
 544       aCView->WS->Resize(ACView.DefWindow);
 545     }
 546   }
 547 }
 548
 549 void OpenGl_GraphicDriver::SetBackFacingModel (const Graphic3d_CView& ACView)
 550 {
 551   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
 552   if (aCView)
 553     aCView->View->SetBackfacing(ACView.Backfacing);
 554 }
 555
 556 //=======================================================================
 557 //function : AddZLayer
 558 //purpose  :
 559 //=======================================================================
 560
 561 void OpenGl_GraphicDriver::AddZLayer (const Graphic3d_CView& theCView,
 562                                       const Standard_Integer theLayerId)
 563 {
 564   const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
 565   if (aCView)
 566     aCView->View->AddZLayer (theLayerId);
 567 }
 568
 569 //=======================================================================
 570 //function : RemoveZLayer
 571 //purpose  :
 572 //=======================================================================
 573
 574 void OpenGl_GraphicDriver::RemoveZLayer (const Graphic3d_CView& theCView,
 575                                          const Standard_Integer theLayerId)
 576 {
 577   const OpenGl_CView* aCView = (const OpenGl_CView *)theCView.ptrView;
 578   if (aCView)
 579     aCView->View->RemoveZLayer (theLayerId);
 580 }