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