0026636: BRepOffsetAPI_ThruSections algorithm crashes on two inconsistent wires
[occt.git] / src / OpenGl / OpenGl_Texture.cxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2013-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_Texture.hxx>
16
17 #include <OpenGl_ArbFBO.hxx>
18 #include <OpenGl_Context.hxx>
19 #include <OpenGl_GlCore15.hxx>
20 #include <Graphic3d_TextureParams.hxx>
21 #include <Standard_Assert.hxx>
22 #include <Image_PixMap.hxx>
23
24
25 //! Simple class to reset unpack alignment settings
26 struct OpenGl_UnpackAlignmentSentry
27 {
28
29   //! Reset unpack alignment settings to safe values
30   void Reset()
31   {
32     glPixelStorei (GL_UNPACK_ALIGNMENT,  1);
33   #if !defined(GL_ES_VERSION_2_0)
34     glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
35   #endif
36   }
37
38   ~OpenGl_UnpackAlignmentSentry()
39   {
40     Reset();
41   }
42
43 };
44
45 // =======================================================================
46 // function : OpenGl_Texture
47 // purpose  :
48 // =======================================================================
49 OpenGl_Texture::OpenGl_Texture (const Handle(Graphic3d_TextureParams)& theParams)
50 : OpenGl_Resource(),
51   myTextureId (NO_TEXTURE),
52   myTarget (GL_TEXTURE_2D),
53   mySizeX (0),
54   mySizeY (0),
55   myTextFormat (GL_RGBA),
56   myHasMipmaps (Standard_False),
57   myIsAlpha    (false),
58   myParams     (theParams)
59 {
60   if (myParams.IsNull())
61   {
62     myParams = new Graphic3d_TextureParams();
63   }
64 }
65
66 // =======================================================================
67 // function : ~OpenGl_Texture
68 // purpose  :
69 // =======================================================================
70 OpenGl_Texture::~OpenGl_Texture()
71 {
72   Release (NULL);
73 }
74
75 // =======================================================================
76 // function : HasMipmaps
77 // purpose  :
78 // =======================================================================
79 const Standard_Boolean OpenGl_Texture::HasMipmaps() const
80 {
81   return myHasMipmaps;
82 }
83
84 // =======================================================================
85 // function : GetParams
86 // purpose  :
87 // =======================================================================
88 const Handle(Graphic3d_TextureParams)& OpenGl_Texture::GetParams() const
89 {
90   return myParams;
91 }
92
93 // =======================================================================
94 // function : SetParams
95 // purpose  :
96 // =======================================================================
97 void OpenGl_Texture::SetParams (const Handle(Graphic3d_TextureParams)& theParams)
98 {
99   myParams = theParams;
100 }
101
102 // =======================================================================
103 // function : Create
104 // purpose  :
105 // =======================================================================
106 bool OpenGl_Texture::Create (const Handle(OpenGl_Context)& )
107 {
108   if (myTextureId == NO_TEXTURE)
109   {
110     glGenTextures (1, &myTextureId);
111   }
112   return myTextureId != NO_TEXTURE;
113 }
114
115 // =======================================================================
116 // function : Release
117 // purpose  :
118 // =======================================================================
119 void OpenGl_Texture::Release (OpenGl_Context* theGlCtx)
120 {
121   if (myTextureId == NO_TEXTURE)
122   {
123     return;
124   }
125
126   // application can not handle this case by exception - this is bug in code
127   Standard_ASSERT_RETURN (theGlCtx != NULL,
128     "OpenGl_Texture destroyed without GL context! Possible GPU memory leakage...",);
129
130   if (theGlCtx->IsValid())
131   {
132     glDeleteTextures (1, &myTextureId);
133   }
134   myTextureId = NO_TEXTURE;
135   mySizeX = mySizeY = 0;
136 }
137
138 // =======================================================================
139 // function : Bind
140 // purpose  :
141 // =======================================================================
142 void OpenGl_Texture::Bind (const Handle(OpenGl_Context)& theCtx,
143                            const GLenum theTextureUnit) const
144 {
145   if (theCtx->core15fwd != NULL)
146   {
147     theCtx->core15fwd->glActiveTexture (theTextureUnit);
148   }
149   glBindTexture (myTarget, myTextureId);
150 }
151
152 // =======================================================================
153 // function : Unbind
154 // purpose  :
155 // =======================================================================
156 void OpenGl_Texture::Unbind (const Handle(OpenGl_Context)& theCtx,
157                              const GLenum theTextureUnit) const
158 {
159   if (theCtx->core15fwd != NULL)
160   {
161     theCtx->core15fwd->glActiveTexture (theTextureUnit);
162   }
163   glBindTexture (myTarget, NO_TEXTURE);
164 }
165
166 //=======================================================================
167 //function : GetDataFormat
168 //purpose  :
169 //=======================================================================
170 bool OpenGl_Texture::GetDataFormat (const Handle(OpenGl_Context)& theCtx,
171                                     const Image_PixMap&           theData,
172                                     GLint&                        theTextFormat,
173                                     GLenum&                       thePixelFormat,
174                                     GLenum&                       theDataType)
175 {
176   theTextFormat  = GL_RGBA8;
177   thePixelFormat = 0;
178   theDataType    = 0;
179   switch (theData.Format())
180   {
181     case Image_PixMap::ImgGrayF:
182     {
183       if (theCtx->core11 == NULL)
184       {
185         theTextFormat  = GL_R8;  // GL_R32F
186         thePixelFormat = GL_RED;
187       }
188       else
189       {
190         theTextFormat  = GL_LUMINANCE8;
191         thePixelFormat = GL_LUMINANCE;
192       }
193       theDataType = GL_FLOAT;
194       return true;
195     }
196     case Image_PixMap::ImgAlphaF:
197     {
198       if (theCtx->core11 == NULL)
199       {
200         theTextFormat  = GL_R8;  // GL_R32F
201         thePixelFormat = GL_RED;
202       }
203       else
204       {
205         theTextFormat  = GL_ALPHA8;
206         thePixelFormat = GL_ALPHA;
207       }
208       theDataType = GL_FLOAT;
209       return true;
210     }
211     case Image_PixMap::ImgRGBAF:
212     {
213       theTextFormat  = GL_RGBA8; // GL_RGBA32F
214       thePixelFormat = GL_RGBA;
215       theDataType    = GL_FLOAT;
216       return true;
217     }
218     case Image_PixMap::ImgBGRAF:
219     {
220       if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
221       {
222         return false;
223       }
224       theTextFormat  = GL_RGBA8;    // GL_RGBA32F
225       thePixelFormat = GL_BGRA_EXT; // equals to GL_BGRA
226       theDataType    = GL_FLOAT;
227       return true;
228     }
229     case Image_PixMap::ImgRGBF:
230     {
231       theTextFormat  = GL_RGB8; // GL_RGB32F
232       thePixelFormat = GL_RGB;
233       theDataType    = GL_FLOAT;
234       return true;
235     }
236     case Image_PixMap::ImgBGRF:
237     {
238     #if !defined(GL_ES_VERSION_2_0)
239       theTextFormat  = GL_RGB8; // GL_RGB32F
240       thePixelFormat = GL_BGR;  // equals to GL_BGR_EXT
241       theDataType    = GL_FLOAT;
242       return true;
243     #else
244       return false;
245     #endif
246     }
247     case Image_PixMap::ImgRGBA:
248     {
249       theTextFormat = GL_RGBA8;
250       thePixelFormat = GL_RGBA;
251       theDataType    = GL_UNSIGNED_BYTE;
252       return true;
253     }
254     case Image_PixMap::ImgBGRA:
255     {
256       if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
257       {
258         return false;
259       }
260       theTextFormat  = GL_RGBA8;
261       thePixelFormat = GL_BGRA_EXT; // equals to GL_BGRA
262       theDataType    = GL_UNSIGNED_BYTE;
263       return true;
264     }
265     case Image_PixMap::ImgRGB32:
266     {
267       theTextFormat = GL_RGB8;
268       thePixelFormat = GL_RGBA;
269       theDataType    = GL_UNSIGNED_BYTE;
270       return true;
271     }
272     case Image_PixMap::ImgBGR32:
273     {
274       if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
275       {
276         return false;
277       }
278       theTextFormat  = GL_RGB8;
279       thePixelFormat = GL_BGRA_EXT; // equals to GL_BGRA
280       theDataType    = GL_UNSIGNED_BYTE;
281       return true;
282     }
283     case Image_PixMap::ImgRGB:
284     {
285       theTextFormat = GL_RGB8;
286       thePixelFormat = GL_RGB;
287       theDataType    = GL_UNSIGNED_BYTE;
288       return true;
289     }
290     case Image_PixMap::ImgBGR:
291     {
292     #if !defined(GL_ES_VERSION_2_0)
293       if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
294       {
295         return false;
296       }
297       theTextFormat = GL_RGB8;
298       thePixelFormat = GL_BGR; // equals to GL_BGR_EXT
299       theDataType    = GL_UNSIGNED_BYTE;
300       return true;
301     #else
302       return false;
303     #endif
304     }
305     case Image_PixMap::ImgGray:
306     {
307       if (theCtx->core11 == NULL)
308       {
309         theTextFormat  = GL_R8;
310         thePixelFormat = GL_RED;
311       }
312       else
313       {
314         theTextFormat  = GL_LUMINANCE8;
315         thePixelFormat = GL_LUMINANCE;
316       }
317       theDataType = GL_UNSIGNED_BYTE;
318       return true;
319     }
320     case Image_PixMap::ImgAlpha:
321     {
322       if (theCtx->core11 == NULL)
323       {
324         theTextFormat  = GL_R8;
325         thePixelFormat = GL_RED;
326       }
327       else
328       {
329         theTextFormat  = GL_ALPHA8;
330         thePixelFormat = GL_ALPHA;
331       }
332       theDataType = GL_UNSIGNED_BYTE;
333       return true;
334     }
335     case Image_PixMap::ImgUNKNOWN:
336     {
337       return false;
338     }
339   }
340   return false;
341 }
342
343 // =======================================================================
344 // function : Init
345 // purpose  :
346 // =======================================================================
347 bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
348                            const Standard_Integer        theTextFormat,
349                            const GLenum                  thePixelFormat,
350                            const GLenum                  theDataType,
351                            const Standard_Integer        theSizeX,
352                            const Standard_Integer        theSizeY,
353                            const Graphic3d_TypeOfTexture theType,
354                            const Image_PixMap*           theImage)
355 {
356   if (!Create (theCtx))
357   {
358     Release (theCtx.operator->());
359     return false;
360   }
361
362   if (theImage != NULL)
363   {
364     myIsAlpha = theImage->Format() == Image_PixMap::ImgAlpha
365              || theImage->Format() == Image_PixMap::ImgAlphaF;
366   }
367   else
368   {
369     myIsAlpha = thePixelFormat == GL_ALPHA;
370   }
371
372   myHasMipmaps             = Standard_False;
373   myTextFormat             = thePixelFormat;
374 #if !defined(GL_ES_VERSION_2_0)
375   const GLint anIntFormat  = theTextFormat;
376 #else
377   // ES does not support sized formats and format conversions - them detected from data type
378   const GLint anIntFormat  = thePixelFormat;
379 #endif
380   const GLsizei aWidth     = theSizeX;
381   const GLsizei aHeight    = theSizeY;
382   const GLsizei aMaxSize   = theCtx->MaxTextureSize();
383
384   // Notice that formally general NPOT textures are required by OpenGL 2.0 specifications
385   // however some hardware (NV30 - GeForce FX, RadeOn 9xxx and Xxxx) supports GLSL but not NPOT!
386   // Trying to create NPOT textures on such hardware will not fail
387   // but driver will fall back into software rendering,
388   const bool    toForceP2  = !theCtx->IsGlGreaterEqual (3, 0) && !theCtx->arbNPTW;
389   const GLsizei aWidthOut  = toForceP2 ? OpenGl_Context::GetPowerOfTwo (aWidth,  aMaxSize) : Min (aWidth,  aMaxSize);
390   const GLsizei aHeightOut = toForceP2 ? OpenGl_Context::GetPowerOfTwo (aHeight, aMaxSize) : Min (aHeight, aMaxSize);
391   const GLenum  aFilter    = (myParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
392   const GLenum  aWrapMode  = myParams->IsRepeat() ? GL_REPEAT : theCtx->TextureWrapClamp();
393
394 #if !defined(GL_ES_VERSION_2_0)
395   GLint aTestWidth  = 0;
396   GLint aTestHeight = 0;
397 #endif
398   GLvoid* aDataPtr = (theImage != NULL) ? (GLvoid* )theImage->Data() : NULL;
399
400   // setup the alignment
401   OpenGl_UnpackAlignmentSentry anUnpackSentry;
402   if (aDataPtr != NULL)
403   {
404     const GLint anAligment = Min ((GLint )theImage->MaxRowAligmentBytes(), 8); // OpenGL supports alignment upto 8 bytes
405     glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
406
407   #if !defined(GL_ES_VERSION_2_0)
408     // notice that GL_UNPACK_ROW_LENGTH is not available on OpenGL ES 2.0 without GL_EXT_unpack_subimage extension
409     const GLint anExtraBytes = GLint(theImage->RowExtraBytes());
410     const GLint aPixelsWidth = GLint(theImage->SizeRowBytes() / theImage->SizePixelBytes());
411     glPixelStorei (GL_UNPACK_ROW_LENGTH, (anExtraBytes >= anAligment) ? aPixelsWidth : 0);
412   #endif
413   }
414
415   switch (theType)
416   {
417     case Graphic3d_TOT_1D:
418     {
419     #if !defined(GL_ES_VERSION_2_0)
420       myTarget = GL_TEXTURE_1D;
421       Bind (theCtx);
422       glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
423       glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
424       glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
425
426       Image_PixMap aCopy;
427       if (aDataPtr != NULL)
428       {
429         if (aWidth != aWidthOut)
430         {
431           glPixelStorei (GL_PACK_ALIGNMENT,  1);
432           glPixelStorei (GL_PACK_ROW_LENGTH, 0);
433           if (!aCopy.InitTrash (theImage->Format(), Standard_Size(aWidthOut), 1)
434             || gluScaleImage (thePixelFormat,
435                               aWidth,    1, theDataType, theImage->Data(),
436                               aWidthOut, 1, theDataType, aCopy.ChangeData()) != 0)
437           {
438             Unbind (theCtx);
439             Release (theCtx.operator->());
440             return false;
441           }
442
443           aDataPtr = (GLvoid* )aCopy.Data();
444           anUnpackSentry.Reset();
445         }
446       }
447
448       // use proxy to check texture could be created or not
449       glTexImage1D (GL_PROXY_TEXTURE_1D, 0, anIntFormat,
450                     aWidthOut, 0,
451                     thePixelFormat, theDataType, NULL);
452       glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &aTestWidth);
453       if (aTestWidth == 0)
454       {
455         // no memory or broken input parameters
456         Unbind (theCtx);
457         Release (theCtx.operator->());
458         return false;
459       }
460
461       glTexImage1D (GL_TEXTURE_1D, 0, anIntFormat,
462                     aWidthOut, 0,
463                     thePixelFormat, theDataType, aDataPtr);
464       if (glGetError() != GL_NO_ERROR)
465       {
466         Unbind (theCtx);
467         Release (theCtx.operator->());
468         return false;
469       }
470
471       mySizeX = aWidthOut;
472       mySizeY = 1;
473
474       Unbind (theCtx);
475       return true;
476     #else
477       return false;
478     #endif
479     }
480     case Graphic3d_TOT_2D:
481     {
482       myTarget = GL_TEXTURE_2D;
483       Bind (theCtx);
484       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilter);
485       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
486       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
487       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
488
489       Image_PixMap aCopy;
490       if (aDataPtr != NULL)
491       {
492         if (aWidth != aWidthOut || aHeight != aHeightOut)
493         {
494         #if !defined(GL_ES_VERSION_2_0)
495           // scale texture
496           glPixelStorei (GL_PACK_ALIGNMENT,  1);
497           glPixelStorei (GL_PACK_ROW_LENGTH, 0);
498           if (!aCopy.InitTrash (theImage->Format(), Standard_Size(aWidthOut), Standard_Size(aHeightOut))
499             || gluScaleImage (thePixelFormat,
500                               aWidth,    aHeight,    theDataType, theImage->Data(),
501                               aWidthOut, aHeightOut, theDataType, aCopy.ChangeData()) != 0)
502           {
503             Unbind (theCtx);
504             Release (theCtx.operator->());
505             return false;
506           }
507
508           aDataPtr = (GLvoid* )aCopy.Data();
509           anUnpackSentry.Reset();
510         #else
511           Unbind (theCtx);
512           Release (theCtx.operator->());
513           return false;
514         #endif
515         }
516       }
517
518     #if !defined(GL_ES_VERSION_2_0)
519       // use proxy to check texture could be created or not
520       glTexImage2D (GL_PROXY_TEXTURE_2D, 0, anIntFormat,
521                     aWidthOut, aHeightOut, 0,
522                     thePixelFormat, theDataType, NULL);
523       glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH,  &aTestWidth);
524       glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &aTestHeight);
525       if (aTestWidth == 0 || aTestHeight == 0)
526       {
527         // no memory or broken input parameters
528         Unbind (theCtx);
529         Release (theCtx.operator->());
530         return false;
531       }
532     #endif
533
534       glTexImage2D (GL_TEXTURE_2D, 0, anIntFormat,
535                     aWidthOut, aHeightOut, 0,
536                     thePixelFormat, theDataType, aDataPtr);
537       if (glGetError() != GL_NO_ERROR)
538       {
539         Unbind (theCtx);
540         Release (theCtx.operator->());
541         return false;
542       }
543
544       mySizeX = aWidthOut;
545       mySizeY = aHeightOut;
546
547       Unbind (theCtx);
548       return true;
549     }
550     case Graphic3d_TOT_2D_MIPMAP:
551     {
552       myTarget     = GL_TEXTURE_2D;
553       myHasMipmaps = Standard_True;
554
555       GLenum aFilterMin = aFilter;
556       aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
557       if (myParams->Filter() == Graphic3d_TOTF_BILINEAR)
558       {
559         aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
560       }
561       else if (myParams->Filter() == Graphic3d_TOTF_TRILINEAR)
562       {
563         aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
564       }
565
566       Bind (theCtx);
567       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
568       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
569       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
570       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
571
572       if (theCtx->arbFBO != NULL
573        && aWidth == aWidthOut && aHeight == aHeightOut)
574       {
575       #if !defined(GL_ES_VERSION_2_0)
576         // use proxy to check texture could be created or not
577         glTexImage2D (GL_PROXY_TEXTURE_2D, 0, anIntFormat,
578                       aWidthOut, aHeightOut, 0,
579                       thePixelFormat, theDataType, NULL);
580         glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH,  &aTestWidth);
581         glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &aTestHeight);
582         if (aTestWidth == 0 || aTestHeight == 0)
583         {
584           // no memory or broken input parameters
585           Unbind (theCtx);
586           Release (theCtx.operator->());
587           return false;
588         }
589       #endif
590
591         // upload main picture
592         glTexImage2D (GL_TEXTURE_2D, 0, anIntFormat,
593                       aWidthOut, aHeightOut, 0,
594                       thePixelFormat, theDataType, theImage->Data());
595         if (glGetError() != GL_NO_ERROR)
596         {
597           Unbind (theCtx);
598           Release (theCtx.operator->());
599           return false;
600         }
601
602         mySizeX = aWidthOut;
603         mySizeY = aHeightOut;
604
605         // generate mipmaps
606         //glHint (GL_GENERATE_MIPMAP_HINT, GL_NICEST);
607         theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
608
609         Unbind (theCtx);
610         return true;
611       }
612       else
613       {
614       #if !defined(GL_ES_VERSION_2_0)
615         bool isCreated = gluBuild2DMipmaps (GL_TEXTURE_2D, anIntFormat,
616                                             aWidth, aHeight,
617                                             thePixelFormat, theDataType, theImage->Data()) == 0;
618         if (isCreated)
619         {
620           glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH,  &mySizeX);
621           glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &mySizeY);
622         }
623
624         Unbind (theCtx);
625         return isCreated;
626       #else
627         Unbind (theCtx);
628         return false;
629       #endif
630       }
631     }
632     default:
633     {
634       Release (theCtx.operator->());
635       return false;
636     }
637   }
638 }
639
640 // =======================================================================
641 // function : Init
642 // purpose  :
643 // =======================================================================
644 bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
645                            const Image_PixMap&           theImage,
646                            const Graphic3d_TypeOfTexture theType)
647 {
648   if (theImage.IsEmpty())
649   {
650     Release (theCtx.operator->());
651     return false;
652   }
653
654   GLenum aPixelFormat;
655   GLenum aDataType;
656   GLint aTextFormat;
657   if (!GetDataFormat (theCtx, theImage, aTextFormat, aPixelFormat, aDataType))
658   {
659     Release (theCtx.operator->());
660     return false;
661   }
662
663   return Init (theCtx,
664                aTextFormat, aPixelFormat, aDataType,
665                (Standard_Integer)theImage.SizeX(),
666                (Standard_Integer)theImage.SizeY(),
667                theType, &theImage);
668 }
669
670 // =======================================================================
671 // function : InitRectangle
672 // purpose  :
673 // =======================================================================
674 bool OpenGl_Texture::InitRectangle (const Handle(OpenGl_Context)& theCtx,
675                                     const Standard_Integer        theSizeX,
676                                     const Standard_Integer        theSizeY,
677                                     const OpenGl_TextureFormat&   theFormat)
678 {
679   if (!Create (theCtx) || !theCtx->IsGlGreaterEqual (3, 0))
680   {
681     return false;
682   }
683
684 #if !defined(GL_ES_VERSION_2_0)
685   myTarget = GL_TEXTURE_RECTANGLE;
686
687   const GLsizei aSizeX    = Min (theCtx->MaxTextureSize(), theSizeX);
688   const GLsizei aSizeY    = Min (theCtx->MaxTextureSize(), theSizeY);
689   const GLenum  aFilter   = (myParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
690   const GLenum  aWrapMode = myParams->IsRepeat() ? GL_REPEAT : theCtx->TextureWrapClamp();
691
692   Bind (theCtx);
693   glTexParameteri (myTarget, GL_TEXTURE_MIN_FILTER, aFilter);
694   glTexParameteri (myTarget, GL_TEXTURE_MAG_FILTER, aFilter);
695   glTexParameteri (myTarget, GL_TEXTURE_WRAP_S,     aWrapMode);
696   glTexParameteri (myTarget, GL_TEXTURE_WRAP_T,     aWrapMode);
697
698   const GLint anIntFormat = theFormat.Internal();
699   myTextFormat = theFormat.Format();
700
701   glTexImage2D (GL_PROXY_TEXTURE_RECTANGLE,
702                 0,
703                 anIntFormat,
704                 aSizeX,
705                 aSizeY,
706                 0,
707                 theFormat.Format(),
708                 GL_FLOAT,
709                 NULL);
710
711   GLint aTestSizeX = 0;
712   GLint aTestSizeY = 0;
713
714   glGetTexLevelParameteriv (
715     GL_PROXY_TEXTURE_RECTANGLE, 0, GL_TEXTURE_WIDTH,  &aTestSizeX);
716   glGetTexLevelParameteriv (
717     GL_PROXY_TEXTURE_RECTANGLE, 0, GL_TEXTURE_HEIGHT, &aTestSizeY);
718
719   if (aTestSizeX == 0 || aTestSizeY == 0)
720   {
721     Unbind (theCtx);
722     return false;
723   }
724
725   glTexImage2D (myTarget,
726                 0,
727                 anIntFormat,
728                 aSizeX,
729                 aSizeY,
730                 0,
731                 theFormat.Format(),
732                 GL_FLOAT,
733                 NULL);
734
735   if (glGetError() != GL_NO_ERROR)
736   {
737     Unbind (theCtx);
738     return false;
739   }
740
741   mySizeX = aSizeX;
742   mySizeY = aSizeY;
743
744   Unbind (theCtx);
745   return true;
746 #else
747   return false;
748 #endif
749 }