0029507: Visualization, TKOpenGl - uninitialized class field OpenGl_FrameBuffer:...
[occt.git] / src / OpenGl / OpenGl_FrameBuffer.cxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2011-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <OpenGl_FrameBuffer.hxx>
16 #include <OpenGl_ArbFBO.hxx>
17
18 #include <NCollection_AlignedAllocator.hxx>
19 #include <Standard_Assert.hxx>
20 #include <TCollection_ExtendedString.hxx>
21
22 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_FrameBuffer,OpenGl_Resource)
23
24 namespace
25 {
26   //! Checks whether two format arrays are equal or not.
27   static bool operator== (const OpenGl_ColorFormats& theFmt1,
28                           const OpenGl_ColorFormats& theFmt2)
29   {
30     if (theFmt1.Length() != theFmt2.Length())
31       return false;
32     OpenGl_ColorFormats::Iterator anIt1 (theFmt1);
33     OpenGl_ColorFormats::Iterator anIt2 (theFmt1);
34     for (; anIt1.More(); anIt1.Next(), anIt2.Next())
35     {
36       if (anIt1.Value() != anIt2.Value())
37         return false;
38     }
39     return true;
40   }
41 }
42
43 // =======================================================================
44 // function : getDepthDataFormat
45 // purpose  :
46 // =======================================================================
47 bool OpenGl_FrameBuffer::getDepthDataFormat (GLint   theTextFormat,
48                                              GLenum& thePixelFormat,
49                                              GLenum& theDataType)
50 {
51   switch (theTextFormat)
52   {
53     case GL_DEPTH24_STENCIL8:
54     {
55       thePixelFormat = GL_DEPTH_STENCIL;
56       theDataType    = GL_UNSIGNED_INT_24_8;
57       return true;
58     }
59     case GL_DEPTH32F_STENCIL8:
60     {
61       thePixelFormat = GL_DEPTH_STENCIL;
62       theDataType    = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
63       return true;
64     }
65     case GL_DEPTH_COMPONENT16:
66     {
67       thePixelFormat = GL_DEPTH_COMPONENT;
68       theDataType    = GL_UNSIGNED_SHORT;
69       return true;
70     }
71     case GL_DEPTH_COMPONENT24:
72     {
73       thePixelFormat = GL_DEPTH_COMPONENT;
74       theDataType    = GL_UNSIGNED_INT;
75       return true;
76     }
77     case GL_DEPTH_COMPONENT32F:
78     {
79       thePixelFormat = GL_DEPTH_COMPONENT;
80       theDataType    = GL_FLOAT;
81       return true;
82     }
83   }
84   return false;
85 }
86
87 // =======================================================================
88 // function : getColorDataFormat
89 // purpose  :
90 // =======================================================================
91 bool OpenGl_FrameBuffer::getColorDataFormat (const Handle(OpenGl_Context)& theGlContext,
92                                              GLint   theTextFormat,
93                                              GLenum& thePixelFormat,
94                                              GLenum& theDataType)
95 {
96   switch (theTextFormat)
97   {
98     case GL_RGBA32F:
99     {
100       thePixelFormat = GL_RGBA;
101       theDataType    = GL_FLOAT;
102       return true;
103     }
104     case GL_R32F:
105     {
106       thePixelFormat = GL_RED;
107       theDataType    = GL_FLOAT;
108       return true;
109     }
110     case GL_RGBA16F:
111     {
112       thePixelFormat = GL_RGBA;
113       theDataType    = GL_HALF_FLOAT;
114       if (theGlContext->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
115       {
116       #if defined(GL_ES_VERSION_2_0)
117         theDataType = GL_HALF_FLOAT_OES;
118       #else
119         theDataType = GL_FLOAT;
120       #endif
121       }
122       return true;
123     }
124     case GL_R16F:
125     {
126       thePixelFormat = GL_RED;
127       theDataType    = GL_HALF_FLOAT;
128       if (theGlContext->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
129       {
130       #if defined(GL_ES_VERSION_2_0)
131         theDataType = GL_HALF_FLOAT_OES;
132       #else
133         theDataType = GL_FLOAT;
134       #endif
135       }
136       return true;
137     }
138     case GL_RGBA8:
139     case GL_RGBA:
140     {
141       thePixelFormat = GL_RGBA;
142       theDataType    = GL_UNSIGNED_BYTE;
143       return true;
144     }
145     case GL_RGB8:
146     case GL_RGB:
147     {
148       thePixelFormat = GL_RGB;
149       theDataType = GL_UNSIGNED_BYTE;
150       return true;
151     }
152   }
153   return false;
154 }
155
156 // =======================================================================
157 // function : OpenGl_FrameBuffer
158 // purpose  :
159 // =======================================================================
160 OpenGl_FrameBuffer::OpenGl_FrameBuffer()
161 : myInitVPSizeX (0),
162   myInitVPSizeY (0),
163   myVPSizeX (0),
164   myVPSizeY (0),
165   myNbSamples (0),
166   myDepthFormat (GL_DEPTH24_STENCIL8),
167   myGlFBufferId (NO_FRAMEBUFFER),
168   myGlColorRBufferId (NO_RENDERBUFFER),
169   myGlDepthRBufferId (NO_RENDERBUFFER),
170   myIsOwnBuffer  (false),
171   myIsOwnDepth  (false),
172   myDepthStencilTexture (new OpenGl_Texture())
173 {
174   myColorFormats.Append (GL_RGBA8);
175   myColorTextures.Append (new OpenGl_Texture());
176 }
177
178 // =======================================================================
179 // function : ~OpenGl_FrameBuffer
180 // purpose  :
181 // =======================================================================
182 OpenGl_FrameBuffer::~OpenGl_FrameBuffer()
183 {
184   Release (NULL);
185 }
186
187 // =======================================================================
188 // function : Init
189 // purpose  :
190 // =======================================================================
191 Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
192                                            const GLsizei                 theSizeX,
193                                            const GLsizei                 theSizeY,
194                                            const GLint                   theColorFormat,
195                                            const GLint                   theDepthFormat,
196                                            const GLsizei                 theNbSamples)
197 {
198   OpenGl_ColorFormats aColorFormats;
199
200   aColorFormats.Append (theColorFormat);
201
202   return Init (theGlContext, theSizeX, theSizeY, aColorFormats, theDepthFormat, theNbSamples);
203 }
204
205 // =======================================================================
206 // function : Init
207 // purpose  :
208 // =======================================================================
209 Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
210                                            const GLsizei                 theSizeX,
211                                            const GLsizei                 theSizeY,
212                                            const OpenGl_ColorFormats&    theColorFormats,
213                                            const Handle(OpenGl_Texture)& theDepthStencilTexture,
214                                            const GLsizei                 theNbSamples)
215 {
216   myColorFormats = theColorFormats;
217
218   OpenGl_TextureArray aTextures (myColorTextures);
219   if (!myColorTextures.IsEmpty())
220   {
221     for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
222     {
223       aTextureIt.Value()->Release (theGlContext.operator->());
224     }
225     myColorTextures.Clear();
226   }
227   for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
228   {
229     myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
230   }
231
232   myDepthFormat = theDepthStencilTexture->GetFormat();
233   myNbSamples   = theNbSamples;
234   if (theGlContext->arbFBO == NULL)
235   {
236     return Standard_False;
237   }
238
239   // clean up previous state
240   Release (theGlContext.operator->());
241   if (myColorFormats.IsEmpty()
242    && myDepthFormat == 0)
243   {
244     return Standard_False;
245   }
246
247   myDepthStencilTexture = theDepthStencilTexture;
248   myIsOwnDepth  = false;
249   myIsOwnBuffer = true;
250
251   // setup viewport sizes as is
252   myVPSizeX = theSizeX;
253   myVPSizeY = theSizeY;
254   const Standard_Integer aSizeX = theSizeX > 0 ? theSizeX : 2;
255   const Standard_Integer aSizeY = theSizeY > 0 ? theSizeY : 2;
256
257   // Create the textures (will be used as color buffer and depth-stencil buffer)
258   if (theNbSamples != 0)
259   {
260     for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
261     {
262       const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
263       const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
264       if (aColorFormat != 0
265       && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples,
266                                             aColorFormat, aSizeX, aSizeY))
267       {
268         Release (theGlContext.operator->());
269         return Standard_False;
270       }
271     }
272   }
273   else
274   {
275     for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
276     {
277       GLenum aPixelFormat = 0;
278       GLenum aDataType    = 0;
279       const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
280       const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
281       if (aColorFormat != 0
282       &&  getColorDataFormat (theGlContext, aColorFormat, aPixelFormat, aDataType)
283       && !aColorTexture->Init (theGlContext, aColorFormat,
284                                aPixelFormat, aDataType,
285                                aSizeX, aSizeY, Graphic3d_TOT_2D))
286       {
287         Release (theGlContext.operator->());
288         return Standard_False;
289       }
290     }
291   }
292
293   // Build FBO and setup it as texture
294   theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
295   theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
296
297   for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
298   {
299     const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
300     if (aColorTexture->IsValid())
301     {
302       theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
303                                                     aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
304     }
305   }
306   if (myDepthStencilTexture->IsValid())
307   {
308   #ifdef GL_DEPTH_STENCIL_ATTACHMENT
309     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
310                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
311   #else
312     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
313                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
314     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
315                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
316   #endif
317   }
318   if (theGlContext->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
319   {
320     Release (theGlContext.operator->());
321     return Standard_False;
322   }
323
324   UnbindBuffer (theGlContext);
325   return Standard_True;
326 }
327
328 // =======================================================================
329 // function : Init
330 // purpose  :
331 // =======================================================================
332 Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
333                                            const GLsizei                 theSizeX,
334                                            const GLsizei                 theSizeY,
335                                            const OpenGl_ColorFormats&    theColorFormats,
336                                            const GLint                   theDepthFormat,
337                                            const GLsizei                 theNbSamples)
338 {
339   myColorFormats = theColorFormats;
340
341   OpenGl_TextureArray aTextures (myColorTextures);
342   if (!myColorTextures.IsEmpty())
343   {
344     for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
345     {
346       aTextureIt.Value()->Release (theGlContext.operator->());
347     }
348     myColorTextures.Clear();
349   }
350   for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
351   {
352     myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
353   }
354
355   myDepthFormat = theDepthFormat;
356   myNbSamples   = theNbSamples;
357   myInitVPSizeX = theSizeX;
358   myInitVPSizeY = theSizeY;
359   if (theGlContext->arbFBO == NULL)
360   {
361     return Standard_False;
362   }
363
364   // clean up previous state
365   Release (theGlContext.operator->());
366   if (myColorFormats.IsEmpty()
367    && myDepthFormat == 0)
368   {
369     return Standard_False;
370   }
371
372   myIsOwnBuffer = true;
373   myIsOwnDepth  = true;
374
375   // setup viewport sizes as is
376   myVPSizeX = theSizeX;
377   myVPSizeY = theSizeY;
378   const Standard_Integer aSizeX = theSizeX > 0 ? theSizeX : 2;
379   const Standard_Integer aSizeY = theSizeY > 0 ? theSizeY : 2;
380   bool hasStencilRB = false;
381
382   // Create the textures (will be used as color buffer and depth-stencil buffer)
383   if (theNbSamples != 0)
384   {
385     for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
386     {
387       const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
388       const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
389       if (aColorFormat != 0
390       && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples, aColorFormat, aSizeX, aSizeY))
391       {
392         Release (theGlContext.operator->());
393         return Standard_False;
394       }
395     }
396     if (myDepthFormat != 0
397     && !myDepthStencilTexture->Init2DMultisample (theGlContext, theNbSamples, myDepthFormat, aSizeX, aSizeY))
398     {
399       Release (theGlContext.operator->());
400       return Standard_False;
401     }
402   }
403   else
404   {
405     GLenum aPixelFormat = 0;
406     GLenum aDataType    = 0;
407
408     for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
409     {
410       const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
411       const GLint                   aColorFormat  = myColorFormats  (aColorBufferIdx);
412       if (aColorFormat != 0
413       &&  getColorDataFormat (theGlContext, aColorFormat, aPixelFormat, aDataType)
414       && !aColorTexture->Init (theGlContext, aColorFormat,
415                                aPixelFormat, aDataType,
416                                aSizeX, aSizeY, Graphic3d_TOT_2D))
417       {
418         Release (theGlContext.operator->());
419         return Standard_False;
420       }
421     }
422
423     // extensions (GL_OES_packed_depth_stencil, GL_OES_depth_texture) + GL version might be used to determine supported formats
424     // instead of just trying to create such texture
425     if (myDepthFormat != 0
426     &&  getDepthDataFormat (myDepthFormat, aPixelFormat, aDataType)
427     && !myDepthStencilTexture->Init (theGlContext, myDepthFormat,
428                                       aPixelFormat, aDataType,
429                                       aSizeX, aSizeY, Graphic3d_TOT_2D))
430     {
431       TCollection_ExtendedString aMsg = TCollection_ExtendedString()
432         + "Warning! Depth textures are not supported by hardware!";
433       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
434                                  GL_DEBUG_TYPE_PORTABILITY,
435                                  0,
436                                  GL_DEBUG_SEVERITY_HIGH,
437                                  aMsg);
438
439       hasStencilRB = aPixelFormat == GL_DEPTH_STENCIL
440                   && theGlContext->extPDS;
441       GLint aDepthStencilFormat = hasStencilRB
442                                 ? GL_DEPTH24_STENCIL8
443                                 : GL_DEPTH_COMPONENT16;
444
445       theGlContext->arbFBO->glGenRenderbuffers (1, &myGlDepthRBufferId);
446       theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBufferId);
447       theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, aDepthStencilFormat, aSizeX, aSizeY);
448       theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
449     }
450   }
451
452   // Build FBO and setup it as texture
453   theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
454   theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
455   for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
456   {
457     const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
458     if (aColorTexture->IsValid())
459     {
460       theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
461                                                     aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
462     }
463   }
464   if (myDepthStencilTexture->IsValid())
465   {
466   #ifdef GL_DEPTH_STENCIL_ATTACHMENT
467     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
468                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
469   #else
470     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
471                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
472     theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
473                                                   myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
474   #endif
475   }
476   else if (myGlDepthRBufferId != NO_RENDERBUFFER)
477   {
478   #ifdef GL_DEPTH_STENCIL_ATTACHMENT
479     theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, hasStencilRB ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT,
480                                                      GL_RENDERBUFFER, myGlDepthRBufferId);
481   #else
482     theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
483                                                      GL_RENDERBUFFER, myGlDepthRBufferId);
484     if (hasStencilRB)
485     {
486       theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
487                                                        GL_RENDERBUFFER, myGlDepthRBufferId);
488     }
489   #endif
490   }
491   if (theGlContext->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
492   {
493     Release (theGlContext.operator->());
494     return Standard_False;
495   }
496
497   UnbindBuffer (theGlContext);
498   return Standard_True;
499 }
500
501 // =======================================================================
502 // function : InitLazy
503 // purpose  :
504 // =======================================================================
505 Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
506                                                const GLsizei                 theViewportSizeX,
507                                                const GLsizei                 theViewportSizeY,
508                                                const GLint                   theColorFormat,
509                                                const GLint                   theDepthFormat,
510                                                const GLsizei                 theNbSamples)
511 {
512   OpenGl_ColorFormats aColorFormats;
513
514   aColorFormats.Append (theColorFormat);
515
516   return InitLazy (theGlContext, theViewportSizeX, theViewportSizeY, aColorFormats, theDepthFormat, theNbSamples);
517 }
518
519 // =======================================================================
520 // function : InitLazy
521 // purpose  :
522 // =======================================================================
523 Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
524                                                const GLsizei                 theViewportSizeX,
525                                                const GLsizei                 theViewportSizeY,
526                                                const OpenGl_ColorFormats&    theColorFormats,
527                                                const GLint                   theDepthFormat,
528                                                const GLsizei                 theNbSamples)
529 {
530   if (myVPSizeX      == theViewportSizeX
531    && myVPSizeY      == theViewportSizeY
532    && myColorFormats == theColorFormats
533    && myDepthFormat  == theDepthFormat
534    && myNbSamples    == theNbSamples)
535   {
536     return IsValid();
537   }
538
539   return Init (theGlContext, theViewportSizeX, theViewportSizeY, theColorFormats, theDepthFormat, theNbSamples);
540 }
541
542 // =======================================================================
543 // function : InitWithRB
544 // purpose  :
545 // =======================================================================
546 Standard_Boolean OpenGl_FrameBuffer::InitWithRB (const Handle(OpenGl_Context)& theGlCtx,
547                                                  const GLsizei                 theSizeX,
548                                                  const GLsizei                 theSizeY,
549                                                  const GLint                   theColorFormat,
550                                                  const GLint                   theDepthFormat,
551                                                  const GLuint                  theColorRBufferFromWindow)
552 {
553   myColorFormats.Clear();
554   myColorFormats.Append (theColorFormat);
555   if (!myColorTextures.IsEmpty())
556   {
557     Handle(OpenGl_Texture) aTexutre = myColorTextures.First();
558     for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
559     {
560       aTextureIt.Value()->Release (theGlCtx.operator->());
561     }
562     myColorTextures.Clear();
563     myColorTextures.Append (aTexutre);
564   }
565
566   myDepthFormat = theDepthFormat;
567   myNbSamples   = 0;
568   myInitVPSizeX = theSizeX;
569   myInitVPSizeY = theSizeY;
570   if (theGlCtx->arbFBO == NULL)
571   {
572     return Standard_False;
573   }
574
575   // clean up previous state
576   Release (theGlCtx.operator->());
577
578   myIsOwnBuffer = true;
579   myIsOwnDepth  = true;
580
581   // setup viewport sizes as is
582   myVPSizeX = theSizeX;
583   myVPSizeY = theSizeY;
584   const Standard_Integer aSizeX = theSizeX > 0 ? theSizeX : 2;
585   const Standard_Integer aSizeY = theSizeY > 0 ? theSizeY : 2;
586
587   // Create the render-buffers
588   if (theColorRBufferFromWindow != NO_RENDERBUFFER)
589   {
590     myGlColorRBufferId = theColorRBufferFromWindow;
591   }
592   else if (theColorFormat != 0)
593   {
594     theGlCtx->arbFBO->glGenRenderbuffers (1, &myGlColorRBufferId);
595     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlColorRBufferId);
596     theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, theColorFormat, aSizeX, aSizeY);
597   }
598
599   bool hasStencilRB = false;
600   if (myDepthFormat != 0)
601   {
602     GLenum aPixelFormat = 0;
603     GLenum aDataType    = 0;
604     getDepthDataFormat (myDepthFormat, aPixelFormat, aDataType);
605     hasStencilRB = aPixelFormat == GL_DEPTH_STENCIL;
606
607     theGlCtx->arbFBO->glGenRenderbuffers (1, &myGlDepthRBufferId);
608     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBufferId);
609     theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, myDepthFormat, aSizeX, aSizeY);
610     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
611   }
612
613   // create FBO
614   theGlCtx->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
615   theGlCtx->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
616   theGlCtx->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
617                                                GL_RENDERBUFFER, myGlColorRBufferId);
618   if (myGlDepthRBufferId != NO_RENDERBUFFER)
619   {
620   #ifdef GL_DEPTH_STENCIL_ATTACHMENT
621     theGlCtx->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, hasStencilRB ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT,
622                                                  GL_RENDERBUFFER, myGlDepthRBufferId);
623   #else
624     theGlCtx->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
625                                                  GL_RENDERBUFFER, myGlDepthRBufferId);
626     if (hasStencilRB)
627     {
628       theGlCtx->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
629                                                    GL_RENDERBUFFER, myGlDepthRBufferId);
630     }
631   #endif
632   }
633   if (theGlCtx->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
634   {
635     UnbindBuffer (theGlCtx);
636     Release (theGlCtx.operator->());
637     return Standard_False;
638   }
639
640   UnbindBuffer (theGlCtx);
641   return Standard_True;
642 }
643
644 // =======================================================================
645 // function : InitWrapper
646 // purpose  :
647 // =======================================================================
648 Standard_Boolean OpenGl_FrameBuffer::InitWrapper (const Handle(OpenGl_Context)& theGlCtx)
649 {
650   myNbSamples = 0;
651   if (theGlCtx->arbFBO == NULL)
652   {
653     return Standard_False;
654   }
655
656   // clean up previous state
657   Release (theGlCtx.operator->());
658
659   GLint anFbo = GLint(NO_FRAMEBUFFER);
660   ::glGetIntegerv (GL_FRAMEBUFFER_BINDING, &anFbo);
661   if (anFbo == GLint(NO_FRAMEBUFFER))
662   {
663     return Standard_False;
664   }
665
666   GLint aColorType = 0;
667   GLint aColorId   = 0;
668   GLint aDepthType = 0;
669   GLint aDepthId   = 0;
670   theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &aColorType);
671   theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &aDepthType);
672
673   myGlFBufferId = GLuint(anFbo);
674   myIsOwnBuffer = false;
675   myIsOwnDepth  = false;
676   if (aColorType == GL_RENDERBUFFER)
677   {
678     theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &aColorId);
679     myGlColorRBufferId = aColorId;
680   }
681   else if (aColorType != GL_NONE)
682   {
683     TCollection_ExtendedString aMsg = "OpenGl_FrameBuffer::InitWrapper(), color attachment of unsupported type has been skipped!";
684     theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
685                            GL_DEBUG_TYPE_ERROR,
686                            0,
687                            GL_DEBUG_SEVERITY_HIGH,
688                            aMsg);
689   }
690
691   if (aDepthType == GL_RENDERBUFFER)
692   {
693     theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &aDepthId);
694     myGlDepthRBufferId = aDepthId;
695   }
696   else if (aDepthType != GL_NONE)
697   {
698     TCollection_ExtendedString aMsg = "OpenGl_FrameBuffer::InitWrapper(), depth attachment of unsupported type has been skipped!";
699     theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
700                            GL_DEBUG_TYPE_ERROR,
701                            0,
702                            GL_DEBUG_SEVERITY_HIGH,
703                            aMsg);
704   }
705
706   // retrieve dimensions
707   GLuint aRBuffer = myGlColorRBufferId != NO_RENDERBUFFER ? myGlColorRBufferId : myGlDepthRBufferId;
708   if (aRBuffer != NO_RENDERBUFFER)
709   {
710     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, aRBuffer);
711     theGlCtx->arbFBO->glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH,  &myVPSizeX);
712     theGlCtx->arbFBO->glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &myVPSizeY);
713     theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
714   }
715
716   return aRBuffer != NO_RENDERBUFFER;
717 }
718
719 // =======================================================================
720 // function : Release
721 // purpose  :
722 // =======================================================================
723 void OpenGl_FrameBuffer::Release (OpenGl_Context* theGlCtx)
724 {
725   if (isValidFrameBuffer())
726   {
727     // application can not handle this case by exception - this is bug in code
728     Standard_ASSERT_RETURN (theGlCtx != NULL,
729       "OpenGl_FrameBuffer destroyed without GL context! Possible GPU memory leakage...",);
730     if (theGlCtx->IsValid()
731      && myIsOwnBuffer)
732     {
733       theGlCtx->arbFBO->glDeleteFramebuffers (1, &myGlFBufferId);
734       if (myGlColorRBufferId != NO_RENDERBUFFER)
735       {
736         theGlCtx->arbFBO->glDeleteRenderbuffers (1, &myGlColorRBufferId);
737       }
738       if (myGlDepthRBufferId != NO_RENDERBUFFER)
739       {
740         theGlCtx->arbFBO->glDeleteRenderbuffers (1, &myGlDepthRBufferId);
741       }
742     }
743     myGlFBufferId      = NO_FRAMEBUFFER;
744     myGlColorRBufferId = NO_RENDERBUFFER;
745     myGlDepthRBufferId = NO_RENDERBUFFER;
746     myIsOwnBuffer      = false;
747   }
748
749   for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
750   {
751     myColorTextures (aColorBufferIdx)->Release (theGlCtx);
752   }
753
754   if (myIsOwnDepth)
755   {
756     myDepthStencilTexture->Release (theGlCtx);
757     myIsOwnDepth = false;
758   }
759
760   myVPSizeX = 0;
761   myVPSizeY = 0;
762 }
763
764 // =======================================================================
765 // function : SetupViewport
766 // purpose  :
767 // =======================================================================
768 void OpenGl_FrameBuffer::SetupViewport (const Handle(OpenGl_Context)& theGlCtx)
769 {
770   const Standard_Integer aViewport[4] = { 0, 0, myVPSizeX, myVPSizeY };
771   theGlCtx->ResizeViewport (aViewport);
772 }
773
774 // =======================================================================
775 // function : ChangeViewport
776 // purpose  :
777 // =======================================================================
778 void OpenGl_FrameBuffer::ChangeViewport (const GLsizei theVPSizeX,
779                                          const GLsizei theVPSizeY)
780 {
781   myVPSizeX = theVPSizeX;
782   myVPSizeY = theVPSizeY;
783 }
784
785 // =======================================================================
786 // function : BindBuffer
787 // purpose  :
788 // =======================================================================
789 void OpenGl_FrameBuffer::BindBuffer (const Handle(OpenGl_Context)& theGlCtx)
790 {
791   theGlCtx->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
792 }
793
794 // =======================================================================
795 // function : BindDrawBuffer
796 // purpose  :
797 // =======================================================================
798 void OpenGl_FrameBuffer::BindDrawBuffer (const Handle(OpenGl_Context)& theGlCtx)
799 {
800   theGlCtx->arbFBO->glBindFramebuffer (GL_DRAW_FRAMEBUFFER, myGlFBufferId);
801 }
802
803 // =======================================================================
804 // function : BindReadBuffer
805 // purpose  :
806 // =======================================================================
807 void OpenGl_FrameBuffer::BindReadBuffer (const Handle(OpenGl_Context)& theGlCtx)
808 {
809   theGlCtx->arbFBO->glBindFramebuffer (GL_READ_FRAMEBUFFER, myGlFBufferId);
810 }
811
812 // =======================================================================
813 // function : UnbindBuffer
814 // purpose  :
815 // =======================================================================
816 void OpenGl_FrameBuffer::UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx)
817 {
818   if (!theGlCtx->DefaultFrameBuffer().IsNull()
819    &&  theGlCtx->DefaultFrameBuffer().operator->() != this)
820   {
821     theGlCtx->DefaultFrameBuffer()->BindBuffer (theGlCtx);
822   }
823   else
824   {
825     theGlCtx->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, NO_FRAMEBUFFER);
826   }
827 }
828
829 // =======================================================================
830 // function : getAligned
831 // purpose  :
832 // =======================================================================
833 inline Standard_Size getAligned (const Standard_Size theNumber,
834                                  const Standard_Size theAlignment)
835 {
836   return theNumber + theAlignment - 1 - (theNumber - 1) % theAlignment;
837 }
838
839 template<typename T>
840 inline void convertRowFromRgba (T* theRgbRow,
841                                 const Image_ColorRGBA* theRgbaRow,
842                                 const Standard_Size theWidth)
843 {
844   for (Standard_Size aCol = 0; aCol < theWidth; ++aCol)
845   {
846     const Image_ColorRGBA& anRgba = theRgbaRow[aCol];
847     T& anRgb = theRgbRow[aCol];
848     anRgb.r() = anRgba.r();
849     anRgb.g() = anRgba.g();
850     anRgb.b() = anRgba.b();
851   }
852 }
853
854 // =======================================================================
855 // function : BufferDump
856 // purpose  :
857 // =======================================================================
858 Standard_Boolean OpenGl_FrameBuffer::BufferDump (const Handle(OpenGl_Context)& theGlCtx,
859                                                  const Handle(OpenGl_FrameBuffer)& theFbo,
860                                                  Image_PixMap& theImage,
861                                                  Graphic3d_BufferType theBufferType)
862 {
863   if (theGlCtx.IsNull()
864    || theImage.IsEmpty())
865   {
866     return Standard_False;
867   }
868
869   GLenum aFormat = 0;
870   GLenum aType   = 0;
871   bool toSwapRgbaBgra = false;
872   bool toConvRgba2Rgb = false;
873   switch (theImage.Format())
874   {
875   #if !defined(GL_ES_VERSION_2_0)
876     case Image_Format_Gray:
877       aFormat = GL_DEPTH_COMPONENT;
878       aType   = GL_UNSIGNED_BYTE;
879       break;
880     case Image_Format_GrayF:
881       aFormat = GL_DEPTH_COMPONENT;
882       aType   = GL_FLOAT;
883       break;
884     case Image_Format_RGB:
885       aFormat = GL_RGB;
886       aType   = GL_UNSIGNED_BYTE;
887       break;
888     case Image_Format_BGR:
889       aFormat = GL_BGR;
890       aType   = GL_UNSIGNED_BYTE;
891       break;
892     case Image_Format_BGRA:
893     case Image_Format_BGR32:
894       aFormat = GL_BGRA;
895       aType   = GL_UNSIGNED_BYTE;
896       break;
897     case Image_Format_BGRF:
898       aFormat = GL_BGR;
899       aType   = GL_FLOAT;
900       break;
901     case Image_Format_BGRAF:
902       aFormat = GL_BGRA;
903       aType   = GL_FLOAT;
904       break;
905   #else
906     case Image_Format_Gray:
907     case Image_Format_GrayF:
908     case Image_Format_BGRF:
909     case Image_Format_BGRAF:
910       return Standard_False;
911     case Image_Format_BGRA:
912     case Image_Format_BGR32:
913       aFormat = GL_RGBA;
914       aType   = GL_UNSIGNED_BYTE;
915       toSwapRgbaBgra = true;
916       break;
917     case Image_Format_BGR:
918     case Image_Format_RGB:
919       aFormat = GL_RGBA;
920       aType   = GL_UNSIGNED_BYTE;
921       toConvRgba2Rgb = true;
922       break;
923   #endif
924     case Image_Format_RGBA:
925     case Image_Format_RGB32:
926       aFormat = GL_RGBA;
927       aType   = GL_UNSIGNED_BYTE;
928       break;
929     case Image_Format_RGBF:
930       aFormat = GL_RGB;
931       aType   = GL_FLOAT;
932       break;
933     case Image_Format_RGBAF:
934       aFormat = GL_RGBA;
935       aType   = GL_FLOAT;
936       break;
937     case Image_Format_Alpha:
938     case Image_Format_AlphaF:
939       return Standard_False; // GL_ALPHA is no more supported in core context
940     case Image_Format_UNKNOWN:
941       return Standard_False;
942   }
943
944   if (aFormat == 0)
945   {
946     return Standard_False;
947   }
948
949 #if !defined(GL_ES_VERSION_2_0)
950   GLint aReadBufferPrev = GL_BACK;
951   if (theBufferType == Graphic3d_BT_Depth
952    && aFormat != GL_DEPTH_COMPONENT)
953   {
954     return Standard_False;
955   }
956 #else
957   (void )theBufferType;
958 #endif
959
960   // bind FBO if used
961   if (!theFbo.IsNull() && theFbo->IsValid())
962   {
963     theFbo->BindBuffer (theGlCtx);
964   }
965   else
966   {
967   #if !defined(GL_ES_VERSION_2_0)
968     glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
969     GLint aDrawBufferPrev = GL_BACK;
970     glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
971     glReadBuffer (aDrawBufferPrev);
972   #endif
973   }
974
975   // setup alignment
976   const GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
977   glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
978   bool isBatchCopy = !theImage.IsTopDown();
979
980   const GLint   anExtraBytes       = GLint(theImage.RowExtraBytes());
981   GLint         aPixelsWidth       = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
982   Standard_Size aSizeRowBytesEstim = getAligned (theImage.SizePixelBytes() * aPixelsWidth, anAligment);
983   if (anExtraBytes < anAligment)
984   {
985     aPixelsWidth = 0;
986   }
987   else if (aSizeRowBytesEstim != theImage.SizeRowBytes())
988   {
989     aPixelsWidth = 0;
990     isBatchCopy  = false;
991   }
992 #if !defined(GL_ES_VERSION_2_0)
993   glPixelStorei (GL_PACK_ROW_LENGTH, aPixelsWidth);
994 #else
995   if (aPixelsWidth != 0)
996   {
997     isBatchCopy = false;
998   }
999 #endif
1000   if (toConvRgba2Rgb)
1001   {
1002     Handle(NCollection_BaseAllocator) anAlloc = new NCollection_AlignedAllocator (16);
1003     const Standard_Size aRowSize = theImage.SizeX() * 4;
1004     NCollection_Buffer aRowBuffer (anAlloc);
1005     if (!aRowBuffer.Allocate (aRowSize))
1006     {
1007       return Standard_False;
1008     }
1009
1010     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
1011     {
1012       // Image_PixMap rows indexation always starts from the upper corner
1013       // while order in memory depends on the flag and processed by ChangeRow() method
1014       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, aRowBuffer.ChangeData());
1015       const Image_ColorRGBA* aRowDataRgba = (const Image_ColorRGBA* )aRowBuffer.Data();
1016       if (theImage.Format() == Image_Format_BGR)
1017       {
1018         convertRowFromRgba ((Image_ColorBGR* )theImage.ChangeRow (aRow), aRowDataRgba, theImage.SizeX());
1019       }
1020       else
1021       {
1022         convertRowFromRgba ((Image_ColorRGB* )theImage.ChangeRow (aRow), aRowDataRgba, theImage.SizeX());
1023       }
1024     }
1025   }
1026   else if (!isBatchCopy)
1027   {
1028     // copy row by row
1029     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
1030     {
1031       // Image_PixMap rows indexation always starts from the upper corner
1032       // while order in memory depends on the flag and processed by ChangeRow() method
1033       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
1034     }
1035   }
1036   else
1037   {
1038     glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
1039   }
1040   const bool hasErrors = theGlCtx->ResetErrors (true);
1041
1042   glPixelStorei (GL_PACK_ALIGNMENT,  1);
1043 #if !defined(GL_ES_VERSION_2_0)
1044   glPixelStorei (GL_PACK_ROW_LENGTH, 0);
1045 #endif
1046
1047   if (!theFbo.IsNull() && theFbo->IsValid())
1048   {
1049     theFbo->UnbindBuffer (theGlCtx);
1050   }
1051   else
1052   {
1053   #if !defined(GL_ES_VERSION_2_0)
1054     glReadBuffer (aReadBufferPrev);
1055   #endif
1056   }
1057
1058   if (toSwapRgbaBgra)
1059   {
1060     Image_PixMap::SwapRgbaBgra (theImage);
1061   }
1062
1063   return !hasErrors;
1064 }
1065
1066 // =======================================================================
1067 // function : EstimatedDataSize
1068 // purpose  :
1069 // =======================================================================
1070 Standard_Size OpenGl_FrameBuffer::EstimatedDataSize() const
1071 {
1072   if (!IsValid())
1073   {
1074     return 0;
1075   }
1076
1077   Standard_Size aSize = 0;
1078   for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
1079   {
1080     aSize += aTextureIt.Value()->EstimatedDataSize();
1081   }
1082   if (!myDepthStencilTexture.IsNull())
1083   {
1084     aSize += myDepthStencilTexture->EstimatedDataSize();
1085   }
1086   if (myGlColorRBufferId != NO_RENDERBUFFER
1087   && !myColorFormats.IsEmpty())
1088   {
1089     aSize += OpenGl_Texture::PixelSizeOfPixelFormat (myColorFormats.First()) * myInitVPSizeX * myInitVPSizeY;
1090   }
1091   if (myGlDepthRBufferId != NO_RENDERBUFFER)
1092   {
1093     aSize += OpenGl_Texture::PixelSizeOfPixelFormat (myDepthFormat) * myInitVPSizeX * myInitVPSizeY;
1094   }
1095   return aSize;
1096 }