bb716f8c758da0a0f98aa789e8157860e2da0e8b
[occt.git] / src / OpenGl / OpenGl_GraphicDriver_7.cxx
1 // Created on: 2011-10-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_GraphicDriver.hxx>
17
18 #include <OpenGl_FrameBuffer.hxx>
19
20 #include <OpenGl_Structure.hxx>
21 #include <OpenGl_CView.hxx>
22 #include <OpenGl_Text.hxx>
23
24 /*----------------------------------------------------------------------*/
25
26 void OpenGl_GraphicDriver::ActivateView (const Graphic3d_CView& ACView)
27 {
28   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
29   if (aCView)
30     aCView->WS->SetActiveView(aCView->View);
31 }
32
33 void OpenGl_GraphicDriver::AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
34 {
35   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
36   if (aCView)
37     aCView->View->SetAntiAliasing(AFlag);
38 }
39
40 void OpenGl_GraphicDriver::Background (const Graphic3d_CView& ACView)
41 {
42   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
43   if (aCView)
44   {
45     aCView->WS->SetBackgroundColor(ACView.DefWindow.Background.r,ACView.DefWindow.Background.g,ACView.DefWindow.Background.b);
46   }
47 }
48
49 void OpenGl_GraphicDriver::GradientBackground (const Graphic3d_CView& ACView,
50                                               const Quantity_Color& AColor1,
51                                               const Quantity_Color& AColor2,
52                                               const Aspect_GradientFillMethod AType)
53 {
54   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
55   if (aCView)
56   {
57     aCView->View->SetBackgroundGradient(AColor1,AColor2,AType);
58   }
59 }
60
61 void OpenGl_GraphicDriver::ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
62 {
63   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
64   if (aCView)
65   {
66     aCView->View->SetClipLimit(ACView);
67     if (!AWait)
68     {
69       aCView->WS->Resize(ACView.DefWindow);
70     }
71   }
72 }
73
74 void OpenGl_GraphicDriver::DeactivateView (const Graphic3d_CView& ACView)
75 {
76   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
77   if (aCView)
78   {
79     const Handle(OpenGl_View) aDummyView;
80     aCView->WS->SetActiveView(aDummyView);
81   }
82 }
83
84 void OpenGl_GraphicDriver::DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
85 {
86   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
87   if (aCView)
88     aCView->View->SetFog(ACView, AFlag);
89 }
90
91 void OpenGl_GraphicDriver::RatioWindow (const Graphic3d_CView& theCView)
92 {
93   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
94   if (aCView != NULL)
95     aCView->WS->Resize (theCView.DefWindow);
96 }
97
98 void OpenGl_GraphicDriver::Redraw (const Graphic3d_CView& ACView, 
99                                    const Aspect_CLayer2d& ACUnderLayer, 
100                                    const Aspect_CLayer2d& ACOverLayer, 
101                                    const Standard_Integer /*x*/, 
102                                    const Standard_Integer /*y*/, 
103                                    const Standard_Integer /*width*/, 
104                                    const Standard_Integer /*height*/)
105 {
106   if (ACView.RenderParams.Method == Graphic3d_RM_RAYTRACING
107   && !myCaps->vboDisable
108   && !myCaps->keepArrayData)
109   {
110     if (ACView.WasRedrawnGL)
111     {
112       myDeviceLostFlag = Standard_True;
113     }
114
115     myCaps->keepArrayData = Standard_True;
116   }
117
118   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
119   if (aCView)
120   {
121     /*if( width <= 0 || height <= 0  )
122       aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
123     else
124       aCView->WS->RedrawArea(ACView, ACUnderLayer, ACOverLayer, x, y, width, height);*/
125     // Always do full redraw
126     aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
127   }
128 }
129
130 void OpenGl_GraphicDriver::RedrawImmediate (const Graphic3d_CView& theCView,
131                                             const Aspect_CLayer2d& theCUnderLayer,
132                                             const Aspect_CLayer2d& theCOverLayer)
133 {
134   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
135   if (aCView != NULL)
136   {
137     aCView->WS->RedrawImmediate (theCView, theCUnderLayer, theCOverLayer);
138   }
139 }
140
141 void OpenGl_GraphicDriver::Invalidate (const Graphic3d_CView& theCView)
142 {
143   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
144   if (aCView != NULL)
145   {
146     aCView->WS->Invalidate (theCView);
147   }
148 }
149
150 Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView& ACView, const Standard_Integer theWidth, const Standard_Integer theHeight)
151 {
152   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
153   if (aCView)
154     return aCView->WS->FBOCreate(theWidth, theHeight);
155   return (Graphic3d_PtrFrameBuffer)NULL;
156 }
157
158 Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
159                                                       const Standard_Integer theHeight)
160 {
161   // activate OpenGL context
162   if (!Activate())
163     return NULL;
164
165   // create the FBO
166   const Handle(OpenGl_Context)& aCtx = GetGlContext();
167   OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
168   if (!aFrameBuffer->Init (aCtx, theWidth, theHeight))
169   {
170     aFrameBuffer->Release (aCtx.operator->());
171     delete aFrameBuffer;
172     return NULL;
173   }
174   return (Graphic3d_PtrFrameBuffer )aFrameBuffer;
175 }
176
177 void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& ACView, Graphic3d_PtrFrameBuffer& theFBOPtr)
178 {
179   if (theFBOPtr == NULL)
180     return;
181   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
182   if (aCView)
183   {
184     aCView->WS->FBORelease(theFBOPtr);
185     theFBOPtr = NULL;
186   }
187 }
188
189 void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr)
190 {
191   // activate OpenGL context
192   if (!Activate()
193    || theFBOPtr == NULL)
194   {
195     return;
196   }
197
198   // release the object
199   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
200   if (aFrameBuffer != NULL)
201   {
202     aFrameBuffer->Release (GetGlContext().operator->());
203   }
204   delete aFrameBuffer;
205 }
206
207 void OpenGl_GraphicDriver::FBOGetDimensions (const Graphic3d_CView& ,
208                                              const Graphic3d_PtrFrameBuffer theFBOPtr,
209                                              Standard_Integer& theWidth,    Standard_Integer& theHeight,
210                                              Standard_Integer& theWidthMax, Standard_Integer& theHeightMax)
211 {
212   if (theFBOPtr == NULL)
213   {
214     return;
215   }
216   const OpenGl_FrameBuffer* aFrameBuffer = (const OpenGl_FrameBuffer* )theFBOPtr;
217   theWidth  = aFrameBuffer->GetVPSizeX(); // current viewport size
218   theHeight = aFrameBuffer->GetVPSizeY();
219   theWidthMax  = aFrameBuffer->GetSizeX(); // texture size
220   theHeightMax = aFrameBuffer->GetSizeY();
221 }
222
223 void OpenGl_GraphicDriver::FBOChangeViewport (const Graphic3d_CView& ,
224                                               Graphic3d_PtrFrameBuffer& theFBOPtr,
225                                               const Standard_Integer theWidth, const Standard_Integer theHeight)
226 {
227   if (theFBOPtr == NULL)
228   {
229     return;
230   }
231   OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theFBOPtr;
232   aFrameBuffer->ChangeViewport (theWidth, theHeight);
233 }
234
235 inline bool getDataFormat (const Image_PixMap& theData,
236                            GLenum&             thePixelFormat,
237                            GLenum&             theDataType)
238 {
239   thePixelFormat = GL_RGB;
240   theDataType    = GL_UNSIGNED_BYTE;
241   switch (theData.Format())
242   {
243     case Image_PixMap::ImgGray:
244       thePixelFormat = GL_DEPTH_COMPONENT;
245       theDataType    = GL_UNSIGNED_BYTE;
246       return true;
247     case Image_PixMap::ImgRGB:
248       thePixelFormat = GL_RGB;
249       theDataType    = GL_UNSIGNED_BYTE;
250       return true;
251     case Image_PixMap::ImgBGR:
252       thePixelFormat = GL_BGR;
253       theDataType    = GL_UNSIGNED_BYTE;
254       return true;
255     case Image_PixMap::ImgRGBA:
256     case Image_PixMap::ImgRGB32:
257       thePixelFormat = GL_RGBA;
258       theDataType    = GL_UNSIGNED_BYTE;
259       return true;
260     case Image_PixMap::ImgBGRA:
261     case Image_PixMap::ImgBGR32:
262       thePixelFormat = GL_BGRA;
263       theDataType    = GL_UNSIGNED_BYTE;
264       return true;
265     case Image_PixMap::ImgGrayF:
266       thePixelFormat = GL_DEPTH_COMPONENT;
267       theDataType    = GL_FLOAT;
268       return true;
269     case Image_PixMap::ImgRGBF:
270       thePixelFormat = GL_RGB;
271       theDataType    = GL_FLOAT;
272       return true;
273     case Image_PixMap::ImgBGRF:
274       thePixelFormat = GL_BGR;
275       theDataType    = GL_FLOAT;
276       return true;
277     case Image_PixMap::ImgRGBAF:
278       thePixelFormat = GL_RGBA;
279       theDataType    = GL_FLOAT;
280       return true;
281     case Image_PixMap::ImgBGRAF:
282       thePixelFormat = GL_BGRA;
283       theDataType    = GL_FLOAT;
284       return true;
285     default:
286       return false;
287   }
288 }
289
290 Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView&      theCView,
291                                                    Image_PixMap&               theImage,
292                                                    const Graphic3d_BufferType& theBufferType)
293 {
294   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
295   return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType);
296 }
297
298 Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFBOPtr,
299                                                Image_PixMap&               theImage,
300                                                const Graphic3d_BufferType& theBufferType)
301 {
302   GLenum aFormat, aType;
303   if (theImage.IsEmpty()
304    || !getDataFormat (theImage, aFormat, aType)
305    || ((theBufferType == Graphic3d_BT_Depth) && (aFormat != GL_DEPTH_COMPONENT))
306    || !Activate())
307   {
308     return Standard_False;
309   }
310
311   // bind FBO if used
312   GLint aReadBufferPrev = GL_BACK;
313   if (theFBOPtr != NULL && theFBOPtr->IsValid())
314   {
315     theFBOPtr->BindBuffer (GetGlContext());
316   }
317   else
318   {
319     glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
320     GLint aDrawBufferPrev = GL_BACK;
321     glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
322     glReadBuffer (aDrawBufferPrev);
323   }
324
325   // setup alignment
326   const GLint anExtraBytes = (GLint )theImage.RowExtraBytes();
327   const GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
328   glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
329
330   const GLint aPixelsWidth = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
331   glPixelStorei (GL_PACK_ROW_LENGTH, (anExtraBytes >= anAligment) ? aPixelsWidth : 0);
332
333   if (theImage.IsTopDown())
334   {
335     // copy row by row
336     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
337     {
338       // Image_PixMap rows indexation always starts from the upper corner
339       // while order in memory depends on the flag and processed by ChangeRow() method
340       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
341     }
342   }
343   else
344   {
345     glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
346   }
347
348   glPixelStorei (GL_PACK_ALIGNMENT,  1);
349   glPixelStorei (GL_PACK_ROW_LENGTH, 0);
350
351   if (theFBOPtr != NULL && theFBOPtr->IsValid())
352   {
353     theFBOPtr->UnbindBuffer (GetGlContext());
354   }
355   else
356   {
357     glReadBuffer (aReadBufferPrev);
358   }
359   return Standard_True;
360 }
361
362 void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView)
363 {
364   Handle(OpenGl_Context)   aCtx = GetSharedContext();
365   Handle(OpenGl_View)      aView;
366   Handle(OpenGl_Workspace) aWindow;
367   if (myMapOfWS.Find (theCView.WsId, aWindow))
368   {
369     myMapOfWS.UnBind (theCView.WsId);
370   }
371   if (!aWindow.IsNull())
372   {
373     if (aWindow->GetGlContext()->MakeCurrent())
374     {
375       aCtx = aWindow->GetGlContext();
376     }
377     else
378     {
379       // try to hijack another context if any
380       const Handle(OpenGl_Context)& anOtherCtx = GetSharedContext();
381       if (!anOtherCtx.IsNull()
382        && anOtherCtx != aWindow->GetGlContext())
383       {
384         aCtx = anOtherCtx;
385         aCtx->MakeCurrent();
386       }
387     }
388   }
389   if (myMapOfView.Find (theCView.ViewId, aView))
390   {
391     aView->ReleaseGlResources (aCtx);
392     myMapOfView.UnBind (theCView.ViewId);
393   }
394
395   if (myMapOfWS.IsEmpty())
396   {
397     // The last view removed but some objects still present.
398     // Release GL resources now without object destruction.
399     for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
400          aStructIt.More (); aStructIt.Next())
401     {
402       OpenGl_Structure* aStruct = aStructIt.ChangeValue();
403       aStruct->ReleaseGlResources (aCtx);
404     }
405     myTempText->Release (aCtx.operator->());
406     myDeviceLostFlag = !myMapOfStructure.IsEmpty();
407   }
408
409   OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
410   delete aCView;
411   ((Graphic3d_CView *)&theCView)->ptrView = NULL;
412
413   aCtx.Nullify();
414   aView.Nullify();
415   aWindow.Nullify();
416 }
417
418 void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView)
419 {
420   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
421   if (aCView)
422     aCView->View->SetLights(ACView.Context);
423 }
424
425 void OpenGl_GraphicDriver::SetClipPlanes (const Graphic3d_CView& theCView)
426 {
427   const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
428   if (aCView)
429   {
430     aCView->View->SetClipPlanes (theCView.Context.ClipPlanes);
431   }
432 }
433
434 //=======================================================================
435 //function : SetCamera
436 //purpose  :
437 //=======================================================================
438 void OpenGl_GraphicDriver::SetCamera (const Graphic3d_CView& theCView)
439 {
440   const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
441   if (aCView)
442   {
443     aCView->View->SetCamera (theCView.Context.Camera);
444   }
445 }
446
447 void OpenGl_GraphicDriver::SetVisualisation (const Graphic3d_CView& ACView)
448 {
449   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
450   if (aCView)
451   {
452     aCView->View->SetVisualisation(ACView.Context);
453     aCView->WS->UseZBuffer() = ( ACView.Context.Visualization == 0? (ACView.Context.ZBufferActivity == 1) : (ACView.Context.ZBufferActivity != 0) );
454   }
455 }
456
457 void OpenGl_GraphicDriver::Transparency (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
458 {
459   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
460   if (aCView)
461     aCView->WS->UseTransparency(AFlag);
462 }
463
464 // =======================================================================
465 // function : InvalidateBVHData
466 // purpose  :
467 // =======================================================================
468 void OpenGl_GraphicDriver::InvalidateBVHData (Graphic3d_CView& theCView, const Standard_Integer theLayerId)
469 {
470   OpenGl_CView *aCView = (OpenGl_CView *)theCView.ptrView;
471   if(aCView)
472   {
473     aCView->View->InvalidateBVHData (theLayerId);
474   }
475 }
476
477 Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& theCView)
478 {
479   if (myMapOfView.IsBound (theCView.ViewId)
480    || myMapOfWS  .IsBound (theCView.WsId))
481   {
482     return Standard_False;
483   }
484
485   Handle(OpenGl_Context)   aShareCtx = GetSharedContext();
486   Handle(OpenGl_Workspace) aWS       = new OpenGl_Workspace (myDisplayConnection, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
487   Handle(OpenGl_View)      aView     = new OpenGl_View (theCView.Context, &myStateCounter);
488   myMapOfWS  .Bind (theCView.WsId,   aWS);
489   myMapOfView.Bind (theCView.ViewId, aView);
490
491   OpenGl_CView* aCView = new OpenGl_CView();
492   aCView->View = aView;
493   aCView->WS   = aWS;
494   theCView.ptrView = aCView;
495
496   return Standard_True;
497 }
498
499 void OpenGl_GraphicDriver::SetBackFacingModel (const Graphic3d_CView& ACView)
500 {
501   const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
502   if (aCView)
503     aCView->View->SetBackfacing(ACView.Backfacing);
504 }
505
506 //=======================================================================
507 //function : AddZLayer
508 //purpose  :
509 //=======================================================================
510
511 void OpenGl_GraphicDriver::AddZLayer (const Graphic3d_CView& theCView,
512                                       const Standard_Integer theLayerId)
513 {
514   const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
515   if (aCView)
516     aCView->View->AddZLayer (theLayerId);
517 }
518
519 //=======================================================================
520 //function : RemoveZLayer
521 //purpose  :
522 //=======================================================================
523 void OpenGl_GraphicDriver::RemoveZLayer (const Graphic3d_CView& theCView,
524                                          const Standard_Integer theLayerId)
525 {
526   const OpenGl_CView* aCView = (const OpenGl_CView *)theCView.ptrView;
527   if (aCView)
528     aCView->View->RemoveZLayer (theLayerId);
529 }
530
531 //=======================================================================
532 //function : SetZLayerSettings
533 //purpose  :
534 //=======================================================================
535 Standard_EXPORT void OpenGl_GraphicDriver::SetZLayerSettings (const Graphic3d_CView& theCView,
536                                                               const Standard_Integer theLayerId,
537                                                               const Graphic3d_ZLayerSettings& theSettings)
538 {
539   const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
540   if (aCView)
541     aCView->View->SetZLayerSettings (theLayerId, theSettings);
542 }