20f8f0095d47b2a17d8964ce1b5c75329c39c7f5
[occt.git] / src / OpenGl / OpenGl_Texture.hxx
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 #ifndef _OpenGl_Texture_H__
16 #define _OpenGl_Texture_H__
17
18 #include <OpenGl_GlCore13.hxx>
19 #include <OpenGl_Resource.hxx>
20 #include <Graphic3d_TypeOfTexture.hxx>
21
22 class OpenGl_Context;
23 class Image_PixMap;
24
25 //! Selects preferable texture format for specified parameters.
26 template<class T>
27 struct OpenGl_TextureFormatSelector
28 {
29   // Not implemented
30 };
31
32 template<>
33 struct OpenGl_TextureFormatSelector<GLubyte>
34 {
35   static GLint Internal (GLuint theChannels)
36   {
37     switch (theChannels)
38     {
39       case 1:
40         return GL_R8;
41       case 2:
42         return GL_RG8;
43       case 3:
44         return GL_RGB8;
45       case 4:
46         return GL_RGBA8;
47       default:
48         return GL_NONE;
49     }
50   }
51 };
52
53 template<>
54 struct OpenGl_TextureFormatSelector<GLushort>
55 {
56   static GLint Internal (GLuint theChannels)
57   {
58     switch (theChannels)
59     {
60       case 1:
61         return GL_R16;
62       case 2:
63         return GL_RG16;
64       case 3:
65         return GL_RGB16;
66       case 4:
67         return GL_RGBA16;
68       default:
69         return GL_NONE;
70     }
71   }
72 };
73
74 template<>
75 struct OpenGl_TextureFormatSelector<GLfloat>
76 {
77   static GLint Internal (GLuint theChannels)
78   {
79     switch (theChannels)
80     {
81       case 1:
82         return GL_R32F;
83       case 2:
84         return GL_RG32F;
85       case 3:
86         return GL_RGB32F;
87       case 4:
88         return GL_RGBA32F;
89       default:
90         return GL_NONE;
91     }
92   }
93 };
94
95 //! Stores parameters of OpenGL texture format.
96 class OpenGl_TextureFormat
97 {
98   friend class OpenGl_Texture;
99
100 public:
101
102   //! Returns OpenGL format of the pixel data.
103   inline GLenum Format() const
104   {
105     switch (myChannels)
106     {
107       case 1:
108         return GL_RED;
109       case 2:
110         return GL_RG;
111       case 3:
112         return GL_RGB;
113       case 4:
114         return GL_RGBA;
115       default:
116         return GL_NONE;
117     }
118   }
119
120   //! Returns OpenGL internal format of the pixel data.
121   inline GLint Internal() const
122   {
123     return myInternal;
124   }
125
126   //! Returns texture format for specified type and number of channels.
127   template<class T, int N>
128   static OpenGl_TextureFormat Create()
129   {
130     return OpenGl_TextureFormat (N, OpenGl_TextureFormatSelector<T>::Internal (N));
131   }
132
133 private:
134
135   //! Creates new texture format.
136   OpenGl_TextureFormat (const GLint theChannels,
137                         const GLint theInternal)
138   : myInternal (theInternal),
139     myChannels (theChannels) {}
140
141 private:
142
143   GLint myInternal; //!< OpenGL internal format of the pixel data
144   GLint myChannels; //!< Number of channels for each pixel (from 1 to 4)
145
146 };
147
148 //! Texture resource.
149 class OpenGl_Texture : public OpenGl_Resource
150 {
151
152 public:
153
154   //! Helpful constants
155   static const GLuint NO_TEXTURE = 0;
156
157 public:
158
159   //! Create uninitialized VBO.
160   Standard_EXPORT OpenGl_Texture (const Handle(Graphic3d_TextureParams)& theParams = NULL);
161
162   //! Destroy object.
163   Standard_EXPORT virtual ~OpenGl_Texture();
164
165   //! @return true if current object was initialized
166   inline bool IsValid() const
167   {
168     return myTextureId != NO_TEXTURE;
169   }
170
171   //! @return target to which the texture is bound (GL_TEXTURE_1D, GL_TEXTURE_2D)
172   inline GLenum GetTarget() const
173   {
174     return myTarget;
175   }
176
177   //! @return texture width (0 LOD)
178   inline GLsizei SizeX() const
179   {
180     return mySizeX;
181   }
182
183   //! @return texture height (0 LOD)
184   inline GLsizei SizeY() const
185   {
186     return mySizeY;
187   }
188
189   //! @return texture ID
190   inline GLuint TextureId() const
191   {
192     return myTextureId;
193   }
194
195   //! @return texture format (not sized)
196   inline GLenum GetFormat() const
197   {
198     return myTextFormat;
199   }
200
201   //! Return true for GL_RED and GL_ALPHA formats.
202   bool IsAlpha() const
203   {
204     return myIsAlpha;
205   }
206
207   //! Setup to interprete the format as Alpha by Shader Manager
208   //! (should be GL_ALPHA within compatible context or GL_RED otherwise).
209   void SetAlpha (const bool theValue)
210   {
211     myIsAlpha = theValue;
212   }
213
214   //! Creates Texture id if not yet generated.
215   //! Data should be initialized by another method.
216   Standard_EXPORT bool Create (const Handle(OpenGl_Context)& theCtx);
217
218   //! Destroy object - will release GPU memory if any.
219   Standard_EXPORT virtual void Release (OpenGl_Context* theCtx);
220
221   //! Bind this Texture to specified unit.
222   Standard_EXPORT void Bind (const Handle(OpenGl_Context)& theCtx,
223                              const GLenum                  theTextureUnit = GL_TEXTURE0) const;
224
225   //! Unbind texture from specified unit.
226   Standard_EXPORT void Unbind (const Handle(OpenGl_Context)& theCtx,
227                                const GLenum                  theTextureUnit = GL_TEXTURE0) const;
228
229   //! Notice that texture will be unbound after this call.
230   Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theCtx,
231                              const Image_PixMap&           theImage,
232                              const Graphic3d_TypeOfTexture theType);
233
234   //! Initialize the texture with specified format, size and texture type.
235   //! If theImage is empty the texture data will contain trash.
236   //! Notice that texture will be unbound after this call.
237   Standard_EXPORT bool Init (const Handle(OpenGl_Context)& theCtx,
238                              const GLint                   theTextFormat,
239                              const GLenum                  thePixelFormat,
240                              const GLenum                  theDataType,
241                              const GLsizei                 theSizeX,
242                              const GLsizei                 theSizeY,
243                              const Graphic3d_TypeOfTexture theType,
244                              const Image_PixMap*           theImage = NULL);
245
246   //! Allocates texture rectangle with specified format and size.
247   //! \note Texture data is not initialized (will contain trash).
248   Standard_EXPORT bool InitRectangle (const Handle(OpenGl_Context)& theCtx,
249                                       const Standard_Integer        theSizeX,
250                                       const Standard_Integer        theSizeY,
251                                       const OpenGl_TextureFormat&   theFormat);
252
253   //! @return true if texture was generated within mipmaps
254   Standard_EXPORT const Standard_Boolean HasMipmaps() const;
255
256   //! @return assigned texture parameters (not necessary applied)
257   Standard_EXPORT const Handle(Graphic3d_TextureParams)& GetParams() const;
258
259   //! @param texture parameters
260   Standard_EXPORT void SetParams (const Handle(Graphic3d_TextureParams)& theParams);
261
262   //! Return texture type and format by Image_PixMap data format.
263   Standard_EXPORT static bool GetDataFormat (const Handle(OpenGl_Context)& theCtx,
264                                              const Image_PixMap&           theData,
265                                              GLint&                        theTextFormat,
266                                              GLenum&                       thePixelFormat,
267                                              GLenum&                       theDataType);
268
269 protected:
270
271   GLuint           myTextureId;  //!< GL resource ID
272   GLenum           myTarget;     //!< GL_TEXTURE_1D/GL_TEXTURE_2D
273   GLsizei          mySizeX;      //!< texture width
274   GLsizei          mySizeY;      //!< texture height
275   GLenum           myTextFormat; //!< texture format - GL_RGB, GL_RGBA,...
276   Standard_Boolean myHasMipmaps; //!< flag indicates that texture was uploaded with mipmaps
277   bool             myIsAlpha;    //!< indicates alpha format
278
279   Handle(Graphic3d_TextureParams) myParams; //!< texture parameters
280
281 public:
282
283   DEFINE_STANDARD_RTTI(OpenGl_Texture, OpenGl_Resource) // Type definition
284
285 };
286
287 #endif // _OpenGl_Texture_H__