0031478: Visualization, TKOpenGl - allow uploading Cubemap in compressed DDS format...
[occt.git] / src / OpenGl / OpenGl_TextureFormat.hxx
1 // Copyright (c) 2017-2019 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #ifndef _OpenGl_TextureFormat_HeaderFile
15 #define _OpenGl_TextureFormat_HeaderFile
16
17 #include <Image_CompressedFormat.hxx>
18 #include <Image_Format.hxx>
19 #include <OpenGl_GlCore13.hxx>
20 #include <Standard_Handle.hxx>
21
22 class OpenGl_Context;
23
24 //! Stores parameters of OpenGL texture format.
25 class OpenGl_TextureFormat
26 {
27 public:
28
29   //! Returns texture format for specified type and number of channels.
30   //! @tparam theCompType component type
31   //! @tparam theNbComps  number of components
32   template<class theCompType, int theNbComps>
33   static OpenGl_TextureFormat Create();
34
35   //! Find texture format suitable to specified image format.
36   //! @param theCtx [in] OpenGL context defining supported texture formats
37   //! @param theFormat [in] image format
38   //! @param theIsColorMap [in] flag indicating color nature of image (to select sRGB texture)
39   //! @return found format or invalid format
40   Standard_EXPORT static OpenGl_TextureFormat FindFormat (const Handle(OpenGl_Context)& theCtx,
41                                                           Image_Format theFormat,
42                                                           bool theIsColorMap);
43
44   //! Find texture format suitable to specified internal (sized) texture format.
45   //! @param theCtx [in] OpenGL context defining supported texture formats
46   //! @param theSizedFormat [in] sized (internal) texture format (example: GL_RGBA8)
47   //! @return found format or invalid format
48   Standard_EXPORT static OpenGl_TextureFormat FindSizedFormat (const Handle(OpenGl_Context)& theCtx,
49                                                                GLint theSizedFormat);
50
51   //! Find texture format suitable to specified compressed texture format.
52   //! @param theCtx [in] OpenGL context defining supported texture formats
53   //! @param theFormat [in] compressed texture format
54   //! @return found format or invalid format
55   Standard_EXPORT static OpenGl_TextureFormat FindCompressedFormat (const Handle(OpenGl_Context)& theCtx,
56                                                                     Image_CompressedFormat theFormat,
57                                                                     bool theIsColorMap);
58
59 public:
60
61   //! Empty constructor (invalid texture format).
62   OpenGl_TextureFormat() : myInternalFormat (0), myPixelFormat (0), myDataType (0), myNbComponents (0) {}
63
64   //! Return TRUE if format is defined.
65   bool IsValid() const
66   {
67     return myInternalFormat != 0
68         && myPixelFormat != 0
69         && myDataType != 0;
70   }
71
72   //! Returns OpenGL internal format of the pixel data (example: GL_R32F).
73   GLint InternalFormat() const { return myInternalFormat; }
74
75   //! Sets texture internal format.
76   void SetInternalFormat (GLint theInternal) { myInternalFormat = theInternal; }
77
78   //! Returns OpenGL format of the pixel data (example: GL_RED).
79   GLenum PixelFormat() const { return myPixelFormat; }
80
81   //! Sets OpenGL format of the pixel data.
82   void SetPixelFormat (GLenum theFormat) { myPixelFormat = theFormat; }
83
84   //! Returns OpenGL data type of the pixel data (example: GL_FLOAT).
85   GLint DataType() const { return myDataType; }
86
87   //! Sets OpenGL data type of the pixel data.
88   void SetDataType (GLint theType) { myDataType = theType; }
89
90   //! Returns number of components (channels). Here for debugging purposes.
91   GLint NbComponents() const { return myNbComponents; }
92
93   //! Sets number of components (channels).
94   void SetNbComponents (GLint theNbComponents) { myNbComponents = theNbComponents; }
95
96   //! Return TRUE if internal texture format is sRGB(A).
97   bool IsSRGB() const
98   {
99     return myInternalFormat == GL_SRGB8
100         || myInternalFormat == GL_SRGB8_ALPHA8;
101   }
102
103 public:
104
105   //! Returns OpenGL internal format of the pixel data (example: GL_R32F).
106   GLint Internal() const { return myInternalFormat; }
107
108   //! Returns OpenGL format of the pixel data (example: GL_RED).
109   GLenum Format() const { return myPixelFormat; }
110
111 private:
112
113   GLint  myInternalFormat; //!< OpenGL internal format of the pixel data
114   GLenum myPixelFormat;    //!< OpenGL pixel format
115   GLint  myDataType;       //!< OpenGL data type of input pixel data
116   GLint  myNbComponents;   //!< number of channels for each pixel (from 1 to 4)
117
118 };
119
120 //! Selects preferable texture format for specified parameters.
121 template<class T> struct OpenGl_TextureFormatSelector
122 {
123   // Not implemented
124 };
125
126 //! Specialization for unsigned byte.
127 template<> struct OpenGl_TextureFormatSelector<GLubyte>
128 {
129   static GLint DataType() { return GL_UNSIGNED_BYTE; }
130   static GLint Internal (GLuint theChannels)
131   {
132     switch (theChannels)
133     {
134       case 1:  return GL_R8;
135       case 2:  return GL_RG8;
136       case 3:  return GL_RGB8;
137       case 4:  return GL_RGBA8;
138       default: return GL_NONE;
139     }
140   }
141 };
142
143 //! Specialization for unsigned short.
144 template<> struct OpenGl_TextureFormatSelector<GLushort>
145 {
146   static GLint DataType() { return GL_UNSIGNED_SHORT; }
147   static GLint Internal (GLuint theChannels)
148   {
149     switch (theChannels)
150     {
151       case 1:  return GL_R16;
152       case 2:  return GL_RG16;
153       case 3:  return GL_RGB16;
154       case 4:  return GL_RGBA16;
155       default: return GL_NONE;
156     }
157   }
158 };
159
160 //! Specialization for float.
161 template<> struct OpenGl_TextureFormatSelector<GLfloat>
162 {
163   static GLint DataType() { return GL_FLOAT; }
164   static GLint Internal (GLuint theChannels)
165   {
166     switch (theChannels)
167     {
168       case 1:  return GL_R32F;
169       case 2:  return GL_RG32F;
170       case 3:  return GL_RGB32F;
171       case 4:  return GL_RGBA32F;
172       default: return GL_NONE;
173     }
174   }
175 };
176
177 //! Specialization for unsigned int.
178 template<> struct OpenGl_TextureFormatSelector<GLuint>
179 {
180   static GLint DataType() { return GL_UNSIGNED_INT; }
181   static GLint Internal (GLuint theChannels)
182   {
183     switch (theChannels)
184     {
185       case 1:  return GL_RED;
186       case 2:  return GL_RG;
187       case 3:  return GL_RGB;
188       case 4:  return GL_RGBA;
189       default: return GL_NONE;
190     }
191   }
192 };
193
194 //! Specialization for signed byte.
195 template<> struct OpenGl_TextureFormatSelector<GLbyte>
196 {
197   static GLint DataType() { return GL_BYTE; }
198   static GLint Internal (GLuint theChannels)
199   {
200     switch (theChannels)
201     {
202       case 1:  return GL_R8_SNORM;
203       case 2:  return GL_RG8_SNORM;
204       case 3:  return GL_RGB8_SNORM;
205       case 4:  return GL_RGBA8_SNORM;
206       default: return GL_NONE;
207     }
208   }
209 };
210
211 //! Specialization for signed short.
212 template<> struct OpenGl_TextureFormatSelector<GLshort>
213 {
214   static GLint DataType() { return GL_SHORT; }
215   static GLint Internal (GLuint theChannels)
216   {
217     switch (theChannels)
218     {
219       case 1:  return GL_R16_SNORM;
220       case 2:  return GL_RG16_SNORM;
221       case 3:  return GL_RGB16_SNORM;
222       case 4:  return GL_RGBA16_SNORM;
223       default: return GL_NONE;
224     }
225   }
226 };
227
228 //! Specialization for signed int.
229 template<> struct OpenGl_TextureFormatSelector<GLint>
230 {
231   static GLint DataType() { return GL_INT; }
232   static GLint Internal (GLuint theChannels)
233   {
234     switch (theChannels)
235     {
236       case 1:  return GL_RED_SNORM;
237       case 2:  return GL_RG_SNORM;
238       case 3:  return GL_RGB_SNORM;
239       case 4:  return GL_RGBA_SNORM;
240       default: return GL_NONE;
241     }
242   }
243 };
244
245 // =======================================================================
246 // function : Create
247 // purpose  :
248 // =======================================================================
249 template<class theCompType, int theNbComps>
250 inline OpenGl_TextureFormat OpenGl_TextureFormat::Create()
251 {
252   OpenGl_TextureFormat aFormat;
253   aFormat.SetNbComponents (theNbComps);
254   aFormat.SetInternalFormat (OpenGl_TextureFormatSelector<theCompType>::Internal (theNbComps));
255   aFormat.SetDataType (OpenGl_TextureFormatSelector<theCompType>::DataType());
256   GLenum aPixelFormat = GL_NONE;
257   switch (theNbComps)
258   {
259     case 1: aPixelFormat = GL_RED;  break;
260     case 2: aPixelFormat = GL_RG;   break;
261     case 3: aPixelFormat = GL_RGB;  break;
262     case 4: aPixelFormat = GL_RGBA; break;
263   }
264   aFormat.SetPixelFormat (aPixelFormat);
265   return aFormat;
266 }
267
268 #endif // _OpenGl_TextureFormat_HeaderFile