4986ed471cd5380819e44a9b8ca3d4e4a8bbdf7d
[glBitmap.git] / glBitmap.pas
1 {***********************************************************
2 glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
3 http://www.opengl24.de/index.php?cat=header&file=glbitmap
4
5 modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
6
7 ------------------------------------------------------------
8 The contents of this file are used with permission, subject to
9 the Mozilla Public License Version 1.1 (the "License"); you may
10 not use this file except in compliance with the License. You may
11 obtain a copy of the License at
12 http://www.mozilla.org/MPL/MPL-1.1.html
13 ------------------------------------------------------------
14 Version 3.0.1
15 ------------------------------------------------------------
16 History
17 20-11-2013
18 - refactoring of the complete library
19 21-03-2010
20 - The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi
21   then it's your problem if that isn't true. This prevents the unit for incompatibility
22   with newer versions of Delphi.
23 - Problems with D2009+ resolved (Thanks noeska and all i forgot)
24 - GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson)
25 10-08-2008
26 - AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson)
27 - Additional Datapointer for functioninterface now has the name CustomData
28 24-07-2008
29 - AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson)
30 - If you load an texture from an file the property Filename will be set to the name of the file
31 - Three new properties to attach custom data to the Texture objects
32   - CustomName  (free for use string)
33   - CustomNameW (free for use widestring)
34   - CustomDataPointer (free for use pointer to attach other objects or complex structures)
35 27-05-2008
36 - RLE TGAs loaded much faster
37 26-05-2008
38 - fixed some problem with reading RLE TGAs.
39 21-05-2008
40 - function clone now only copys data if it's assigned and now it also copies the ID
41 - it seems that lazarus dont like comments in comments.
42 01-05-2008
43 - It's possible to set the id of the texture
44 - define GLB_NO_NATIVE_GL deactivated by default
45 27-04-2008
46 - Now supports the following libraries
47   - SDL and SDL_image
48   - libPNG
49   - libJPEG
50 - Linux compatibillity via free pascal compatibility (delphi sources optional)
51 - BMPs now loaded manuel
52 - Large restructuring
53 - Property DataPtr now has the name Data
54 - Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR
55 - Unused Depth removed
56 - Function FreeData to freeing image data added
57 24-10-2007
58 - ImageID flag of TGAs was ignored. (Thanks Zwoetzen)
59 15-11-2006
60 - Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER)
61 - Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel
62 - Function ReadOpenGLExtension is now only intern
63 29-06-2006
64 - pngimage now disabled by default like all other versions.
65 26-06-2006
66 - Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi)
67 22-06-2006
68 - Fixed some Problem with Delphi 5
69 - Now uses the newest version of pngimage. Makes saving pngs much easier.
70 22-03-2006
71 - Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi)
72 09-03-2006
73 - Internal Format ifDepth8 added
74 - function GrabScreen now supports all uncompressed formats
75 31-01-2006
76 - AddAlphaFromglBitmap implemented
77 29-12-2005
78 - LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID)
79 28-12-2005
80 - Width, Height and Depth internal changed to TglBitmapPixelPosition.
81   property Width, Height, Depth are still existing and new property Dimension are avail
82 11-12-2005
83 - Added native OpenGL Support. Breaking the dglOpenGL "barrier".
84 19-10-2005
85 - Added function GrabScreen to class TglBitmap2D
86 18-10-2005
87 - Added support to Save images
88 - Added function Clone to Clone Instance
89 11-10-2005
90 - Functions now works with Cardinals for each channel. Up to 32 Bits per channel.
91   Usefull for Future
92 - Several speed optimizations
93 09-10-2005
94 - Internal structure change. Loading of TGA, PNG and DDS improved.
95   Data, format and size will now set directly with SetDataPtr.
96 - AddFunc now works with all Types of Images and Formats
97 - Some Funtions moved to Baseclass TglBitmap
98 06-10-2005
99 - Added Support to decompress DXT3 and DXT5 compressed Images.
100 - Added Mapping to convert data from one format into an other.
101 05-10-2005
102 - Added method ConvertTo in Class TglBitmap2D. Method allows to convert every
103   supported Input format (supported by GetPixel) into any uncompresed Format
104 - Added Support to decompress DXT1 compressed Images.
105 - SwapColors replaced by ConvertTo
106 04-10-2005
107 - Added Support for compressed DDSs
108 - Added new internal formats (DXT1, DXT3, DXT5)
109 29-09-2005
110 - Parameter Components renamed to InternalFormat
111 23-09-2005
112 - Some AllocMem replaced with GetMem (little speed change)
113 - better exception handling. Better protection from memory leaks.
114 22-09-2005
115 - Added support for Direct Draw Surfaces (.DDS) (uncompressed images only)
116 - Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5)
117 07-09-2005
118 - Added support for Grayscale textures
119 - Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8)
120 10-07-2005
121 - Added support for GL_VERSION_2_0
122 - Added support for GL_EXT_texture_filter_anisotropic
123 04-07-2005
124 - Function FillWithColor fills the Image with one Color
125 - Function LoadNormalMap added
126 30-06-2005
127 - ToNormalMap allows to Create an NormalMap from the Alphachannel
128 - ToNormalMap now supports Sobel (nmSobel) function.
129 29-06-2005
130 - support for RLE Compressed RGB TGAs added
131 28-06-2005
132 - Class TglBitmapNormalMap added to support Normalmap generation
133 - Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures.
134   3 Filters are supported. (4 Samples, 3x3 and 5x5)
135 16-06-2005
136 - Method LoadCubeMapClass removed
137 - LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures
138 - virtual abstract method GenTexture in class TglBitmap now is protected
139 12-06-2005
140 - now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal
141 10-06-2005
142 - little enhancement for IsPowerOfTwo
143 - TglBitmap1D.GenTexture now tests NPOT Textures
144 06-06-2005
145 - some little name changes. All properties or function with Texture in name are
146   now without texture in name. We have allways texture so we dosn't name it.
147 03-06-2005
148 - GenTexture now tests if texture is NPOT and NPOT-Texture are supported or
149   TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception.
150 02-06-2005
151 - added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle
152 25-04-2005
153 - Function Unbind added
154 - call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture.
155 21-04-2005
156 - class TglBitmapCubeMap added (allows to Create Cubemaps)
157 29-03-2005
158 - Added Support for PNG Images. (http://pngdelphi.sourceforge.net/)
159   To Enable png's use the define pngimage
160 22-03-2005
161 - New Functioninterface added
162 - Function GetPixel added
163 27-11-2004
164 - Property BuildMipMaps renamed to MipMap
165 21-11-2004
166 - property Name removed.
167 - BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap
168 22-05-2004
169 - property name added. Only used in glForms!
170 26-11-2003
171 - property FreeDataAfterGenTexture is now available as default (default = true)
172 - BuildMipmaps now implemented in TglBitmap1D (i've forgotten it)
173 - function MoveMemory replaced with function Move (little speed change)
174 - several calculations stored in variables (little speed change)
175 29-09-2003
176 - property BuildMipsMaps added (default = true)
177   if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps
178 - property FreeDataAfterGenTexture added (default = true)
179   if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated.
180 - parameter DisableOtherTextureUnits of Bind removed
181 - parameter FreeDataAfterGeneration of GenTextures removed
182 12-09-2003
183 - TglBitmap dosn't delete data if class was destroyed (fixed)
184 09-09-2003
185 - Bind now enables TextureUnits (by params)
186 - GenTextures can leave data (by param)
187 - LoadTextures now optimal
188 03-09-2003
189 - Performance optimization in AddFunc
190 - procedure Bind moved to subclasses
191 - Added new Class TglBitmap1D to support real OpenGL 1D Textures
192 19-08-2003
193 - Texturefilter and texturewrap now also as defaults
194   Minfilter = GL_LINEAR_MIPMAP_LINEAR
195   Magfilter = GL_LINEAR
196   Wrap(str) = GL_CLAMP_TO_EDGE
197 - Added new format tfCompressed to create a compressed texture.
198 - propertys IsCompressed, TextureSize and IsResident added
199   IsCompressed and TextureSize only contains data from level 0
200 18-08-2003
201 - Added function AddFunc to add PerPixelEffects to Image
202 - LoadFromFunc now based on AddFunc
203 - Invert now based on AddFunc
204 - SwapColors now based on AddFunc
205 16-08-2003
206 - Added function FlipHorz
207 15-08-2003
208 - Added function LaodFromFunc to create images with function
209 - Added function FlipVert
210 - Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported
211 29-07-2003
212 - Added Alphafunctions to calculate alpha per function
213 - Added Alpha from ColorKey using alphafunctions
214 28-07-2003
215 - First full functionally Version of glBitmap
216 - Support for 24Bit and 32Bit TGA Pictures added
217 25-07-2003
218 - begin of programming
219 ***********************************************************}
220 unit glBitmap;
221
222 // Please uncomment the defines below to configure the glBitmap to your preferences.
223 // If you have configured the unit you can uncomment the warning above.
224 {.$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'}
225
226 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
227 // Preferences ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
228 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
229 // enable OpenGL ES support
230 {.$DEFINE OPENGL_ES_1_1}
231 {.$DEFINE OPENGL_ES_2_0}
232 {.$DEFINE OPENGL_ES_3_0}
233 {.$DEFINE OPENGL_ES_EXT}
234
235 // activate to enable build-in OpenGL support with statically linked methods
236 // use dglOpenGL.pas if not enabled
237 {.$DEFINE GLB_NATIVE_OGL_STATIC}
238
239 // activate to enable build-in OpenGL support with dynamically linked methods
240 // use dglOpenGL.pas if not enabled
241 {.$DEFINE GLB_NATIVE_OGL_DYNAMIC}
242
243
244 // activate to enable the support for SDL_surfaces
245 {.$DEFINE GLB_SDL}
246
247 // activate  to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
248 {.$DEFINE GLB_DELPHI}
249
250 // activate to enable the support for TLazIntfImage from Lazarus
251 {.$DEFINE GLB_LAZARUS}
252
253
254
255 // activate to enable the support of SDL_image to load files. (READ ONLY)
256 // If you enable SDL_image all other libraries will be ignored!
257 {.$DEFINE GLB_SDL_IMAGE}
258
259
260
261 // activate to enable Lazarus TPortableNetworkGraphic support
262 // if you enable this pngImage and libPNG will be ignored
263 {.$DEFINE GLB_LAZ_PNG}
264
265 // activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
266 // if you enable pngimage the libPNG will be ignored
267 {.$DEFINE GLB_PNGIMAGE}
268
269 // activate to use the libPNG -> http://www.libpng.org/
270 // You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
271 {.$DEFINE GLB_LIB_PNG}
272
273
274
275 // activate to enable Lazarus TJPEGImage support
276 // if you enable this delphi jpegs and libJPEG will be ignored
277 {.$DEFINE GLB_LAZ_JPEG}
278
279 // if you enable delphi jpegs the libJPEG will be ignored
280 {.$DEFINE GLB_DELPHI_JPEG}
281
282 // activate to use the libJPEG -> http://www.ijg.org/
283 // You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
284 {.$DEFINE GLB_LIB_JPEG}
285
286
287 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
288 // PRIVATE: do not change anything! //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
289 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
290 // Delphi Versions
291 {$IFDEF fpc}
292   {$MODE Delphi}
293
294   {$IFDEF CPUI386}
295     {$DEFINE CPU386}
296     {$ASMMODE INTEL}
297   {$ENDIF}
298
299   {$IFNDEF WINDOWS}
300     {$linklib c}
301   {$ENDIF}
302 {$ENDIF}
303
304 // Operation System
305 {$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
306   {$DEFINE GLB_WIN}
307 {$ELSEIF DEFINED(LINUX)}
308   {$DEFINE GLB_LINUX}
309 {$IFEND}
310
311 // OpenGL ES
312 {$IF DEFINED(OPENGL_ES_EXT)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
313 {$IF DEFINED(OPENGL_ES_3_0)} {$DEFINE OPENGL_ES_2_0} {$IFEND}
314 {$IF DEFINED(OPENGL_ES_2_0)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
315 {$IF DEFINED(OPENGL_ES_1_1)} {$DEFINE OPENGL_ES}     {$IFEND}
316
317 // native OpenGL Support
318 {$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
319   {$IFDEF OPENGL_ES}
320     {$ERROR 'native OpenGL is not supported yet for OpenGL ES, please use dglOpenGLES.pas instead'}
321   {$ELSE}
322     {$DEFINE GLB_NATIVE_OGL}
323   {$ENDIF}
324 {$IFEND}
325
326 // checking define combinations
327 //SDL Image
328 {$IFDEF GLB_SDL_IMAGE}
329   {$IFNDEF GLB_SDL}
330     {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'}
331     {$DEFINE GLB_SDL}
332   {$ENDIF}
333
334   {$IFDEF GLB_LAZ_PNG}
335     {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'}
336     {$undef GLB_LAZ_PNG}
337   {$ENDIF}
338
339   {$IFDEF GLB_PNGIMAGE}
340     {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'}
341     {$undef GLB_PNGIMAGE}
342   {$ENDIF}
343
344   {$IFDEF GLB_LAZ_JPEG}
345     {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'}
346     {$undef GLB_LAZ_JPEG}
347   {$ENDIF}
348
349   {$IFDEF GLB_DELPHI_JPEG}
350     {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'}
351     {$undef GLB_DELPHI_JPEG}
352   {$ENDIF}
353
354   {$IFDEF GLB_LIB_PNG}
355     {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'}
356     {$undef GLB_LIB_PNG}
357   {$ENDIF}
358
359   {$IFDEF GLB_LIB_JPEG}
360     {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'}
361     {$undef GLB_LIB_JPEG}
362   {$ENDIF}
363
364   {$DEFINE GLB_SUPPORT_PNG_READ}
365   {$DEFINE GLB_SUPPORT_JPEG_READ}
366 {$ENDIF}
367
368 // Lazarus TPortableNetworkGraphic
369 {$IFDEF GLB_LAZ_PNG}
370   {$IFNDEF GLB_LAZARUS}
371     {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'}
372     {$DEFINE GLB_LAZARUS}
373   {$ENDIF}
374
375   {$IFDEF GLB_PNGIMAGE}
376     {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
377     {$undef GLB_PNGIMAGE}
378   {$ENDIF}
379
380   {$IFDEF GLB_LIB_PNG}
381     {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
382     {$undef GLB_LIB_PNG}
383   {$ENDIF}
384
385   {$DEFINE GLB_SUPPORT_PNG_READ}
386   {$DEFINE GLB_SUPPORT_PNG_WRITE}
387 {$ENDIF}
388
389 // PNG Image
390 {$IFDEF GLB_PNGIMAGE}
391   {$IFDEF GLB_LIB_PNG}
392     {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'}
393     {$undef GLB_LIB_PNG}
394   {$ENDIF}
395
396   {$DEFINE GLB_SUPPORT_PNG_READ}
397   {$DEFINE GLB_SUPPORT_PNG_WRITE}
398 {$ENDIF}
399
400 // libPNG
401 {$IFDEF GLB_LIB_PNG}
402   {$DEFINE GLB_SUPPORT_PNG_READ}
403   {$DEFINE GLB_SUPPORT_PNG_WRITE}
404 {$ENDIF}
405
406 // Lazarus TJPEGImage
407 {$IFDEF GLB_LAZ_JPEG}
408   {$IFNDEF GLB_LAZARUS}
409     {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'}
410     {$DEFINE GLB_LAZARUS}
411   {$ENDIF}
412
413   {$IFDEF GLB_DELPHI_JPEG}
414     {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'}
415     {$undef GLB_DELPHI_JPEG}
416   {$ENDIF}
417
418   {$IFDEF GLB_LIB_JPEG}
419     {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'}
420     {$undef GLB_LIB_JPEG}
421   {$ENDIF}
422
423   {$DEFINE GLB_SUPPORT_JPEG_READ}
424   {$DEFINE GLB_SUPPORT_JPEG_WRITE}
425 {$ENDIF}
426
427 // JPEG Image
428 {$IFDEF GLB_DELPHI_JPEG}
429   {$IFDEF GLB_LIB_JPEG}
430     {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'}
431     {$undef GLB_LIB_JPEG}
432   {$ENDIF}
433
434   {$DEFINE GLB_SUPPORT_JPEG_READ}
435   {$DEFINE GLB_SUPPORT_JPEG_WRITE}
436 {$ENDIF}
437
438 // libJPEG
439 {$IFDEF GLB_LIB_JPEG}
440   {$DEFINE GLB_SUPPORT_JPEG_READ}
441   {$DEFINE GLB_SUPPORT_JPEG_WRITE}
442 {$ENDIF}
443
444 // native OpenGL
445 {$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
446   {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'}
447 {$IFEND}
448
449 // general options
450 {$EXTENDEDSYNTAX ON}
451 {$LONGSTRINGS ON}
452 {$ALIGN ON}
453 {$IFNDEF FPC}
454   {$OPTIMIZATION ON}
455 {$ENDIF}
456
457 interface
458
459 uses
460   {$IFNDEF GLB_NATIVE_OGL}
461     {$IFDEF OPENGL_ES}          dglOpenGLES,
462     {$ELSE}                     dglOpenGL,                          {$ENDIF}
463                                                                     {$ENDIF}
464   {$IF DEFINED(GLB_WIN) AND
465        (DEFINED(GLB_NATIVE_OGL) OR
466         DEFINED(GLB_DELPHI))}   windows,                            {$IFEND}
467
468   {$IFDEF GLB_SDL}              SDL,                                {$ENDIF}
469   {$IFDEF GLB_LAZARUS}          IntfGraphics, GraphType, Graphics,  {$ENDIF}
470   {$IFDEF GLB_DELPHI}           Dialogs, Graphics, Types,           {$ENDIF}
471
472   {$IFDEF GLB_SDL_IMAGE}        SDL_image,                          {$ENDIF}
473   {$IFDEF GLB_PNGIMAGE}         pngimage,                           {$ENDIF}
474   {$IFDEF GLB_LIB_PNG}          libPNG,                             {$ENDIF}
475   {$IFDEF GLB_DELPHI_JPEG}      JPEG,                               {$ENDIF}
476   {$IFDEF GLB_LIB_JPEG}         libJPEG,                            {$ENDIF}
477
478   Classes, SysUtils;
479
480 {$IFDEF GLB_NATIVE_OGL}
481 const
482   GL_TRUE   = 1;
483   GL_FALSE  = 0;
484
485   GL_ZERO = 0;
486   GL_ONE  = 1;
487
488   GL_VERSION    = $1F02;
489   GL_EXTENSIONS = $1F03;
490
491   GL_TEXTURE_1D         = $0DE0;
492   GL_TEXTURE_2D         = $0DE1;
493   GL_TEXTURE_RECTANGLE  = $84F5;
494
495   GL_NORMAL_MAP                   = $8511;
496   GL_TEXTURE_CUBE_MAP             = $8513;
497   GL_REFLECTION_MAP               = $8512;
498   GL_TEXTURE_CUBE_MAP_POSITIVE_X  = $8515;
499   GL_TEXTURE_CUBE_MAP_NEGATIVE_X  = $8516;
500   GL_TEXTURE_CUBE_MAP_POSITIVE_Y  = $8517;
501   GL_TEXTURE_CUBE_MAP_NEGATIVE_Y  = $8518;
502   GL_TEXTURE_CUBE_MAP_POSITIVE_Z  = $8519;
503   GL_TEXTURE_CUBE_MAP_NEGATIVE_Z  = $851A;
504
505   GL_TEXTURE_WIDTH            = $1000;
506   GL_TEXTURE_HEIGHT           = $1001;
507   GL_TEXTURE_INTERNAL_FORMAT  = $1003;
508   GL_TEXTURE_SWIZZLE_RGBA     = $8E46;
509
510   GL_S = $2000;
511   GL_T = $2001;
512   GL_R = $2002;
513   GL_Q = $2003;
514
515   GL_TEXTURE_GEN_S = $0C60;
516   GL_TEXTURE_GEN_T = $0C61;
517   GL_TEXTURE_GEN_R = $0C62;
518   GL_TEXTURE_GEN_Q = $0C63;
519
520   GL_RED    = $1903;
521   GL_GREEN  = $1904;
522   GL_BLUE   = $1905;
523
524   GL_ALPHA    = $1906;
525   GL_ALPHA4   = $803B;
526   GL_ALPHA8   = $803C;
527   GL_ALPHA12  = $803D;
528   GL_ALPHA16  = $803E;
529
530   GL_LUMINANCE    = $1909;
531   GL_LUMINANCE4   = $803F;
532   GL_LUMINANCE8   = $8040;
533   GL_LUMINANCE12  = $8041;
534   GL_LUMINANCE16  = $8042;
535
536   GL_LUMINANCE_ALPHA      = $190A;
537   GL_LUMINANCE4_ALPHA4    = $8043;
538   GL_LUMINANCE6_ALPHA2    = $8044;
539   GL_LUMINANCE8_ALPHA8    = $8045;
540   GL_LUMINANCE12_ALPHA4   = $8046;
541   GL_LUMINANCE12_ALPHA12  = $8047;
542   GL_LUMINANCE16_ALPHA16  = $8048;
543
544   GL_RGB      = $1907;
545   GL_BGR      = $80E0;
546   GL_R3_G3_B2 = $2A10;
547   GL_RGB4     = $804F;
548   GL_RGB5     = $8050;
549   GL_RGB565   = $8D62;
550   GL_RGB8     = $8051;
551   GL_RGB10    = $8052;
552   GL_RGB12    = $8053;
553   GL_RGB16    = $8054;
554
555   GL_RGBA     = $1908;
556   GL_BGRA     = $80E1;
557   GL_RGBA2    = $8055;
558   GL_RGBA4    = $8056;
559   GL_RGB5_A1  = $8057;
560   GL_RGBA8    = $8058;
561   GL_RGB10_A2 = $8059;
562   GL_RGBA12   = $805A;
563   GL_RGBA16   = $805B;
564
565   GL_DEPTH_COMPONENT    = $1902;
566   GL_DEPTH_COMPONENT16  = $81A5;
567   GL_DEPTH_COMPONENT24  = $81A6;
568   GL_DEPTH_COMPONENT32  = $81A7;
569
570   GL_COMPRESSED_RGB                 = $84ED;
571   GL_COMPRESSED_RGBA                = $84EE;
572   GL_COMPRESSED_RGB_S3TC_DXT1_EXT   = $83F0;
573   GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  = $83F1;
574   GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  = $83F2;
575   GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  = $83F3;
576
577   GL_UNSIGNED_BYTE            = $1401;
578   GL_UNSIGNED_BYTE_3_3_2      = $8032;
579   GL_UNSIGNED_BYTE_2_3_3_REV  = $8362;
580
581   GL_UNSIGNED_SHORT             = $1403;
582   GL_UNSIGNED_SHORT_5_6_5       = $8363;
583   GL_UNSIGNED_SHORT_4_4_4_4     = $8033;
584   GL_UNSIGNED_SHORT_5_5_5_1     = $8034;
585   GL_UNSIGNED_SHORT_5_6_5_REV   = $8364;
586   GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365;
587   GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366;
588
589   GL_UNSIGNED_INT                 = $1405;
590   GL_UNSIGNED_INT_8_8_8_8         = $8035;
591   GL_UNSIGNED_INT_10_10_10_2      = $8036;
592   GL_UNSIGNED_INT_8_8_8_8_REV     = $8367;
593   GL_UNSIGNED_INT_2_10_10_10_REV  = $8368;
594
595   { Texture Filter }
596   GL_TEXTURE_MAG_FILTER     = $2800;
597   GL_TEXTURE_MIN_FILTER     = $2801;
598   GL_NEAREST                = $2600;
599   GL_NEAREST_MIPMAP_NEAREST = $2700;
600   GL_NEAREST_MIPMAP_LINEAR  = $2702;
601   GL_LINEAR                 = $2601;
602   GL_LINEAR_MIPMAP_NEAREST  = $2701;
603   GL_LINEAR_MIPMAP_LINEAR   = $2703;
604
605   { Texture Wrap }
606   GL_TEXTURE_WRAP_S   = $2802;
607   GL_TEXTURE_WRAP_T   = $2803;
608   GL_TEXTURE_WRAP_R   = $8072;
609   GL_CLAMP            = $2900;
610   GL_REPEAT           = $2901;
611   GL_CLAMP_TO_EDGE    = $812F;
612   GL_CLAMP_TO_BORDER  = $812D;
613   GL_MIRRORED_REPEAT  = $8370;
614
615   { Other }
616   GL_GENERATE_MIPMAP      = $8191;
617   GL_TEXTURE_BORDER_COLOR = $1004;
618   GL_MAX_TEXTURE_SIZE     = $0D33;
619   GL_PACK_ALIGNMENT       = $0D05;
620   GL_UNPACK_ALIGNMENT     = $0CF5;
621
622   GL_TEXTURE_MAX_ANISOTROPY_EXT     = $84FE;
623   GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
624   GL_MAX_CUBE_MAP_TEXTURE_SIZE      = $851C;
625   GL_TEXTURE_GEN_MODE               = $2500;
626
627 {$IF DEFINED(GLB_WIN)}
628   libglu    = 'glu32.dll';
629   libopengl = 'opengl32.dll';
630 {$ELSEIF DEFINED(GLB_LINUX)}
631   libglu    = 'libGLU.so.1';
632   libopengl = 'libGL.so.1';
633 {$IFEND}
634
635 type
636   GLboolean = BYTEBOOL;
637   GLint     = Integer;
638   GLsizei   = Integer;
639   GLuint    = Cardinal;
640   GLfloat   = Single;
641   GLenum    = Cardinal;
642
643   PGLvoid    = Pointer;
644   PGLboolean = ^GLboolean;
645   PGLint     = ^GLint;
646   PGLuint    = ^GLuint;
647   PGLfloat   = ^GLfloat;
648
649   TglCompressedTexImage1D  = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
650   TglCompressedTexImage2D  = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
651   TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
652
653 {$IF DEFINED(GLB_WIN)}
654   TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall;
655 {$ELSEIF DEFINED(GLB_LINUX)}
656   TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl;
657   TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
658 {$IFEND}
659
660 {$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
661   TglEnable  = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
662   TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
663
664   TglGetString   = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
665   TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
666
667   TglTexParameteri          = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
668   TglTexParameteriv         = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
669   TglTexParameterfv         = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
670   TglGetTexParameteriv      = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
671   TglGetTexParameterfv      = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
672   TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
673   TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
674
675   TglTexGeni        = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
676   TglGenTextures    = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
677   TglBindTexture    = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
678   TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
679
680   TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
681   TglReadPixels          = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
682   TglPixelStorei         = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
683
684   TglTexImage1D  = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
685   TglTexImage2D  = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
686   TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
687
688   TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
689   TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
690
691 {$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)}
692   procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
693   procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
694
695   function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
696   procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
697
698   procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
699   procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
700   procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
701   procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
702   procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
703   procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
704   procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
705
706   procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
707   procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
708   procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
709   procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
710
711   function  glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
712   procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
713   procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
714
715   procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
716   procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
717   procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
718
719   function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
720   function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
721 {$IFEND}
722
723 var
724   GL_VERSION_1_2,
725   GL_VERSION_1_3,
726   GL_VERSION_1_4,
727   GL_VERSION_2_0,
728   GL_VERSION_3_3,
729
730   GL_SGIS_generate_mipmap,
731
732   GL_ARB_texture_border_clamp,
733   GL_ARB_texture_mirrored_repeat,
734   GL_ARB_texture_rectangle,
735   GL_ARB_texture_non_power_of_two,
736   GL_ARB_texture_swizzle,
737   GL_ARB_texture_cube_map,
738
739   GL_IBM_texture_mirrored_repeat,
740
741   GL_NV_texture_rectangle,
742
743   GL_EXT_texture_edge_clamp,
744   GL_EXT_texture_rectangle,
745   GL_EXT_texture_swizzle,
746   GL_EXT_texture_cube_map,
747   GL_EXT_texture_filter_anisotropic: Boolean;
748
749   glCompressedTexImage1D: TglCompressedTexImage1D;
750   glCompressedTexImage2D: TglCompressedTexImage2D;
751   glGetCompressedTexImage: TglGetCompressedTexImage;
752
753 {$IF DEFINED(GLB_WIN)}
754   wglGetProcAddress: TwglGetProcAddress;
755 {$ELSEIF DEFINED(GLB_LINUX)}
756   glXGetProcAddress: TglXGetProcAddress;
757   glXGetProcAddressARB: TglXGetProcAddress;
758 {$IFEND}
759
760 {$IFDEF GLB_NATIVE_OGL_DYNAMIC}
761   glEnable: TglEnable;
762   glDisable: TglDisable;
763
764   glGetString: TglGetString;
765   glGetIntegerv: TglGetIntegerv;
766
767   glTexParameteri: TglTexParameteri;
768   glTexParameteriv: TglTexParameteriv;
769   glTexParameterfv: TglTexParameterfv;
770   glGetTexParameteriv: TglGetTexParameteriv;
771   glGetTexParameterfv: TglGetTexParameterfv;
772   glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
773   glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
774
775   glTexGeni: TglTexGeni;
776   glGenTextures: TglGenTextures;
777   glBindTexture: TglBindTexture;
778   glDeleteTextures: TglDeleteTextures;
779
780   glAreTexturesResident: TglAreTexturesResident;
781   glReadPixels: TglReadPixels;
782   glPixelStorei: TglPixelStorei;
783
784   glTexImage1D: TglTexImage1D;
785   glTexImage2D: TglTexImage2D;
786   glGetTexImage: TglGetTexImage;
787
788   gluBuild1DMipmaps: TgluBuild1DMipmaps;
789   gluBuild2DMipmaps: TgluBuild2DMipmaps;
790 {$ENDIF}
791 {$ENDIF}
792
793 type
794 ////////////////////////////////////////////////////////////////////////////////////////////////////
795 // the name of formats is composed of the following constituents:
796 // - multiple chanals:
797 //    - channel                          (e.g. R, G, B, A or Alpha, Luminance or X (reserved)
798 //    - width of the chanel in bit       (4, 8, 16, ...)
799 // - data type                           (e.g. ub, us, ui)
800 // - number of data types
801
802 {$IFNDEF fpc}
803   QWord   = System.UInt64;
804   PQWord  = ^QWord;
805
806   PtrInt  = Longint;
807   PtrUInt = DWord;
808 {$ENDIF}
809
810   TglBitmapFormat = (
811     tfEmpty = 0,                //must be smallest value!
812
813     tfAlpha4ub1,                // 1 x unsigned byte
814     tfAlpha8ub1,                // 1 x unsigned byte
815     tfAlpha16us1,               // 1 x unsigned short
816
817     tfLuminance4ub1,            // 1 x unsigned byte
818     tfLuminance8ub1,            // 1 x unsigned byte
819     tfLuminance16us1,           // 1 x unsigned short
820
821     tfLuminance4Alpha4ub2,      // 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
822     tfLuminance6Alpha2ub2,      // 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
823     tfLuminance8Alpha8ub2,      // 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
824     tfLuminance12Alpha4us2,     // 1 x unsigned short (lum), 1 x unsigned short (alpha)
825     tfLuminance16Alpha16us2,    // 1 x unsigned short (lum), 1 x unsigned short (alpha)
826
827     tfR3G3B2ub1,                // 1 x unsigned byte (3bit red, 3bit green, 2bit blue)
828     tfRGBX4us1,                 // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd)
829     tfXRGB4us1,                 // 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue)
830     tfR5G6B5us1,                // 1 x unsigned short (5bit red, 6bit green, 5bit blue)
831     tfRGB5X1us1,                // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved)
832     tfX1RGB5us1,                // 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue)
833     tfRGB8ub3,                  // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue)
834     tfRGBX8ui1,                 // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved)
835     tfXRGB8ui1,                 // 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue)
836     tfRGB10X2ui1,               // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved)
837     tfX2RGB10ui1,               // 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue)
838     tfRGB16us3,                 // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue)
839
840     tfRGBA4us1,                 // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha)
841     tfARGB4us1,                 // 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue)
842     tfRGB5A1us1,                // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha)
843     tfA1RGB5us1,                // 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue)
844     tfRGBA8ui1,                 // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha)
845     tfARGB8ui1,                 // 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue)
846     tfRGBA8ub4,                 // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha)
847     tfRGB10A2ui1,               // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha)
848     tfA2RGB10ui1,               // 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue)
849     tfRGBA16us4,                // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha)
850
851     tfBGRX4us1,                 // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved)
852     tfXBGR4us1,                 // 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red)
853     tfB5G6R5us1,                // 1 x unsigned short (5bit blue, 6bit green, 5bit red)
854     tfBGR5X1us1,                // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved)
855     tfX1BGR5us1,                // 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red)
856     tfBGR8ub3,                  // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red)
857     tfBGRX8ui1,                 // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved)
858     tfXBGR8ui1,                 // 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red)
859     tfBGR10X2ui1,               // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved)
860     tfX2BGR10ui1,               // 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red)
861     tfBGR16us3,                 // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red)
862
863     tfBGRA4us1,                 // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha)
864     tfABGR4us1,                 // 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red)
865     tfBGR5A1us1,                // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha)
866     tfA1BGR5us1,                // 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red)
867     tfBGRA8ui1,                 // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha)
868     tfABGR8ui1,                 // 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red)
869     tfBGRA8ub4,                 // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha)
870     tfBGR10A2ui1,               // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha)
871     tfA2BGR10ui1,               // 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red)
872     tfBGRA16us4,                // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha)
873
874     tfDepth16us1,               // 1 x unsigned short (depth)
875     tfDepth24ui1,               // 1 x unsigned int (depth)
876     tfDepth32ui1,               // 1 x unsigned int (depth)
877
878     tfS3tcDtx1RGBA,
879     tfS3tcDtx3RGBA,
880     tfS3tcDtx5RGBA
881   );
882
883   TglBitmapFileType = (
884      {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG,  {$ENDIF}
885      {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF}
886      ftDDS,
887      ftTGA,
888      ftBMP,
889      ftRAW);
890    TglBitmapFileTypes = set of TglBitmapFileType;
891
892    TglBitmapMipMap = (
893      mmNone,
894      mmMipmap,
895      mmMipmapGlu);
896
897    TglBitmapNormalMapFunc = (
898      nm4Samples,
899      nmSobel,
900      nm3x3,
901      nm5x5);
902
903  ////////////////////////////////////////////////////////////////////////////////////////////////////
904    EglBitmap                  = class(Exception);
905    EglBitmapNotSupported      = class(Exception);
906    EglBitmapSizeToLarge       = class(EglBitmap);
907    EglBitmapNonPowerOfTwo     = class(EglBitmap);
908    EglBitmapUnsupportedFormat = class(EglBitmap)
909    public
910      constructor Create(const aFormat: TglBitmapFormat); overload;
911      constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
912    end;
913
914 ////////////////////////////////////////////////////////////////////////////////////////////////////
915   TglBitmapRec4ui = packed record
916   case Integer of
917     0: (r, g, b, a: Cardinal);
918     1: (arr: array[0..3] of Cardinal);
919   end;
920
921   TglBitmapRec4ub = packed record
922   case Integer of
923     0: (r, g, b, a: Byte);
924     1: (arr: array[0..3] of Byte);
925   end;
926
927   TglBitmapRec4ul = packed record
928   case Integer of
929     0: (r, g, b, a: QWord);
930     1: (arr: array[0..3] of QWord);
931   end;
932
933   TglBitmapFormatDescriptor = class(TObject)
934   private
935     // cached properties
936     fBytesPerPixel: Single;
937     fChannelCount: Integer;
938     fMask: TglBitmapRec4ul;
939     fRange: TglBitmapRec4ui;
940
941     function GetHasRed: Boolean;
942     function GetHasGreen: Boolean;
943     function GetHasBlue: Boolean;
944     function GetHasAlpha: Boolean;
945     function GetHasColor: Boolean;
946     function GetIsGrayscale: Boolean;
947   protected
948     fFormat:        TglBitmapFormat;
949     fWithAlpha:     TglBitmapFormat;
950     fWithoutAlpha:  TglBitmapFormat;
951     fOpenGLFormat:  TglBitmapFormat;
952     fRGBInverted:   TglBitmapFormat;
953     fUncompressed:  TglBitmapFormat;
954
955     fBitsPerPixel: Integer;
956     fIsCompressed: Boolean;
957
958     fPrecision: TglBitmapRec4ub;
959     fShift:     TglBitmapRec4ub;
960
961     fglFormat:         GLenum;
962     fglInternalFormat: GLenum;
963     fglDataFormat:     GLenum;
964
965     procedure SetValues; virtual;
966     procedure CalcValues;
967   public
968     property Format:        TglBitmapFormat read fFormat;
969     property ChannelCount:  Integer         read fChannelCount;
970     property IsCompressed:  Boolean         read fIsCompressed;
971     property BitsPerPixel:  Integer         read fBitsPerPixel;
972     property BytesPerPixel: Single          read fBytesPerPixel;
973
974     property Precision: TglBitmapRec4ub read fPrecision;
975     property Shift:     TglBitmapRec4ub read fShift;
976     property Range:     TglBitmapRec4ui read fRange;
977     property Mask:      TglBitmapRec4ul read fMask;
978
979     property RGBInverted:  TglBitmapFormat read fRGBInverted;
980     property WithAlpha:    TglBitmapFormat read fWithAlpha;
981     property WithoutAlpha: TglBitmapFormat read fWithAlpha;
982     property OpenGLFormat: TglBitmapFormat read fOpenGLFormat;
983     property Uncompressed: TglBitmapFormat read fUncompressed;
984
985     property glFormat:         GLenum  read fglFormat;
986     property glInternalFormat: GLenum  read fglInternalFormat;
987     property glDataFormat:     GLenum  read fglDataFormat;
988
989     property HasRed:       Boolean read GetHasRed;
990     property HasGreen:     Boolean read GetHasGreen;
991     property HasBlue:      Boolean read GetHasBlue;
992     property HasAlpha:     Boolean read GetHasAlpha;
993     property HasColor:     Boolean read GetHasColor;
994     property IsGrayscale:  Boolean read GetIsGrayscale;
995
996     constructor Create;
997   public
998     class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
999   end;
1000
1001 ////////////////////////////////////////////////////////////////////////////////////////////////////
1002   TglBitmapPixelData = packed record
1003     Data:   TglBitmapRec4ui;
1004     Range:  TglBitmapRec4ui;
1005     Format: TglBitmapFormat;
1006   end;
1007   PglBitmapPixelData = ^TglBitmapPixelData;
1008
1009   TglBitmapPixelPositionFields = set of (ffX, ffY);
1010   TglBitmapPixelPosition = record
1011     Fields : TglBitmapPixelPositionFields;
1012     X : Word;
1013     Y : Word;
1014   end;
1015
1016 ////////////////////////////////////////////////////////////////////////////////////////////////////
1017   TglBitmap = class;
1018   TglBitmapFunctionRec = record
1019     Sender:   TglBitmap;
1020     Size:     TglBitmapPixelPosition;
1021     Position: TglBitmapPixelPosition;
1022     Source:   TglBitmapPixelData;
1023     Dest:     TglBitmapPixelData;
1024     Args:     Pointer;
1025   end;
1026   TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
1027
1028 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1029   TglBitmap = class
1030   private
1031     function GetFormatDesc: TglBitmapFormatDescriptor;
1032   protected
1033     fID: GLuint;
1034     fTarget: GLuint;
1035     fAnisotropic: Integer;
1036     fDeleteTextureOnFree: Boolean;
1037     fFreeDataOnDestroy: Boolean;
1038     fFreeDataAfterGenTexture: Boolean;
1039     fData: PByte;
1040 {$IFNDEF OPENGL_ES}
1041     fIsResident: GLboolean;
1042 {$ENDIF}
1043     fBorderColor: array[0..3] of Single;
1044
1045     fDimension: TglBitmapPixelPosition;
1046     fMipMap: TglBitmapMipMap;
1047     fFormat: TglBitmapFormat;
1048
1049     // Mapping
1050     fPixelSize: Integer;
1051     fRowSize: Integer;
1052
1053     // Filtering
1054     fFilterMin: GLenum;
1055     fFilterMag: GLenum;
1056
1057     // TexturWarp
1058     fWrapS: GLenum;
1059     fWrapT: GLenum;
1060     fWrapR: GLenum;
1061
1062 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
1063     //Swizzle
1064     fSwizzle: array[0..3] of GLenum;
1065 {$IFEND}
1066
1067     // CustomData
1068     fFilename: String;
1069     fCustomName: String;
1070     fCustomNameW: WideString;
1071     fCustomData: Pointer;
1072
1073     //Getter
1074     function GetWidth:  Integer; virtual;
1075     function GetHeight: Integer; virtual;
1076
1077     function GetFileWidth:  Integer; virtual;
1078     function GetFileHeight: Integer; virtual;
1079
1080     //Setter
1081     procedure SetCustomData(const aValue: Pointer);
1082     procedure SetCustomName(const aValue: String);
1083     procedure SetCustomNameW(const aValue: WideString);
1084     procedure SetFreeDataOnDestroy(const aValue: Boolean);
1085     procedure SetDeleteTextureOnFree(const aValue: Boolean);
1086     procedure SetFormat(const aValue: TglBitmapFormat);
1087     procedure SetFreeDataAfterGenTexture(const aValue: Boolean);
1088     procedure SetID(const aValue: Cardinal);
1089     procedure SetMipMap(const aValue: TglBitmapMipMap);
1090     procedure SetTarget(const aValue: Cardinal);
1091     procedure SetAnisotropic(const aValue: Integer);
1092
1093     procedure CreateID;
1094     procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF});
1095     procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
1096       const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;  //be careful, aData could be freed by this method
1097     procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;
1098
1099     function FlipHorz: Boolean; virtual;
1100     function FlipVert: Boolean; virtual;
1101
1102     property Width:  Integer read GetWidth;
1103     property Height: Integer read GetHeight;
1104
1105     property FileWidth:  Integer read GetFileWidth;
1106     property FileHeight: Integer read GetFileHeight;
1107   public
1108     //Properties
1109     property ID:           Cardinal        read fID          write SetID;
1110     property Target:       Cardinal        read fTarget      write SetTarget;
1111     property Format:       TglBitmapFormat read fFormat      write SetFormat;
1112     property MipMap:       TglBitmapMipMap read fMipMap      write SetMipMap;
1113     property Anisotropic:  Integer         read fAnisotropic write SetAnisotropic;
1114
1115     property FormatDesc:   TglBitmapFormatDescriptor read GetFormatDesc;
1116
1117     property Filename:    String     read fFilename;
1118     property CustomName:  String     read fCustomName  write SetCustomName;
1119     property CustomNameW: WideString read fCustomNameW write SetCustomNameW;
1120     property CustomData:  Pointer    read fCustomData  write SetCustomData;
1121
1122     property DeleteTextureOnFree:     Boolean read fDeleteTextureOnFree     write SetDeleteTextureOnFree;
1123     property FreeDataOnDestroy:       Boolean read fFreeDataOnDestroy       write SetFreeDataOnDestroy;
1124     property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture;
1125
1126     property Dimension:  TglBitmapPixelPosition  read fDimension;
1127     property Data:       PByte                   read fData;
1128 {$IFNDEF OPENGL_ES}
1129     property IsResident: GLboolean               read fIsResident;
1130 {$ENDIF}
1131
1132     procedure AfterConstruction; override;
1133     procedure BeforeDestruction; override;
1134
1135     procedure PrepareResType(var aResource: String; var aResType: PChar);
1136
1137     //Load
1138     procedure LoadFromFile(const aFilename: String);
1139     procedure LoadFromStream(const aStream: TStream); virtual;
1140     procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
1141       const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);
1142     procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
1143     procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
1144
1145     //Save
1146     procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
1147     procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
1148
1149     //Convert
1150     function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
1151     function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
1152       const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
1153   public
1154     //Alpha & Co
1155     {$IFDEF GLB_SDL}
1156     function AssignToSurface(out aSurface: PSDL_Surface): Boolean;
1157     function AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
1158     function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
1159     function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil;
1160       const aArgs: Pointer = nil): Boolean;
1161     {$ENDIF}
1162
1163     {$IFDEF GLB_DELPHI}
1164     function AssignToBitmap(const aBitmap: TBitmap): Boolean;
1165     function AssignFromBitmap(const aBitmap: TBitmap): Boolean;
1166     function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
1167     function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil;
1168       const aArgs: Pointer = nil): Boolean;
1169     {$ENDIF}
1170
1171     {$IFDEF GLB_LAZARUS}
1172     function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
1173     function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
1174     function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
1175     function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil;
1176       const aArgs: Pointer = nil): Boolean;
1177     {$ENDIF}
1178
1179     function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil;
1180       const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
1181     function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
1182       const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
1183
1184     function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
1185     function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
1186     function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
1187     function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
1188
1189     function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
1190     function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
1191     function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
1192
1193     function AddAlphaFromValue(const aAlpha: Byte): Boolean;
1194     function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
1195     function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
1196
1197     function RemoveAlpha: Boolean; virtual;
1198   public
1199     //Common
1200     function Clone: TglBitmap;
1201     function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
1202     procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);
1203 {$IFNDEF OPENGL_ES}
1204     procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
1205 {$ENDIF}
1206     procedure FreeData;
1207
1208     //ColorFill
1209     procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
1210     procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
1211     procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1);
1212
1213     //TexParameters
1214     procedure SetFilter(const aMin, aMag: GLenum);
1215     procedure SetWrap(
1216       const S: GLenum = GL_CLAMP_TO_EDGE;
1217       const T: GLenum = GL_CLAMP_TO_EDGE;
1218       const R: GLenum = GL_CLAMP_TO_EDGE);
1219 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
1220     procedure SetSwizzle(const r, g, b, a: GLenum);
1221 {$IFEND}
1222
1223     procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
1224     procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
1225
1226     //Constructors
1227     constructor Create; overload;
1228     constructor Create(const aFileName: String); overload;
1229     constructor Create(const aStream: TStream); overload;
1230     constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
1231     constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
1232     constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
1233     constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
1234   private
1235     {$IFDEF GLB_SUPPORT_PNG_READ}  function  LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF}
1236     {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF}
1237
1238     {$IFDEF GLB_SUPPORT_JPEG_READ}  function  LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF}
1239     {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF}
1240
1241     function LoadRAW(const aStream: TStream): Boolean;
1242     procedure SaveRAW(const aStream: TStream);
1243
1244     function LoadBMP(const aStream: TStream): Boolean;
1245     procedure SaveBMP(const aStream: TStream);
1246
1247     function LoadTGA(const aStream: TStream): Boolean;
1248     procedure SaveTGA(const aStream: TStream);
1249
1250     function LoadDDS(const aStream: TStream): Boolean;
1251     procedure SaveDDS(const aStream: TStream);
1252   end;
1253
1254 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1255 {$IFNDEF OPENGL_ES}
1256   TglBitmap1D = class(TglBitmap)
1257   protected
1258     procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
1259       const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
1260     procedure UploadData(const aBuildWithGlu: Boolean);
1261   public
1262     property Width;
1263     procedure AfterConstruction; override;
1264     function FlipHorz: Boolean; override;
1265     procedure GenTexture(const aTestTextureSize: Boolean = true); override;
1266   end;
1267 {$ENDIF}
1268
1269 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1270   TglBitmap2D = class(TglBitmap)
1271   protected
1272     fLines: array of PByte;
1273     function GetScanline(const aIndex: Integer): Pointer;
1274     procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
1275       const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
1276     procedure UploadData(const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF});
1277   public
1278     property Width;
1279     property Height;
1280     property Scanline[const aIndex: Integer]: Pointer read GetScanline;
1281
1282     procedure AfterConstruction; override;
1283
1284     procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
1285 {$IFNDEF OPENGL_ES}
1286     procedure GetDataFromTexture;
1287 {$ENDIF}
1288     procedure GenTexture(const aTestTextureSize: Boolean = true); override;
1289
1290     function FlipHorz: Boolean; override;
1291     function FlipVert: Boolean; override;
1292
1293     procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3;
1294       const aScale: Single = 2; const aUseAlpha: Boolean = false);
1295   end;
1296
1297 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1298 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
1299   TglBitmapCubeMap = class(TglBitmap2D)
1300   protected
1301   {$IFNDEF OPENGL_ES}
1302     fGenMode: Integer;
1303   {$ENDIF}
1304     procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;
1305   public
1306     procedure AfterConstruction; override;
1307     procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);
1308     procedure Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean = true;{$ENDIF} const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
1309     procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean = true;{$ENDIF} const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
1310   end;
1311 {$IFEND}
1312
1313 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
1314 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1315   TglBitmapNormalMap = class(TglBitmapCubeMap)
1316   public
1317     procedure AfterConstruction; override;
1318     procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);
1319   end;
1320 {$IFEND}
1321
1322 const
1323   NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
1324
1325 procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
1326 procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
1327 procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
1328 procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
1329 procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
1330 procedure glBitmapSetDefaultWrap(
1331   const S: Cardinal = GL_CLAMP_TO_EDGE;
1332   const T: Cardinal = GL_CLAMP_TO_EDGE;
1333   const R: Cardinal = GL_CLAMP_TO_EDGE);
1334
1335 function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
1336 function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
1337 function glBitmapGetDefaultMipmap: TglBitmapMipMap;
1338 function glBitmapGetDefaultFormat: TglBitmapFormat;
1339 procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
1340 procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
1341
1342 function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
1343 function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
1344 function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
1345 function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
1346 function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
1347 function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
1348
1349 function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D;
1350
1351 var
1352   glBitmapDefaultDeleteTextureOnFree: Boolean;
1353   glBitmapDefaultFreeDataAfterGenTextures: Boolean;
1354   glBitmapDefaultFormat: TglBitmapFormat;
1355   glBitmapDefaultMipmap: TglBitmapMipMap;
1356   glBitmapDefaultFilterMin: Cardinal;
1357   glBitmapDefaultFilterMag: Cardinal;
1358   glBitmapDefaultWrapS: Cardinal;
1359   glBitmapDefaultWrapT: Cardinal;
1360   glBitmapDefaultWrapR: Cardinal;
1361   glDefaultSwizzle: array[0..3] of GLenum;
1362
1363 {$IFDEF GLB_DELPHI}
1364 function CreateGrayPalette: HPALETTE;
1365 {$ENDIF}
1366
1367 implementation
1368
1369 uses
1370   Math, syncobjs, typinfo
1371   {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND};
1372
1373 ////////////////////////////////////////////////////////////////////////////////////////////////////
1374 type
1375   TFormatDescriptor = class(TglBitmapFormatDescriptor)
1376   public
1377     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
1378     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
1379
1380     function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual;
1381     function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
1382
1383     function CreateMappingData: Pointer; virtual;
1384     procedure FreeMappingData(var aMappingData: Pointer); virtual;
1385
1386     function IsEmpty: Boolean; virtual;
1387     function MaskMatch(const aMask: TglBitmapRec4ul): Boolean; virtual;
1388
1389     procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
1390
1391     constructor Create; virtual;
1392   public
1393     class procedure Init;
1394     class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
1395     class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
1396     class function GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer = 0): TFormatDescriptor;
1397     class function GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor;
1398     class procedure Clear;
1399     class procedure Finalize;
1400   end;
1401   TFormatDescriptorClass = class of TFormatDescriptor;
1402
1403   TfdEmpty = class(TFormatDescriptor);
1404
1405 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1406   TfdAlphaUB1 = class(TFormatDescriptor) //1* unsigned byte
1407     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1408     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1409   end;
1410
1411   TfdLuminanceUB1 = class(TFormatDescriptor) //1* unsigned byte
1412     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1413     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1414   end;
1415
1416   TfdUniversalUB1 = class(TFormatDescriptor) //1* unsigned byte
1417     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1418     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1419   end;
1420
1421   TfdLuminanceAlphaUB2 = class(TfdLuminanceUB1) //2* unsigned byte
1422     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1423     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1424   end;
1425
1426   TfdRGBub3 = class(TFormatDescriptor) //3* unsigned byte
1427     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1428     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1429   end;
1430
1431   TfdBGRub3 = class(TFormatDescriptor) //3* unsigned byte (inverse)
1432     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1433     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1434   end;
1435
1436   TfdRGBAub4 = class(TfdRGBub3) //3* unsigned byte
1437     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1438     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1439   end;
1440
1441   TfdBGRAub4 = class(TfdBGRub3) //3* unsigned byte (inverse)
1442     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1443     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1444   end;
1445
1446 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1447   TfdAlphaUS1 = class(TFormatDescriptor) //1* unsigned short
1448     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1449     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1450   end;
1451
1452   TfdLuminanceUS1 = class(TFormatDescriptor) //1* unsigned short
1453     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1454     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1455   end;
1456
1457   TfdUniversalUS1 = class(TFormatDescriptor) //1* unsigned short
1458     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1459     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1460   end;
1461
1462   TfdDepthUS1 = class(TFormatDescriptor) //1* unsigned short
1463     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1464     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1465   end;
1466
1467   TfdLuminanceAlphaUS2 = class(TfdLuminanceUS1) //2* unsigned short
1468     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1469     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1470   end;
1471
1472   TfdRGBus3 = class(TFormatDescriptor) //3* unsigned short
1473     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1474     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1475   end;
1476
1477   TfdBGRus3 = class(TFormatDescriptor) //3* unsigned short (inverse)
1478     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1479     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1480   end;
1481
1482   TfdRGBAus4 = class(TfdRGBus3) //4* unsigned short
1483     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1484     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1485   end;
1486
1487   TfdARGBus4 = class(TfdRGBus3) //4* unsigned short
1488     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1489     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1490   end;
1491
1492   TfdBGRAus4 = class(TfdBGRus3) //4* unsigned short (inverse)
1493     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1494     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1495   end;
1496
1497   TfdABGRus4 = class(TfdBGRus3) //4* unsigned short (inverse)
1498     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1499     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1500   end;
1501
1502 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1503   TfdUniversalUI1 = class(TFormatDescriptor) //1* unsigned int
1504     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1505     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1506   end;
1507
1508   TfdDepthUI1 = class(TFormatDescriptor) //1* unsigned int
1509     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1510     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1511   end;
1512
1513 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1514   TfdAlpha4ub1 = class(TfdAlphaUB1)
1515     procedure SetValues; override;
1516   end;
1517
1518   TfdAlpha8ub1 = class(TfdAlphaUB1)
1519     procedure SetValues; override;
1520   end;
1521
1522   TfdAlpha16us1 = class(TfdAlphaUS1)
1523     procedure SetValues; override;
1524   end;
1525
1526   TfdLuminance4ub1 = class(TfdLuminanceUB1)
1527     procedure SetValues; override;
1528   end;
1529
1530   TfdLuminance8ub1 = class(TfdLuminanceUB1)
1531     procedure SetValues; override;
1532   end;
1533
1534   TfdLuminance16us1 = class(TfdLuminanceUS1)
1535     procedure SetValues; override;
1536   end;
1537
1538   TfdLuminance4Alpha4ub2 = class(TfdLuminanceAlphaUB2)
1539     procedure SetValues; override;
1540   end;
1541
1542   TfdLuminance6Alpha2ub2 = class(TfdLuminanceAlphaUB2)
1543     procedure SetValues; override;
1544   end;
1545
1546   TfdLuminance8Alpha8ub2 = class(TfdLuminanceAlphaUB2)
1547     procedure SetValues; override;
1548   end;
1549
1550   TfdLuminance12Alpha4us2 = class(TfdLuminanceAlphaUS2)
1551     procedure SetValues; override;
1552   end;
1553
1554   TfdLuminance16Alpha16us2 = class(TfdLuminanceAlphaUS2)
1555     procedure SetValues; override;
1556   end;
1557
1558 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1559   TfdR3G3B2ub1 = class(TfdUniversalUB1)
1560     procedure SetValues; override;
1561   end;
1562
1563   TfdRGBX4us1 = class(TfdUniversalUS1)
1564     procedure SetValues; override;
1565   end;
1566
1567   TfdXRGB4us1 = class(TfdUniversalUS1)
1568     procedure SetValues; override;
1569   end;
1570
1571   TfdR5G6B5us1 = class(TfdUniversalUS1)
1572     procedure SetValues; override;
1573   end;
1574
1575   TfdRGB5X1us1 = class(TfdUniversalUS1)
1576     procedure SetValues; override;
1577   end;
1578
1579   TfdX1RGB5us1 = class(TfdUniversalUS1)
1580     procedure SetValues; override;
1581   end;
1582
1583   TfdRGB8ub3 = class(TfdRGBub3)
1584     procedure SetValues; override;
1585   end;
1586
1587   TfdRGBX8ui1 = class(TfdUniversalUI1)
1588     procedure SetValues; override;
1589   end;
1590
1591   TfdXRGB8ui1 = class(TfdUniversalUI1)
1592     procedure SetValues; override;
1593   end;
1594
1595   TfdRGB10X2ui1 = class(TfdUniversalUI1)
1596     procedure SetValues; override;
1597   end;
1598
1599   TfdX2RGB10ui1 = class(TfdUniversalUI1)
1600     procedure SetValues; override;
1601   end;
1602
1603   TfdRGB16us3 = class(TfdRGBus3)
1604     procedure SetValues; override;
1605   end;
1606
1607   TfdRGBA4us1 = class(TfdUniversalUS1)
1608     procedure SetValues; override;
1609   end;
1610
1611   TfdARGB4us1 = class(TfdUniversalUS1)
1612     procedure SetValues; override;
1613   end;
1614
1615   TfdRGB5A1us1 = class(TfdUniversalUS1)
1616     procedure SetValues; override;
1617   end;
1618
1619   TfdA1RGB5us1 = class(TfdUniversalUS1)
1620     procedure SetValues; override;
1621   end;
1622
1623   TfdRGBA8ui1 = class(TfdUniversalUI1)
1624     procedure SetValues; override;
1625   end;
1626
1627   TfdARGB8ui1 = class(TfdUniversalUI1)
1628     procedure SetValues; override;
1629   end;
1630
1631   TfdRGBA8ub4 = class(TfdRGBAub4)
1632     procedure SetValues; override;
1633   end;
1634
1635   TfdRGB10A2ui1 = class(TfdUniversalUI1)
1636     procedure SetValues; override;
1637   end;
1638
1639   TfdA2RGB10ui1 = class(TfdUniversalUI1)
1640     procedure SetValues; override;
1641   end;
1642
1643   TfdRGBA16us4 = class(TfdRGBAus4)
1644     procedure SetValues; override;
1645   end;
1646
1647 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1648   TfdBGRX4us1 = class(TfdUniversalUS1)
1649     procedure SetValues; override;
1650   end;
1651
1652   TfdXBGR4us1 = class(TfdUniversalUS1)
1653     procedure SetValues; override;
1654   end;
1655
1656   TfdB5G6R5us1 = class(TfdUniversalUS1)
1657     procedure SetValues; override;
1658   end;
1659
1660   TfdBGR5X1us1 = class(TfdUniversalUS1)
1661     procedure SetValues; override;
1662   end;
1663
1664   TfdX1BGR5us1 = class(TfdUniversalUS1)
1665     procedure SetValues; override;
1666   end;
1667
1668   TfdBGR8ub3 = class(TfdBGRub3)
1669     procedure SetValues; override;
1670   end;
1671
1672   TfdBGRX8ui1 = class(TfdUniversalUI1)
1673     procedure SetValues; override;
1674   end;
1675
1676   TfdXBGR8ui1 = class(TfdUniversalUI1)
1677     procedure SetValues; override;
1678   end;
1679
1680   TfdBGR10X2ui1 = class(TfdUniversalUI1)
1681     procedure SetValues; override;
1682   end;
1683
1684   TfdX2BGR10ui1 = class(TfdUniversalUI1)
1685     procedure SetValues; override;
1686   end;
1687
1688   TfdBGR16us3 = class(TfdBGRus3)
1689     procedure SetValues; override;
1690   end;
1691
1692   TfdBGRA4us1 = class(TfdUniversalUS1)
1693     procedure SetValues; override;
1694   end;
1695
1696   TfdABGR4us1 = class(TfdUniversalUS1)
1697     procedure SetValues; override;
1698   end;
1699
1700   TfdBGR5A1us1 = class(TfdUniversalUS1)
1701     procedure SetValues; override;
1702   end;
1703
1704   TfdA1BGR5us1 = class(TfdUniversalUS1)
1705     procedure SetValues; override;
1706   end;
1707
1708   TfdBGRA8ui1 = class(TfdUniversalUI1)
1709     procedure SetValues; override;
1710   end;
1711
1712   TfdABGR8ui1 = class(TfdUniversalUI1)
1713     procedure SetValues; override;
1714   end;
1715
1716   TfdBGRA8ub4 = class(TfdBGRAub4)
1717     procedure SetValues; override;
1718   end;
1719
1720   TfdBGR10A2ui1 = class(TfdUniversalUI1)
1721     procedure SetValues; override;
1722   end;
1723
1724   TfdA2BGR10ui1 = class(TfdUniversalUI1)
1725     procedure SetValues; override;
1726   end;
1727
1728   TfdBGRA16us4 = class(TfdBGRAus4)
1729     procedure SetValues; override;
1730   end;
1731
1732   TfdDepth16us1 = class(TfdDepthUS1)
1733     procedure SetValues; override;
1734   end;
1735
1736   TfdDepth24ui1 = class(TfdDepthUI1)
1737     procedure SetValues; override;
1738   end;
1739
1740   TfdDepth32ui1 = class(TfdDepthUI1)
1741     procedure SetValues; override;
1742   end;
1743
1744   TfdS3tcDtx1RGBA = class(TFormatDescriptor)
1745     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1746     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1747     procedure SetValues; override;
1748   end;
1749
1750   TfdS3tcDtx3RGBA = class(TFormatDescriptor)
1751     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1752     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1753     procedure SetValues; override;
1754   end;
1755
1756   TfdS3tcDtx5RGBA = class(TFormatDescriptor)
1757     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1758     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1759     procedure SetValues; override;
1760   end;
1761
1762 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1763   TbmpBitfieldFormat = class(TFormatDescriptor)
1764   public
1765     procedure SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul); overload;
1766     procedure SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
1767     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1768     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1769   end;
1770
1771 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1772   TbmpColorTableEnty = packed record
1773     b, g, r, a: Byte;
1774   end;
1775   TbmpColorTable = array of TbmpColorTableEnty;
1776   TbmpColorTableFormat = class(TFormatDescriptor)
1777   private
1778     fBitsPerPixel: Integer;
1779     fColorTable: TbmpColorTable;
1780   protected
1781     procedure SetValues; override;
1782   public
1783     property ColorTable:   TbmpColorTable  read fColorTable   write fColorTable;
1784     property BitsPerPixel: Integer         read fBitsPerPixel write fBitsPerPixel;
1785
1786     procedure SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
1787     procedure CalcValues;
1788     procedure CreateColorTable;
1789
1790     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
1791     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
1792     destructor Destroy; override;
1793   end;
1794
1795 const
1796   LUMINANCE_WEIGHT_R = 0.30;
1797   LUMINANCE_WEIGHT_G = 0.59;
1798   LUMINANCE_WEIGHT_B = 0.11;
1799
1800   ALPHA_WEIGHT_R = 0.30;
1801   ALPHA_WEIGHT_G = 0.59;
1802   ALPHA_WEIGHT_B = 0.11;
1803
1804   DEPTH_WEIGHT_R = 0.333333333;
1805   DEPTH_WEIGHT_G = 0.333333333;
1806   DEPTH_WEIGHT_B = 0.333333333;
1807
1808   FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
1809     TfdEmpty,
1810
1811     TfdAlpha4ub1,
1812     TfdAlpha8ub1,
1813     TfdAlpha16us1,
1814
1815     TfdLuminance4ub1,
1816     TfdLuminance8ub1,
1817     TfdLuminance16us1,
1818
1819     TfdLuminance4Alpha4ub2,
1820     TfdLuminance6Alpha2ub2,
1821     TfdLuminance8Alpha8ub2,
1822     TfdLuminance12Alpha4us2,
1823     TfdLuminance16Alpha16us2,
1824
1825     TfdR3G3B2ub1,
1826     TfdRGBX4us1,
1827     TfdXRGB4us1,
1828     TfdR5G6B5us1,
1829     TfdRGB5X1us1,
1830     TfdX1RGB5us1,
1831     TfdRGB8ub3,
1832     TfdRGBX8ui1,
1833     TfdXRGB8ui1,
1834     TfdRGB10X2ui1,
1835     TfdX2RGB10ui1,
1836     TfdRGB16us3,
1837
1838     TfdRGBA4us1,
1839     TfdARGB4us1,
1840     TfdRGB5A1us1,
1841     TfdA1RGB5us1,
1842     TfdRGBA8ui1,
1843     TfdARGB8ui1,
1844     TfdRGBA8ub4,
1845     TfdRGB10A2ui1,
1846     TfdA2RGB10ui1,
1847     TfdRGBA16us4,
1848
1849     TfdBGRX4us1,
1850     TfdXBGR4us1,
1851     TfdB5G6R5us1,
1852     TfdBGR5X1us1,
1853     TfdX1BGR5us1,
1854     TfdBGR8ub3,
1855     TfdBGRX8ui1,
1856     TfdXBGR8ui1,
1857     TfdBGR10X2ui1,
1858     TfdX2BGR10ui1,
1859     TfdBGR16us3,
1860
1861     TfdBGRA4us1,
1862     TfdABGR4us1,
1863     TfdBGR5A1us1,
1864     TfdA1BGR5us1,
1865     TfdBGRA8ui1,
1866     TfdABGR8ui1,
1867     TfdBGRA8ub4,
1868     TfdBGR10A2ui1,
1869     TfdA2BGR10ui1,
1870     TfdBGRA16us4,
1871
1872     TfdDepth16us1,
1873     TfdDepth24ui1,
1874     TfdDepth32ui1,
1875
1876     TfdS3tcDtx1RGBA,
1877     TfdS3tcDtx3RGBA,
1878     TfdS3tcDtx5RGBA
1879   );
1880
1881 var
1882   FormatDescriptorCS: TCriticalSection;
1883   FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
1884
1885 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1886 constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
1887 begin
1888   inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
1889 end;
1890
1891 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1892 constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat);
1893 begin
1894   inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
1895 end;
1896
1897 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1898 function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition;
1899 begin
1900   result.Fields := [];
1901
1902   if X >= 0 then
1903     result.Fields := result.Fields + [ffX];
1904   if Y >= 0 then
1905     result.Fields := result.Fields + [ffY];
1906
1907   result.X := Max(0, X);
1908   result.Y := Max(0, Y);
1909 end;
1910
1911 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1912 function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
1913 begin
1914   result.r := r;
1915   result.g := g;
1916   result.b := b;
1917   result.a := a;
1918 end;
1919
1920 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1921 function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
1922 begin
1923   result.r := r;
1924   result.g := g;
1925   result.b := b;
1926   result.a := a;
1927 end;
1928
1929 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1930 function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
1931 begin
1932   result.r := r;
1933   result.g := g;
1934   result.b := b;
1935   result.a := a;
1936 end;
1937
1938 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1939 function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
1940 var
1941   i: Integer;
1942 begin
1943   result := false;
1944   for i := 0 to high(r1.arr) do
1945     if (r1.arr[i] <> r2.arr[i]) then
1946       exit;
1947   result := true;
1948 end;
1949
1950 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1951 function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
1952 var
1953   i: Integer;
1954 begin
1955   result := false;
1956   for i := 0 to high(r1.arr) do
1957     if (r1.arr[i] <> r2.arr[i]) then
1958       exit;
1959   result := true;
1960 end;
1961
1962 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1963 function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D;
1964 var
1965   desc: TFormatDescriptor;
1966   p, tmp: PByte;
1967   x, y, i: Integer;
1968   md: Pointer;
1969   px: TglBitmapPixelData;
1970 begin
1971   result := nil;
1972   desc := TFormatDescriptor.Get(aFormat);
1973   if (desc.IsCompressed) or (desc.glFormat = 0) then
1974     exit;
1975
1976   p := GetMemory(ceil(25 * desc.BytesPerPixel)); // 5 x 5 pixel
1977   md := desc.CreateMappingData;
1978   try
1979     tmp := p;
1980     desc.PreparePixel(px);
1981     for y := 0 to 4 do
1982       for x := 0 to 4 do begin
1983         px.Data := glBitmapRec4ui(0, 0, 0, 0);
1984         for i := 0 to 3 do begin
1985           if ((y < 3) and (y = i)) or
1986              ((y = 3) and (i < 3)) or
1987              ((y = 4) and (i = 3))
1988           then
1989             px.Data.arr[i] := Trunc(px.Range.arr[i] / 4 * x)
1990           else if ((y < 4) and (i = 3)) or
1991                   ((y = 4) and (i < 3))
1992           then
1993             px.Data.arr[i] := px.Range.arr[i]
1994           else
1995             px.Data.arr[i] := 0; //px.Range.arr[i];
1996         end;
1997         desc.Map(px, tmp, md);
1998       end;
1999   finally
2000     desc.FreeMappingData(md);
2001   end;
2002
2003   result := TglBitmap2D.Create(glBitmapPosition(5, 5), aFormat, p);
2004   result.FreeDataOnDestroy       := true;
2005   result.FreeDataAfterGenTexture := false;
2006   result.SetFilter(GL_NEAREST, GL_NEAREST);
2007 end;
2008
2009 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2010 function glBitmapShiftRec(const r, g, b, a: Byte): TglBitmapRec4ub;
2011 begin
2012   result.r := r;
2013   result.g := g;
2014   result.b := b;
2015   result.a := a;
2016 end;
2017
2018 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2019 function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
2020 begin
2021   result := [];
2022
2023   if (aFormat in [
2024         //8bpp
2025         tfAlpha4ub1, tfAlpha8ub1,
2026         tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1,
2027
2028         //16bpp
2029         tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
2030         tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1,
2031         tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1,
2032
2033         //24bpp
2034         tfBGR8ub3, tfRGB8ub3,
2035
2036         //32bpp
2037         tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1,
2038         tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1])
2039   then
2040     result := result + [ ftBMP ];
2041
2042   if (aFormat in [
2043         //8bbp
2044         tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1,
2045
2046         //16bbp
2047         tfAlpha16us1, tfLuminance16us1,
2048         tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
2049         tfX1RGB5us1, tfARGB4us1, tfA1RGB5us1, tfDepth16us1,
2050
2051         //24bbp
2052         tfBGR8ub3,
2053
2054         //32bbp
2055         tfX2RGB10ui1, tfARGB8ui1, tfBGRA8ub4, tfA2RGB10ui1,
2056         tfDepth24ui1, tfDepth32ui1])
2057   then
2058     result := result + [ftTGA];
2059
2060   if not (aFormat in [tfEmpty, tfRGB16us3, tfBGR16us3]) then
2061     result := result + [ftDDS];
2062
2063 {$IFDEF GLB_SUPPORT_PNG_WRITE}
2064   if aFormat in [
2065       tfAlpha8ub1, tfLuminance8ub1, tfLuminance8Alpha8ub2,
2066       tfRGB8ub3, tfRGBA8ui1,
2067       tfBGR8ub3, tfBGRA8ui1] then
2068     result := result + [ftPNG];
2069 {$ENDIF}
2070
2071 {$IFDEF GLB_SUPPORT_JPEG_WRITE}
2072   if aFormat in [tfAlpha8ub1, tfLuminance8ub1, tfRGB8ub3, tfBGR8ub3] then
2073     result := result + [ftJPEG];
2074 {$ENDIF}
2075 end;
2076
2077 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2078 function IsPowerOfTwo(aNumber: Integer): Boolean;
2079 begin
2080   while (aNumber and 1) = 0 do
2081     aNumber := aNumber shr 1;
2082   result := aNumber = 1;
2083 end;
2084
2085 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2086 function GetTopMostBit(aBitSet: QWord): Integer;
2087 begin
2088   result := 0;
2089   while aBitSet > 0 do begin
2090     inc(result);
2091     aBitSet := aBitSet shr 1;
2092   end;
2093 end;
2094
2095 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2096 function CountSetBits(aBitSet: QWord): Integer;
2097 begin
2098   result := 0;
2099   while aBitSet > 0 do begin
2100     if (aBitSet and 1) = 1 then
2101       inc(result);
2102     aBitSet := aBitSet shr 1;
2103   end;
2104 end;
2105
2106 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2107 function LuminanceWeight(const aPixel: TglBitmapPixelData): Cardinal;
2108 begin
2109   result := Trunc(
2110     LUMINANCE_WEIGHT_R * aPixel.Data.r +
2111     LUMINANCE_WEIGHT_G * aPixel.Data.g +
2112     LUMINANCE_WEIGHT_B * aPixel.Data.b);
2113 end;
2114
2115 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2116 function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
2117 begin
2118   result := Trunc(
2119     DEPTH_WEIGHT_R * aPixel.Data.r +
2120     DEPTH_WEIGHT_G * aPixel.Data.g +
2121     DEPTH_WEIGHT_B * aPixel.Data.b);
2122 end;
2123
2124 {$IFDEF GLB_NATIVE_OGL}
2125 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2126 //OpenGLInitialization///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2127 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2128 var
2129   GL_LibHandle: Pointer = nil;
2130
2131 function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer;
2132 begin
2133   if not Assigned(aLibHandle) then
2134     aLibHandle := GL_LibHandle;
2135
2136 {$IF DEFINED(GLB_WIN)}
2137   result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName);
2138   if Assigned(result) then
2139     exit;
2140
2141   if Assigned(wglGetProcAddress) then
2142     result := wglGetProcAddress(aProcName);
2143 {$ELSEIF DEFINED(GLB_LINUX)}
2144   if Assigned(glXGetProcAddress) then begin
2145     result := glXGetProcAddress(aProcName);
2146     if Assigned(result) then
2147       exit;
2148   end;
2149
2150   if Assigned(glXGetProcAddressARB) then begin
2151     result := glXGetProcAddressARB(aProcName);
2152     if Assigned(result) then
2153       exit;
2154   end;
2155
2156   result := dlsym(aLibHandle, aProcName);
2157 {$IFEND}
2158   if not Assigned(result) and aRaiseOnErr then
2159     raise EglBitmap.Create('unable to load procedure form library: ' + aProcName);
2160 end;
2161
2162 {$IFDEF GLB_NATIVE_OGL_DYNAMIC}
2163 var
2164   GLU_LibHandle: Pointer = nil;
2165   OpenGLInitialized: Boolean;
2166   InitOpenGLCS: TCriticalSection;
2167
2168 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2169 procedure glbInitOpenGL;
2170
2171   ////////////////////////////////////////////////////////////////////////////////
2172   function glbLoadLibrary(const aName: PChar): Pointer;
2173   begin
2174     {$IF DEFINED(GLB_WIN)}
2175     result := {%H-}Pointer(LoadLibrary(aName));
2176     {$ELSEIF DEFINED(GLB_LINUX)}
2177     result := dlopen(Name, RTLD_LAZY);
2178     {$ELSE}
2179     result := nil;
2180     {$IFEND}
2181   end;
2182
2183   ////////////////////////////////////////////////////////////////////////////////
2184   function glbFreeLibrary(const aLibHandle: Pointer): Boolean;
2185   begin
2186     result := false;
2187     if not Assigned(aLibHandle) then
2188       exit;
2189
2190     {$IF DEFINED(GLB_WIN)}
2191     Result := FreeLibrary({%H-}HINST(aLibHandle));
2192     {$ELSEIF DEFINED(GLB_LINUX)}
2193     Result := dlclose(aLibHandle) = 0;
2194     {$IFEND}
2195   end;
2196
2197 begin
2198   if Assigned(GL_LibHandle) then
2199     glbFreeLibrary(GL_LibHandle);
2200
2201   if Assigned(GLU_LibHandle) then
2202     glbFreeLibrary(GLU_LibHandle);
2203
2204   GL_LibHandle := glbLoadLibrary(libopengl);
2205   if not Assigned(GL_LibHandle) then
2206     raise EglBitmap.Create('unable to load library: ' + libopengl);
2207
2208   GLU_LibHandle := glbLoadLibrary(libglu);
2209   if not Assigned(GLU_LibHandle) then
2210     raise EglBitmap.Create('unable to load library: ' + libglu);
2211
2212 {$IF DEFINED(GLB_WIN)}
2213   wglGetProcAddress    := glbGetProcAddress('wglGetProcAddress');
2214 {$ELSEIF DEFINED(GLB_LINUX)}
2215   glXGetProcAddress    := glbGetProcAddress('glXGetProcAddress');
2216   glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB');
2217 {$IFEND}
2218
2219   glEnable := glbGetProcAddress('glEnable');
2220   glDisable := glbGetProcAddress('glDisable');
2221   glGetString := glbGetProcAddress('glGetString');
2222   glGetIntegerv := glbGetProcAddress('glGetIntegerv');
2223   glTexParameteri := glbGetProcAddress('glTexParameteri');
2224   glTexParameteriv := glbGetProcAddress('glTexParameteriv');
2225   glTexParameterfv := glbGetProcAddress('glTexParameterfv');
2226   glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv');
2227   glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv');
2228   glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv');
2229   glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv');
2230   glTexGeni := glbGetProcAddress('glTexGeni');
2231   glGenTextures := glbGetProcAddress('glGenTextures');
2232   glBindTexture := glbGetProcAddress('glBindTexture');
2233   glDeleteTextures := glbGetProcAddress('glDeleteTextures');
2234   glAreTexturesResident := glbGetProcAddress('glAreTexturesResident');
2235   glReadPixels := glbGetProcAddress('glReadPixels');
2236   glPixelStorei := glbGetProcAddress('glPixelStorei');
2237   glTexImage1D := glbGetProcAddress('glTexImage1D');
2238   glTexImage2D := glbGetProcAddress('glTexImage2D');
2239   glGetTexImage := glbGetProcAddress('glGetTexImage');
2240
2241   gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle);
2242   gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle);
2243 end;
2244 {$ENDIF}
2245
2246 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2247 procedure glbReadOpenGLExtensions;
2248 var
2249   Buffer: AnsiString;
2250   MajorVersion, MinorVersion: Integer;
2251
2252   ///////////////////////////////////////////////////////////////////////////////////////////
2253   procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer);
2254   var
2255     Separator: Integer;
2256   begin
2257     aMinor := 0;
2258     aMajor := 0;
2259
2260     Separator := Pos(AnsiString('.'), aBuffer);
2261     if (Separator > 1) and (Separator < Length(aBuffer)) and
2262        (aBuffer[Separator - 1] in ['0'..'9']) and
2263        (aBuffer[Separator + 1] in ['0'..'9']) then begin
2264
2265       Dec(Separator);
2266       while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do
2267         Dec(Separator);
2268
2269       Delete(aBuffer, 1, Separator);
2270       Separator := Pos(AnsiString('.'), aBuffer) + 1;
2271
2272       while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do
2273         Inc(Separator);
2274
2275       Delete(aBuffer, Separator, 255);
2276       Separator := Pos(AnsiString('.'), aBuffer);
2277
2278       aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1));
2279       aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1));
2280     end;
2281   end;
2282
2283   ///////////////////////////////////////////////////////////////////////////////////////////
2284   function CheckExtension(const Extension: AnsiString): Boolean;
2285   var
2286     ExtPos: Integer;
2287   begin
2288     ExtPos := Pos(Extension, Buffer);
2289     result := ExtPos > 0;
2290     if result then
2291       result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
2292   end;
2293
2294   ///////////////////////////////////////////////////////////////////////////////////////////
2295   function CheckVersion(const aMajor, aMinor: Integer): Boolean;
2296   begin
2297     result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor));
2298   end;
2299
2300 begin
2301 {$IFDEF GLB_NATIVE_OGL_DYNAMIC}
2302   InitOpenGLCS.Enter;
2303   try
2304     if not OpenGLInitialized then begin
2305       glbInitOpenGL;
2306       OpenGLInitialized := true;
2307     end;
2308   finally
2309     InitOpenGLCS.Leave;
2310   end;
2311 {$ENDIF}
2312
2313   // Version
2314   Buffer := glGetString(GL_VERSION);
2315   TrimVersionString(Buffer, MajorVersion, MinorVersion);
2316
2317   GL_VERSION_1_2 := CheckVersion(1, 2);
2318   GL_VERSION_1_3 := CheckVersion(1, 3);
2319   GL_VERSION_1_4 := CheckVersion(1, 4);
2320   GL_VERSION_2_0 := CheckVersion(2, 0);
2321   GL_VERSION_3_3 := CheckVersion(3, 3);
2322
2323   // Extensions
2324   Buffer := glGetString(GL_EXTENSIONS);
2325   GL_ARB_texture_border_clamp       := CheckExtension('GL_ARB_texture_border_clamp');
2326   GL_ARB_texture_non_power_of_two   := CheckExtension('GL_ARB_texture_non_power_of_two');
2327   GL_ARB_texture_swizzle            := CheckExtension('GL_ARB_texture_swizzle');
2328   GL_ARB_texture_cube_map           := CheckExtension('GL_ARB_texture_cube_map');
2329   GL_ARB_texture_rectangle          := CheckExtension('GL_ARB_texture_rectangle');
2330   GL_ARB_texture_mirrored_repeat    := CheckExtension('GL_ARB_texture_mirrored_repeat');
2331   GL_EXT_texture_edge_clamp         := CheckExtension('GL_EXT_texture_edge_clamp');
2332   GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
2333   GL_EXT_texture_rectangle          := CheckExtension('GL_EXT_texture_rectangle');
2334   GL_EXT_texture_swizzle            := CheckExtension('GL_EXT_texture_swizzle');
2335   GL_EXT_texture_cube_map           := CheckExtension('GL_EXT_texture_cube_map');
2336   GL_NV_texture_rectangle           := CheckExtension('GL_NV_texture_rectangle');
2337   GL_IBM_texture_mirrored_repeat    := CheckExtension('GL_IBM_texture_mirrored_repeat');
2338   GL_SGIS_generate_mipmap           := CheckExtension('GL_SGIS_generate_mipmap');
2339
2340   if GL_VERSION_1_3 then begin
2341     glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1D');
2342     glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2D');
2343     glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage');
2344   end else begin
2345     glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1DARB',  nil, false);
2346     glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2DARB',  nil, false);
2347     glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false);
2348   end;
2349 end;
2350 {$ENDIF}
2351
2352 {$IFDEF GLB_SDL_IMAGE}
2353 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2354 // SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2355 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2356 function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
2357 begin
2358   result := TStream(context^.unknown.data1).Seek(offset, whence);
2359 end;
2360
2361 function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
2362 begin
2363   result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
2364 end;
2365
2366 function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
2367 begin
2368   result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
2369 end;
2370
2371 function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
2372 begin
2373   result := 0;
2374 end;
2375
2376 function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
2377 begin
2378   result := SDL_AllocRW;
2379
2380   if result = nil then
2381     raise EglBitmap.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
2382
2383   result^.seek := glBitmapRWseek;
2384   result^.read := glBitmapRWread;
2385   result^.write := glBitmapRWwrite;
2386   result^.close := glBitmapRWclose;
2387   result^.unknown.data1 := Stream;
2388 end;
2389 {$ENDIF}
2390
2391 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2392 procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
2393 begin
2394   glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
2395 end;
2396
2397 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2398 procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
2399 begin
2400   glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
2401 end;
2402
2403 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2404 procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
2405 begin
2406   glBitmapDefaultMipmap := aValue;
2407 end;
2408
2409 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2410 procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
2411 begin
2412   glBitmapDefaultFormat := aFormat;
2413 end;
2414
2415 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2416 procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
2417 begin
2418   glBitmapDefaultFilterMin := aMin;
2419   glBitmapDefaultFilterMag := aMag;
2420 end;
2421
2422 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2423 procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
2424 begin
2425   glBitmapDefaultWrapS := S;
2426   glBitmapDefaultWrapT := T;
2427   glBitmapDefaultWrapR := R;
2428 end;
2429
2430 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2431 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
2432 procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
2433 begin
2434   glDefaultSwizzle[0] := r;
2435   glDefaultSwizzle[1] := g;
2436   glDefaultSwizzle[2] := b;
2437   glDefaultSwizzle[3] := a;
2438 end;
2439 {$IFEND}
2440
2441 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2442 function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
2443 begin
2444   result := glBitmapDefaultDeleteTextureOnFree;
2445 end;
2446
2447 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2448 function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
2449 begin
2450   result := glBitmapDefaultFreeDataAfterGenTextures;
2451 end;
2452
2453 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2454 function glBitmapGetDefaultMipmap: TglBitmapMipMap;
2455 begin
2456   result := glBitmapDefaultMipmap;
2457 end;
2458
2459 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2460 function glBitmapGetDefaultFormat: TglBitmapFormat;
2461 begin
2462   result := glBitmapDefaultFormat;
2463 end;
2464
2465 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2466 procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
2467 begin
2468   aMin := glBitmapDefaultFilterMin;
2469   aMag := glBitmapDefaultFilterMag;
2470 end;
2471
2472 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2473 procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
2474 begin
2475   S := glBitmapDefaultWrapS;
2476   T := glBitmapDefaultWrapT;
2477   R := glBitmapDefaultWrapR;
2478 end;
2479
2480 {$IFNDEF OPENGL_ES}
2481 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2482 procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
2483 begin
2484   r := glDefaultSwizzle[0];
2485   g := glDefaultSwizzle[1];
2486   b := glDefaultSwizzle[2];
2487   a := glDefaultSwizzle[3];
2488 end;
2489 {$ENDIF}
2490
2491 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2492 //TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2493 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2494 function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer;
2495 var
2496   w, h: Integer;
2497 begin
2498   if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin
2499     w := Max(1, aSize.X);
2500     h := Max(1, aSize.Y);
2501     result := GetSize(w, h);
2502   end else
2503     result := 0;
2504 end;
2505
2506 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2507 function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer;
2508 begin
2509   result := 0;
2510   if (aWidth <= 0) or (aHeight <= 0) then
2511     exit;
2512   result := Ceil(aWidth * aHeight * BytesPerPixel);
2513 end;
2514
2515 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2516 function TFormatDescriptor.CreateMappingData: Pointer;
2517 begin
2518   result := nil;
2519 end;
2520
2521 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2522 procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer);
2523 begin
2524   //DUMMY
2525 end;
2526
2527 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2528 function TFormatDescriptor.IsEmpty: Boolean;
2529 begin
2530   result := (fFormat = tfEmpty);
2531 end;
2532
2533 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2534 function TFormatDescriptor.MaskMatch(const aMask: TglBitmapRec4ul): Boolean;
2535 var
2536   i: Integer;
2537   m: TglBitmapRec4ul;
2538 begin
2539   result := false;
2540   if (aMask.r = 0) and (aMask.g = 0) and (aMask.b = 0) and (aMask.a = 0) then
2541     raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
2542   m := Mask;
2543   for i := 0 to 3 do
2544     if (aMask.arr[i] <> m.arr[i]) then
2545       exit;
2546   result := true;
2547 end;
2548
2549 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2550 procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData);
2551 begin
2552   FillChar(aPixel{%H-}, SizeOf(aPixel), 0);
2553   aPixel.Data   := Range;
2554   aPixel.Format := fFormat;
2555   aPixel.Range  := Range;
2556 end;
2557
2558 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2559 constructor TFormatDescriptor.Create;
2560 begin
2561   inherited Create;
2562 end;
2563
2564 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2565 //TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2566 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2567 procedure TfdAlphaUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2568 begin
2569   aData^ := aPixel.Data.a;
2570   inc(aData);
2571 end;
2572
2573 procedure TfdAlphaUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2574 begin
2575   aPixel.Data.r := 0;
2576   aPixel.Data.g := 0;
2577   aPixel.Data.b := 0;
2578   aPixel.Data.a := aData^;
2579   inc(aData);
2580 end;
2581
2582 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2583 //TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2584 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2585 procedure TfdLuminanceUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2586 begin
2587   aData^ := LuminanceWeight(aPixel);
2588   inc(aData);
2589 end;
2590
2591 procedure TfdLuminanceUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2592 begin
2593   aPixel.Data.r := aData^;
2594   aPixel.Data.g := aData^;
2595   aPixel.Data.b := aData^;
2596   aPixel.Data.a := 0;
2597   inc(aData);
2598 end;
2599
2600 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2601 //TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2602 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2603 procedure TfdUniversalUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2604 var
2605   i: Integer;
2606 begin
2607   aData^ := 0;
2608   for i := 0 to 3 do
2609     if (Range.arr[i] > 0) then
2610       aData^ := aData^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
2611   inc(aData);
2612 end;
2613
2614 procedure TfdUniversalUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2615 var
2616   i: Integer;
2617 begin
2618   for i := 0 to 3 do
2619     aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and Range.arr[i];
2620   inc(aData);
2621 end;
2622
2623 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2624 //TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2625 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2626 procedure TfdLuminanceAlphaUB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2627 begin
2628   inherited Map(aPixel, aData, aMapData);
2629   aData^ := aPixel.Data.a;
2630   inc(aData);
2631 end;
2632
2633 procedure TfdLuminanceAlphaUB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2634 begin
2635   inherited Unmap(aData, aPixel, aMapData);
2636   aPixel.Data.a := aData^;
2637   inc(aData);
2638 end;
2639
2640 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2641 //TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2642 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2643 procedure TfdRGBub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2644 begin
2645   aData^ := aPixel.Data.r;
2646   inc(aData);
2647   aData^ := aPixel.Data.g;
2648   inc(aData);
2649   aData^ := aPixel.Data.b;
2650   inc(aData);
2651 end;
2652
2653 procedure TfdRGBub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2654 begin
2655   aPixel.Data.r := aData^;
2656   inc(aData);
2657   aPixel.Data.g := aData^;
2658   inc(aData);
2659   aPixel.Data.b := aData^;
2660   inc(aData);
2661   aPixel.Data.a := 0;
2662 end;
2663
2664 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2665 //TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2666 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2667 procedure TfdBGRub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2668 begin
2669   aData^ := aPixel.Data.b;
2670   inc(aData);
2671   aData^ := aPixel.Data.g;
2672   inc(aData);
2673   aData^ := aPixel.Data.r;
2674   inc(aData);
2675 end;
2676
2677 procedure TfdBGRub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2678 begin
2679   aPixel.Data.b := aData^;
2680   inc(aData);
2681   aPixel.Data.g := aData^;
2682   inc(aData);
2683   aPixel.Data.r := aData^;
2684   inc(aData);
2685   aPixel.Data.a := 0;
2686 end;
2687
2688 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2689 //TfdRGBA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2690 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2691 procedure TfdRGBAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2692 begin
2693   inherited Map(aPixel, aData, aMapData);
2694   aData^ := aPixel.Data.a;
2695   inc(aData);
2696 end;
2697
2698 procedure TfdRGBAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2699 begin
2700   inherited Unmap(aData, aPixel, aMapData);
2701   aPixel.Data.a := aData^;
2702   inc(aData);
2703 end;
2704
2705 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2706 //TfdBGRA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2707 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2708 procedure TfdBGRAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2709 begin
2710   inherited Map(aPixel, aData, aMapData);
2711   aData^ := aPixel.Data.a;
2712   inc(aData);
2713 end;
2714
2715 procedure TfdBGRAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2716 begin
2717   inherited Unmap(aData, aPixel, aMapData);
2718   aPixel.Data.a := aData^;
2719   inc(aData);
2720 end;
2721
2722 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2723 //TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2724 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2725 procedure TfdAlphaUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2726 begin
2727   PWord(aData)^ := aPixel.Data.a;
2728   inc(aData, 2);
2729 end;
2730
2731 procedure TfdAlphaUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2732 begin
2733   aPixel.Data.r := 0;
2734   aPixel.Data.g := 0;
2735   aPixel.Data.b := 0;
2736   aPixel.Data.a := PWord(aData)^;
2737   inc(aData, 2);
2738 end;
2739
2740 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2741 //TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2742 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2743 procedure TfdLuminanceUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2744 begin
2745   PWord(aData)^ := LuminanceWeight(aPixel);
2746   inc(aData, 2);
2747 end;
2748
2749 procedure TfdLuminanceUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2750 begin
2751   aPixel.Data.r := PWord(aData)^;
2752   aPixel.Data.g := PWord(aData)^;
2753   aPixel.Data.b := PWord(aData)^;
2754   aPixel.Data.a := 0;
2755   inc(aData, 2);
2756 end;
2757
2758 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2759 //TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2760 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2761 procedure TfdUniversalUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2762 var
2763   i: Integer;
2764 begin
2765   PWord(aData)^ := 0;
2766   for i := 0 to 3 do
2767     if (Range.arr[i] > 0) then
2768       PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
2769   inc(aData, 2);
2770 end;
2771
2772 procedure TfdUniversalUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2773 var
2774   i: Integer;
2775 begin
2776   for i := 0 to 3 do
2777     aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and Range.arr[i];
2778   inc(aData, 2);
2779 end;
2780
2781 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2782 //TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2783 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2784 procedure TfdDepthUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2785 begin
2786   PWord(aData)^ := DepthWeight(aPixel);
2787   inc(aData, 2);
2788 end;
2789
2790 procedure TfdDepthUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2791 begin
2792   aPixel.Data.r := PWord(aData)^;
2793   aPixel.Data.g := PWord(aData)^;
2794   aPixel.Data.b := PWord(aData)^;
2795   aPixel.Data.a := PWord(aData)^;;
2796   inc(aData, 2);
2797 end;
2798
2799 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2800 //TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2801 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2802 procedure TfdLuminanceAlphaUS2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2803 begin
2804   inherited Map(aPixel, aData, aMapData);
2805   PWord(aData)^ := aPixel.Data.a;
2806   inc(aData, 2);
2807 end;
2808
2809 procedure TfdLuminanceAlphaUS2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2810 begin
2811   inherited Unmap(aData, aPixel, aMapData);
2812   aPixel.Data.a := PWord(aData)^;
2813   inc(aData, 2);
2814 end;
2815
2816 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2817 //TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2818 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2819 procedure TfdRGBus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2820 begin
2821   PWord(aData)^ := aPixel.Data.r;
2822   inc(aData, 2);
2823   PWord(aData)^ := aPixel.Data.g;
2824   inc(aData, 2);
2825   PWord(aData)^ := aPixel.Data.b;
2826   inc(aData, 2);
2827 end;
2828
2829 procedure TfdRGBus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2830 begin
2831   aPixel.Data.r := PWord(aData)^;
2832   inc(aData, 2);
2833   aPixel.Data.g := PWord(aData)^;
2834   inc(aData, 2);
2835   aPixel.Data.b := PWord(aData)^;
2836   inc(aData, 2);
2837   aPixel.Data.a := 0;
2838 end;
2839
2840 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2841 //TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2842 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2843 procedure TfdBGRus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2844 begin
2845   PWord(aData)^ := aPixel.Data.b;
2846   inc(aData, 2);
2847   PWord(aData)^ := aPixel.Data.g;
2848   inc(aData, 2);
2849   PWord(aData)^ := aPixel.Data.r;
2850   inc(aData, 2);
2851 end;
2852
2853 procedure TfdBGRus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2854 begin
2855   aPixel.Data.b := PWord(aData)^;
2856   inc(aData, 2);
2857   aPixel.Data.g := PWord(aData)^;
2858   inc(aData, 2);
2859   aPixel.Data.r := PWord(aData)^;
2860   inc(aData, 2);
2861   aPixel.Data.a := 0;
2862 end;
2863
2864 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2865 //TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2866 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2867 procedure TfdRGBAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2868 begin
2869   inherited Map(aPixel, aData, aMapData);
2870   PWord(aData)^ := aPixel.Data.a;
2871   inc(aData, 2);
2872 end;
2873
2874 procedure TfdRGBAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2875 begin
2876   inherited Unmap(aData, aPixel, aMapData);
2877   aPixel.Data.a := PWord(aData)^;
2878   inc(aData, 2);
2879 end;
2880
2881 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2882 //TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2883 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2884 procedure TfdARGBus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2885 begin
2886   PWord(aData)^ := aPixel.Data.a;
2887   inc(aData, 2);
2888   inherited Map(aPixel, aData, aMapData);
2889 end;
2890
2891 procedure TfdARGBus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2892 begin
2893   aPixel.Data.a := PWord(aData)^;
2894   inc(aData, 2);
2895   inherited Unmap(aData, aPixel, aMapData);
2896 end;
2897
2898 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2899 //TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2900 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2901 procedure TfdBGRAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2902 begin
2903   inherited Map(aPixel, aData, aMapData);
2904   PWord(aData)^ := aPixel.Data.a;
2905   inc(aData, 2);
2906 end;
2907
2908 procedure TfdBGRAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2909 begin
2910   inherited Unmap(aData, aPixel, aMapData);
2911   aPixel.Data.a := PWord(aData)^;
2912   inc(aData, 2);
2913 end;
2914
2915 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2916 //TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2917 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2918 procedure TfdABGRus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2919 begin
2920   PWord(aData)^ := aPixel.Data.a;
2921   inc(aData, 2);
2922   inherited Map(aPixel, aData, aMapData);
2923 end;
2924
2925 procedure TfdABGRus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2926 begin
2927   aPixel.Data.a := PWord(aData)^;
2928   inc(aData, 2);
2929   inherited Unmap(aData, aPixel, aMapData);
2930 end;
2931
2932 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2933 //TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2934 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2935 procedure TfdUniversalUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2936 var
2937   i: Integer;
2938 begin
2939   PCardinal(aData)^ := 0;
2940   for i := 0 to 3 do
2941     if (Range.arr[i] > 0) then
2942       PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
2943   inc(aData, 4);
2944 end;
2945
2946 procedure TfdUniversalUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2947 var
2948   i: Integer;
2949 begin
2950   for i := 0 to 3 do
2951     aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and Range.arr[i];
2952   inc(aData, 2);
2953 end;
2954
2955 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2956 //TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2957 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2958 procedure TfdDepthUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
2959 begin
2960   PCardinal(aData)^ := DepthWeight(aPixel);
2961   inc(aData, 4);
2962 end;
2963
2964 procedure TfdDepthUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
2965 begin
2966   aPixel.Data.r := PCardinal(aData)^;
2967   aPixel.Data.g := PCardinal(aData)^;
2968   aPixel.Data.b := PCardinal(aData)^;
2969   aPixel.Data.a := PCardinal(aData)^;
2970   inc(aData, 4);
2971 end;
2972
2973 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2974 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2975 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2976 procedure TfdAlpha4ub1.SetValues;
2977 begin
2978   inherited SetValues;
2979   fBitsPerPixel     := 8;
2980   fFormat           := tfAlpha4ub1;
2981   fWithAlpha        := tfAlpha4ub1;
2982   fPrecision        := glBitmapRec4ub(0, 0, 0, 8);
2983   fShift            := glBitmapRec4ub(0, 0, 0, 0);
2984 {$IFNDEF OPENGL_ES}
2985   fOpenGLFormat     := tfAlpha4ub1;
2986   fglFormat         := GL_ALPHA;
2987   fglInternalFormat := GL_ALPHA4;
2988   fglDataFormat     := GL_UNSIGNED_BYTE;
2989 {$ELSE}
2990   fOpenGLFormat     := tfAlpha8ub1;
2991 {$ENDIF}
2992 end;
2993
2994 procedure TfdAlpha8ub1.SetValues;
2995 begin
2996   inherited SetValues;
2997   fBitsPerPixel     := 8;
2998   fFormat           := tfAlpha8ub1;
2999   fWithAlpha        := tfAlpha8ub1;
3000   fPrecision        := glBitmapRec4ub(0, 0, 0, 8);
3001   fShift            := glBitmapRec4ub(0, 0, 0, 0);
3002   fOpenGLFormat     := tfAlpha8ub1;
3003   fglFormat         := GL_ALPHA;
3004   fglInternalFormat := {$IFNDEF OPENGL_ES}GL_ALPHA8{$ELSE}GL_ALPHA{$ENDIF};
3005   fglDataFormat     := GL_UNSIGNED_BYTE;
3006 end;
3007
3008 procedure TfdAlpha16us1.SetValues;
3009 begin
3010   inherited SetValues;
3011   fBitsPerPixel     := 16;
3012   fFormat           := tfAlpha16us1;
3013   fWithAlpha        := tfAlpha16us1;
3014   fPrecision        := glBitmapRec4ub(0, 0, 0, 16);
3015   fShift            := glBitmapRec4ub(0, 0, 0,  0);
3016 {$IFNDEF OPENGL_ES}
3017   fOpenGLFormat     := tfAlpha16us1;
3018   fglFormat         := GL_ALPHA;
3019   fglInternalFormat := GL_ALPHA16;
3020   fglDataFormat     := GL_UNSIGNED_SHORT;
3021 {$ELSE}
3022   fOpenGLFormat     := tfAlpha8ub1;
3023 {$ENDIF}
3024 end;
3025
3026 procedure TfdLuminance4ub1.SetValues;
3027 begin
3028   inherited SetValues;
3029   fBitsPerPixel     := 8;
3030   fFormat           := tfLuminance4ub1;
3031   fWithAlpha        := tfLuminance4Alpha4ub2;
3032   fWithoutAlpha     := tfLuminance4ub1;
3033   fPrecision        := glBitmapRec4ub(8, 8, 8, 0);
3034   fShift            := glBitmapRec4ub(0, 0, 0, 0);
3035 {$IFNDEF OPENGL_ES}
3036   fOpenGLFormat     := tfLuminance4ub1;
3037   fglFormat         := GL_LUMINANCE;
3038   fglInternalFormat := GL_LUMINANCE4;
3039   fglDataFormat     := GL_UNSIGNED_BYTE;
3040 {$ELSE}
3041   fOpenGLFormat     := tfLuminance8ub1;
3042 {$ENDIF}
3043 end;
3044
3045 procedure TfdLuminance8ub1.SetValues;
3046 begin
3047   inherited SetValues;
3048   fBitsPerPixel     := 8;
3049   fFormat           := tfLuminance8ub1;
3050   fWithAlpha        := tfLuminance8Alpha8ub2;
3051   fWithoutAlpha     := tfLuminance8ub1;
3052   fOpenGLFormat     := tfLuminance8ub1;
3053   fPrecision        := glBitmapRec4ub(8, 8, 8, 0);
3054   fShift            := glBitmapRec4ub(0, 0, 0, 0);
3055   fglFormat         := GL_LUMINANCE;
3056   fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8{$ELSE}GL_LUMINANCE{$ENDIF};
3057   fglDataFormat     := GL_UNSIGNED_BYTE;
3058 end;
3059
3060 procedure TfdLuminance16us1.SetValues;
3061 begin
3062   inherited SetValues;
3063   fBitsPerPixel     := 16;
3064   fFormat           := tfLuminance16us1;
3065   fWithAlpha        := tfLuminance16Alpha16us2;
3066   fWithoutAlpha     := tfLuminance16us1;
3067   fPrecision        := glBitmapRec4ub(16, 16, 16,  0);
3068   fShift            := glBitmapRec4ub( 0,  0,  0,  0);
3069 {$IFNDEF OPENGL_ES}
3070   fOpenGLFormat     := tfLuminance16us1;
3071   fglFormat         := GL_LUMINANCE;
3072   fglInternalFormat := GL_LUMINANCE16;
3073   fglDataFormat     := GL_UNSIGNED_SHORT;
3074 {$ELSE}
3075   fOpenGLFormat     := tfLuminance8ub1;
3076 {$ENDIF}
3077 end;
3078
3079 procedure TfdLuminance4Alpha4ub2.SetValues;
3080 begin
3081   inherited SetValues;
3082   fBitsPerPixel     := 16;
3083   fFormat           := tfLuminance4Alpha4ub2;
3084   fWithAlpha        := tfLuminance4Alpha4ub2;
3085   fWithoutAlpha     := tfLuminance4ub1;
3086   fPrecision        := glBitmapRec4ub(8, 8, 8, 8);
3087   fShift            := glBitmapRec4ub(0, 0, 0, 8);
3088 {$IFNDEF OPENGL_ES}
3089   fOpenGLFormat     := tfLuminance4Alpha4ub2;
3090   fglFormat         := GL_LUMINANCE_ALPHA;
3091   fglInternalFormat := GL_LUMINANCE4_ALPHA4;
3092   fglDataFormat     := GL_UNSIGNED_BYTE;
3093 {$ELSE}
3094   fOpenGLFormat     := tfLuminance8Alpha8ub2;
3095 {$ENDIF}
3096 end;
3097
3098 procedure TfdLuminance6Alpha2ub2.SetValues;
3099 begin
3100   inherited SetValues;
3101   fBitsPerPixel     := 16;
3102   fFormat           := tfLuminance6Alpha2ub2;
3103   fWithAlpha        := tfLuminance6Alpha2ub2;
3104   fWithoutAlpha     := tfLuminance8ub1;
3105   fPrecision        := glBitmapRec4ub(8, 8, 8, 8);
3106   fShift            := glBitmapRec4ub(0, 0, 0, 8);
3107 {$IFNDEF OPENGL_ES}
3108   fOpenGLFormat     := tfLuminance6Alpha2ub2;
3109   fglFormat         := GL_LUMINANCE_ALPHA;
3110   fglInternalFormat := GL_LUMINANCE6_ALPHA2;
3111   fglDataFormat     := GL_UNSIGNED_BYTE;
3112 {$ELSE}
3113   fOpenGLFormat     := tfLuminance8Alpha8ub2;
3114 {$ENDIF}
3115 end;
3116
3117 procedure TfdLuminance8Alpha8ub2.SetValues;
3118 begin
3119   inherited SetValues;
3120   fBitsPerPixel     := 16;
3121   fFormat           := tfLuminance8Alpha8ub2;
3122   fWithAlpha        := tfLuminance8Alpha8ub2;
3123   fWithoutAlpha     := tfLuminance8ub1;
3124   fOpenGLFormat     := tfLuminance8Alpha8ub2;
3125   fPrecision        := glBitmapRec4ub(8, 8, 8, 8);
3126   fShift            := glBitmapRec4ub(0, 0, 0, 8);
3127   fglFormat         := GL_LUMINANCE_ALPHA;
3128   fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8_ALPHA8{$ELSE}GL_LUMINANCE_ALPHA{$ENDIF};
3129   fglDataFormat     := GL_UNSIGNED_BYTE;
3130 end;
3131
3132 procedure TfdLuminance12Alpha4us2.SetValues;
3133 begin
3134   inherited SetValues;
3135   fBitsPerPixel     := 32;
3136   fFormat           := tfLuminance12Alpha4us2;
3137   fWithAlpha        := tfLuminance12Alpha4us2;
3138   fWithoutAlpha     := tfLuminance16us1;
3139   fPrecision        := glBitmapRec4ub(16, 16, 16, 16);
3140   fShift            := glBitmapRec4ub( 0,  0,  0, 16);
3141 {$IFNDEF OPENGL_ES}
3142   fOpenGLFormat     := tfLuminance12Alpha4us2;
3143   fglFormat         := GL_LUMINANCE_ALPHA;
3144   fglInternalFormat := GL_LUMINANCE12_ALPHA4;
3145   fglDataFormat     := GL_UNSIGNED_SHORT;
3146 {$ELSE}
3147   fOpenGLFormat     := tfLuminance8Alpha8ub2;
3148 {$ENDIF}
3149 end;
3150
3151 procedure TfdLuminance16Alpha16us2.SetValues;
3152 begin
3153   inherited SetValues;
3154   fBitsPerPixel     := 32;
3155   fFormat           := tfLuminance16Alpha16us2;
3156   fWithAlpha        := tfLuminance16Alpha16us2;
3157   fWithoutAlpha     := tfLuminance16us1;
3158   fPrecision        := glBitmapRec4ub(16, 16, 16, 16);
3159   fShift            := glBitmapRec4ub( 0,  0,  0, 16);
3160 {$IFNDEF OPENGL_ES}
3161   fOpenGLFormat     := tfLuminance16Alpha16us2;
3162   fglFormat         := GL_LUMINANCE_ALPHA;
3163   fglInternalFormat := GL_LUMINANCE16_ALPHA16;
3164   fglDataFormat     := GL_UNSIGNED_SHORT;
3165 {$ELSE}
3166   fOpenGLFormat     := tfLuminance8Alpha8ub2;
3167 {$ENDIF}
3168 end;
3169
3170 procedure TfdR3G3B2ub1.SetValues;
3171 begin
3172   inherited SetValues;
3173   fBitsPerPixel     := 8;
3174   fFormat           := tfR3G3B2ub1;
3175   fWithAlpha        := tfRGBA4us1;
3176   fWithoutAlpha     := tfR3G3B2ub1;
3177   fRGBInverted      := tfEmpty;
3178   fPrecision        := glBitmapRec4ub(3, 3, 2, 0);
3179   fShift            := glBitmapRec4ub(5, 2, 0, 0);
3180 {$IFNDEF OPENGL_ES}
3181   fOpenGLFormat     := tfR3G3B2ub1;
3182   fglFormat         := GL_RGB;
3183   fglInternalFormat := GL_R3_G3_B2;
3184   fglDataFormat     := GL_UNSIGNED_BYTE_3_3_2;
3185 {$ELSE}
3186   fOpenGLFormat     := tfR5G6B5us1;
3187 {$ENDIF}
3188 end;
3189
3190 procedure TfdRGBX4us1.SetValues;
3191 begin
3192   inherited SetValues;
3193   fBitsPerPixel     := 16;
3194   fFormat           := tfRGBX4us1;
3195   fWithAlpha        := tfRGBA4us1;
3196   fWithoutAlpha     := tfRGBX4us1;
3197   fRGBInverted      := tfBGRX4us1;
3198   fPrecision        := glBitmapRec4ub( 4, 4, 4, 0);
3199   fShift            := glBitmapRec4ub(12, 8, 4, 0);
3200 {$IFNDEF OPENGL_ES}
3201   fOpenGLFormat     := tfRGBX4us1;
3202   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3203   fglInternalFormat := GL_RGB4;
3204   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
3205 {$ELSE}
3206   fOpenGLFormat     := tfR5G6B5us1;
3207 {$ENDIF}
3208 end;
3209
3210 procedure TfdXRGB4us1.SetValues;
3211 begin
3212   inherited SetValues;
3213   fBitsPerPixel     := 16;
3214   fFormat           := tfXRGB4us1;
3215   fWithAlpha        := tfARGB4us1;
3216   fWithoutAlpha     := tfXRGB4us1;
3217   fRGBInverted      := tfXBGR4us1;
3218   fPrecision        := glBitmapRec4ub(4, 4, 4, 0);
3219   fShift            := glBitmapRec4ub(8, 4, 0, 0);
3220 {$IFNDEF OPENGL_ES}
3221   fOpenGLFormat     := tfXRGB4us1;
3222   fglFormat         := GL_BGRA;
3223   fglInternalFormat := GL_RGB4;
3224   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
3225 {$ELSE}
3226   fOpenGLFormat     := tfR5G6B5us1;
3227 {$ENDIF}
3228 end;
3229
3230 procedure TfdR5G6B5us1.SetValues;
3231 begin
3232   inherited SetValues;
3233   fBitsPerPixel     := 16;
3234   fFormat           := tfR5G6B5us1;
3235   fWithAlpha        := tfRGB5A1us1;
3236   fWithoutAlpha     := tfR5G6B5us1;
3237   fRGBInverted      := tfB5G6R5us1;
3238   fPrecision        := glBitmapRec4ub( 5, 6, 5, 0);
3239   fShift            := glBitmapRec4ub(11, 5, 0, 0);
3240 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
3241   fOpenGLFormat     := tfR5G6B5us1;
3242   fglFormat         := GL_RGB;
3243   fglInternalFormat := GL_RGB565;
3244   fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
3245 {$ELSE}
3246   fOpenGLFormat     := tfRGB8ub3;
3247 {$IFEND}
3248 end;
3249
3250 procedure TfdRGB5X1us1.SetValues;
3251 begin
3252   inherited SetValues;
3253   fBitsPerPixel     := 16;
3254   fFormat           := tfRGB5X1us1;
3255   fWithAlpha        := tfRGB5A1us1;
3256   fWithoutAlpha     := tfRGB5X1us1;
3257   fRGBInverted      := tfBGR5X1us1;
3258   fPrecision        := glBitmapRec4ub( 5, 5, 5, 0);
3259   fShift            := glBitmapRec4ub(11, 6, 1, 0);
3260 {$IFNDEF OPENGL_ES}
3261   fOpenGLFormat     := tfRGB5X1us1;
3262   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3263   fglInternalFormat := GL_RGB5;
3264   fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
3265 {$ELSE}
3266   fOpenGLFormat     := tfR5G6B5us1;
3267 {$ENDIF}
3268 end;
3269
3270 procedure TfdX1RGB5us1.SetValues;
3271 begin
3272   inherited SetValues;
3273   fBitsPerPixel     := 16;
3274   fFormat           := tfX1RGB5us1;
3275   fWithAlpha        := tfA1RGB5us1;
3276   fWithoutAlpha     := tfX1RGB5us1;
3277   fRGBInverted      := tfX1BGR5us1;
3278   fPrecision        := glBitmapRec4ub( 5, 5, 5, 0);
3279   fShift            := glBitmapRec4ub(10, 5, 0, 0);
3280 {$IFNDEF OPENGL_ES}
3281   fOpenGLFormat     := tfX1RGB5us1;
3282   fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3283   fglInternalFormat := GL_RGB5;
3284   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
3285 {$ELSE}
3286   fOpenGLFormat     := tfR5G6B5us1;
3287 {$ENDIF}
3288 end;
3289
3290 procedure TfdRGB8ub3.SetValues;
3291 begin
3292   inherited SetValues;
3293   fBitsPerPixel     := 24;
3294   fFormat           := tfRGB8ub3;
3295   fWithAlpha        := tfRGBA8ub4;
3296   fWithoutAlpha     := tfRGB8ub3;
3297   fRGBInverted      := tfBGR8ub3;
3298   fPrecision        := glBitmapRec4ub(8, 8,  8, 0);
3299   fShift            := glBitmapRec4ub(0, 8, 16, 0);
3300   fOpenGLFormat     := tfRGB8ub3;
3301   fglFormat         := GL_RGB;
3302   fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGB8{$ELSE}GL_RGB{$IFEND};
3303   fglDataFormat     := GL_UNSIGNED_BYTE;
3304 end;
3305
3306 procedure TfdRGBX8ui1.SetValues;
3307 begin
3308   inherited SetValues;
3309   fBitsPerPixel     := 32;
3310   fFormat           := tfRGBX8ui1;
3311   fWithAlpha        := tfRGBA8ui1;
3312   fWithoutAlpha     := tfRGBX8ui1;
3313   fRGBInverted      := tfBGRX8ui1;
3314   fPrecision        := glBitmapRec4ub( 8,  8,  8, 0);
3315   fShift            := glBitmapRec4ub(24, 16,  8, 0);
3316 {$IFNDEF OPENGL_ES}
3317   fOpenGLFormat     := tfRGBX8ui1;
3318   fglFormat         := GL_RGBA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3319   fglInternalFormat := GL_RGB8;
3320   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
3321 {$ELSE}
3322   fOpenGLFormat     := tfRGB8ub3;
3323 {$ENDIF}
3324 end;
3325
3326 procedure TfdXRGB8ui1.SetValues;
3327 begin
3328   inherited SetValues;
3329   fBitsPerPixel     := 32;
3330   fFormat           := tfXRGB8ui1;
3331   fWithAlpha        := tfXRGB8ui1;
3332   fWithoutAlpha     := tfXRGB8ui1;
3333   fOpenGLFormat     := tfXRGB8ui1;
3334   fRGBInverted      := tfXBGR8ui1;
3335   fPrecision        := glBitmapRec4ub( 8,  8,  8, 0);
3336   fShift            := glBitmapRec4ub(16,  8,  0, 0);
3337 {$IFNDEF OPENGL_ES}
3338   fOpenGLFormat     := tfXRGB8ui1;
3339   fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3340   fglInternalFormat := GL_RGB8;
3341   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
3342 {$ELSE}
3343   fOpenGLFormat     := tfRGB8ub3;
3344 {$ENDIF}
3345 end;
3346
3347 procedure TfdRGB10X2ui1.SetValues;
3348 begin
3349   inherited SetValues;
3350   fBitsPerPixel     := 32;
3351   fFormat           := tfRGB10X2ui1;
3352   fWithAlpha        := tfRGB10A2ui1;
3353   fWithoutAlpha     := tfRGB10X2ui1;
3354   fRGBInverted      := tfBGR10X2ui1;
3355   fPrecision        := glBitmapRec4ub(10, 10, 10, 0);
3356   fShift            := glBitmapRec4ub(22, 12,  2, 0);
3357 {$IFNDEF OPENGL_ES}
3358   fOpenGLFormat     := tfRGB10X2ui1;
3359   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3360   fglInternalFormat := GL_RGB10;
3361   fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
3362 {$ELSE}
3363   fOpenGLFormat     := tfRGB16us3;
3364 {$ENDIF}
3365 end;
3366
3367 procedure TfdX2RGB10ui1.SetValues;
3368 begin
3369   inherited SetValues;
3370   fBitsPerPixel     := 32;
3371   fFormat           := tfX2RGB10ui1;
3372   fWithAlpha        := tfA2RGB10ui1;
3373   fWithoutAlpha     := tfX2RGB10ui1;
3374   fRGBInverted      := tfX2BGR10ui1;
3375   fPrecision        := glBitmapRec4ub(10, 10, 10, 0);
3376   fShift            := glBitmapRec4ub(20, 10,  0, 0);
3377 {$IFNDEF OPENGL_ES}
3378   fOpenGLFormat     := tfX2RGB10ui1;
3379   fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3380   fglInternalFormat := GL_RGB10;
3381   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
3382 {$ELSE}
3383   fOpenGLFormat     := tfRGB16us3;
3384 {$ENDIF}
3385 end;
3386
3387 procedure TfdRGB16us3.SetValues;
3388 begin
3389   inherited SetValues;
3390   fBitsPerPixel     := 48;
3391   fFormat           := tfRGB16us3;
3392   fWithAlpha        := tfRGBA16us4;
3393   fWithoutAlpha     := tfRGB16us3;
3394   fRGBInverted      := tfBGR16us3;
3395   fPrecision        := glBitmapRec4ub(16, 16, 16, 0);
3396   fShift            := glBitmapRec4ub( 0, 16, 32, 0);
3397 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
3398   fOpenGLFormat     := tfRGB16us3;
3399   fglFormat         := GL_RGB;
3400   fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGB16{$ELSE}GL_RGB16UI{$ENDIF};
3401   fglDataFormat     := GL_UNSIGNED_SHORT;
3402 {$ELSE}
3403   fOpenGLFormat     := tfRGB8ub3;
3404 {$IFEND}
3405 end;
3406
3407 procedure TfdRGBA4us1.SetValues;
3408 begin
3409   inherited SetValues;
3410   fBitsPerPixel     := 16;
3411   fFormat           := tfRGBA4us1;
3412   fWithAlpha        := tfRGBA4us1;
3413   fWithoutAlpha     := tfRGBX4us1;
3414   fOpenGLFormat     := tfRGBA4us1;
3415   fRGBInverted      := tfBGRA4us1;
3416   fPrecision        := glBitmapRec4ub( 4,  4,  4,  4);
3417   fShift            := glBitmapRec4ub(12,  8,  4,  0);
3418   fglFormat         := GL_RGBA;
3419   fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
3420   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
3421 end;
3422
3423 procedure TfdARGB4us1.SetValues;
3424 begin
3425   inherited SetValues;
3426   fBitsPerPixel     := 16;
3427   fFormat           := tfARGB4us1;
3428   fWithAlpha        := tfARGB4us1;
3429   fWithoutAlpha     := tfXRGB4us1;
3430   fRGBInverted      := tfABGR4us1;
3431   fPrecision        := glBitmapRec4ub( 4,  4,  4,  4);
3432   fShift            := glBitmapRec4ub( 8,  4,  0, 12);
3433 {$IFNDEF OPENGL_ES}
3434   fOpenGLFormat     := tfARGB4us1;
3435   fglFormat         := GL_BGRA;
3436   fglInternalFormat := GL_RGBA4;
3437   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
3438 {$ELSE}
3439   fOpenGLFormat     := tfRGBA4us1;
3440 {$ENDIF}
3441 end;
3442
3443 procedure TfdRGB5A1us1.SetValues;
3444 begin
3445   inherited SetValues;
3446   fBitsPerPixel     := 16;
3447   fFormat           := tfRGB5A1us1;
3448   fWithAlpha        := tfRGB5A1us1;
3449   fWithoutAlpha     := tfRGB5X1us1;
3450   fOpenGLFormat     := tfRGB5A1us1;
3451   fRGBInverted      := tfBGR5A1us1;
3452   fPrecision        := glBitmapRec4ub( 5,  5,  5,  1);
3453   fShift            := glBitmapRec4ub(11,  6,  1,  0);
3454   fglFormat         := GL_RGBA;
3455   fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}GL_RGB5_A1{$ELSE}GL_RGBA{$IFEND};
3456   fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
3457 end;
3458
3459 procedure TfdA1RGB5us1.SetValues;
3460 begin
3461   inherited SetValues;
3462   fBitsPerPixel     := 16;
3463   fFormat           := tfA1RGB5us1;
3464   fWithAlpha        := tfA1RGB5us1;
3465   fWithoutAlpha     := tfX1RGB5us1;
3466   fRGBInverted      := tfA1BGR5us1;
3467   fPrecision        := glBitmapRec4ub( 5,  5,  5,  1);
3468   fShift            := glBitmapRec4ub(10,  5,  0, 15);
3469 {$IFNDEF OPENGL_ES}
3470   fOpenGLFormat     := tfA1RGB5us1;
3471   fglFormat         := GL_BGRA;
3472   fglInternalFormat := GL_RGB5_A1;
3473   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
3474 {$ELSE}
3475   fOpenGLFormat     := tfRGB5A1us1;
3476 {$ENDIF}
3477 end;
3478
3479 procedure TfdRGBA8ui1.SetValues;
3480 begin
3481   inherited SetValues;
3482   fBitsPerPixel     := 32;
3483   fFormat           := tfRGBA8ui1;
3484   fWithAlpha        := tfRGBA8ui1;
3485   fWithoutAlpha     := tfRGBX8ui1;
3486   fRGBInverted      := tfBGRA8ui1;
3487   fPrecision        := glBitmapRec4ub( 8,  8,  8,  8);
3488   fShift            := glBitmapRec4ub(24, 16,  8,  0);
3489 {$IFNDEF OPENGL_ES}
3490   fOpenGLFormat     := tfRGBA8ui1;
3491   fglFormat         := GL_RGBA;
3492   fglInternalFormat := GL_RGBA8;
3493   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
3494 {$ELSE}
3495   fOpenGLFormat     := tfRGBA8ub4;
3496 {$ENDIF}
3497 end;
3498
3499 procedure TfdARGB8ui1.SetValues;
3500 begin
3501   inherited SetValues;
3502   fBitsPerPixel     := 32;
3503   fFormat           := tfARGB8ui1;
3504   fWithAlpha        := tfARGB8ui1;
3505   fWithoutAlpha     := tfXRGB8ui1;
3506   fRGBInverted      := tfABGR8ui1;
3507   fPrecision        := glBitmapRec4ub( 8,  8,  8,  8);
3508   fShift            := glBitmapRec4ub(16,  8,  0, 24);
3509 {$IFNDEF OPENGL_ES}
3510   fOpenGLFormat     := tfARGB8ui1;
3511   fglFormat         := GL_BGRA;
3512   fglInternalFormat := GL_RGBA8;
3513   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
3514 {$ELSE}
3515   fOpenGLFormat     := tfRGBA8ub4;
3516 {$ENDIF}
3517 end;
3518
3519 procedure TfdRGBA8ub4.SetValues;
3520 begin
3521   inherited SetValues;
3522   fBitsPerPixel     := 32;
3523   fFormat           := tfRGBA8ub4;
3524   fWithAlpha        := tfRGBA8ub4;
3525   fWithoutAlpha     := tfRGB8ub3;
3526   fOpenGLFormat     := tfRGBA8ub4;
3527   fRGBInverted      := tfBGRA8ub4;
3528   fPrecision        := glBitmapRec4ub( 8,  8,  8,  8);
3529   fShift            := glBitmapRec4ub( 0,  8, 16, 24);
3530   fglFormat         := GL_RGBA;
3531   fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
3532   fglDataFormat     := GL_UNSIGNED_BYTE;
3533 end;
3534
3535 procedure TfdRGB10A2ui1.SetValues;
3536 begin
3537   inherited SetValues;
3538   fBitsPerPixel     := 32;
3539   fFormat           := tfRGB10A2ui1;
3540   fWithAlpha        := tfRGB10A2ui1;
3541   fWithoutAlpha     := tfRGB10X2ui1;
3542   fRGBInverted      := tfBGR10A2ui1;
3543   fPrecision        := glBitmapRec4ub(10, 10, 10,  2);
3544   fShift            := glBitmapRec4ub(22, 12,  2,  0);
3545 {$IFNDEF OPENGL_ES}
3546   fOpenGLFormat     := tfRGB10A2ui1;
3547   fglFormat         := GL_RGBA;
3548   fglInternalFormat := GL_RGB10_A2;
3549   fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
3550 {$ELSE}
3551   fOpenGLFormat     := tfA2RGB10ui1;
3552 {$ENDIF}
3553 end;
3554
3555 procedure TfdA2RGB10ui1.SetValues;
3556 begin
3557   inherited SetValues;
3558   fBitsPerPixel     := 32;
3559   fFormat           := tfA2RGB10ui1;
3560   fWithAlpha        := tfA2RGB10ui1;
3561   fWithoutAlpha     := tfX2RGB10ui1;
3562   fRGBInverted      := tfA2BGR10ui1;
3563   fPrecision        := glBitmapRec4ub(10, 10, 10,  2);
3564   fShift            := glBitmapRec4ub(20, 10,  0, 30);
3565 {$IF NOT DEFINED(OPENGL_ES)}
3566   fOpenGLFormat     := tfA2RGB10ui1;
3567   fglFormat         := GL_BGRA;
3568   fglInternalFormat := GL_RGB10_A2;
3569   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
3570 {$ELSEIF DEFINED(OPENGL_ES_3_0)}
3571   fOpenGLFormat     := tfA2RGB10ui1;
3572   fglFormat         := GL_RGBA;
3573   fglInternalFormat := GL_RGB10_A2;
3574   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
3575 {$ELSE}
3576   fOpenGLFormat     := tfRGBA8ui1;
3577 {$IFEND}
3578 end;
3579
3580 procedure TfdRGBA16us4.SetValues;
3581 begin
3582   inherited SetValues;
3583   fBitsPerPixel     := 64;
3584   fFormat           := tfRGBA16us4;
3585   fWithAlpha        := tfRGBA16us4;
3586   fWithoutAlpha     := tfRGB16us3;
3587   fRGBInverted      := tfBGRA16us4;
3588   fPrecision        := glBitmapRec4ub(16, 16, 16, 16);
3589   fShift            := glBitmapRec4ub( 0, 16, 32, 48);
3590 {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
3591   fOpenGLFormat     := tfRGBA16us4;
3592   fglFormat         := GL_RGBA;
3593   fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGBA16{$ELSE}GL_RGBA16UI{$ENDIF};
3594   fglDataFormat     := GL_UNSIGNED_SHORT;
3595 {$ELSE}
3596   fOpenGLFormat     := tfRGBA8ub4;
3597 {$IFEND}
3598 end;
3599
3600 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3601 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3602 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3603 procedure TfdBGRX4us1.SetValues;
3604 begin
3605   inherited SetValues;
3606   fBitsPerPixel     := 16;
3607   fFormat           := tfBGRX4us1;
3608   fWithAlpha        := tfBGRA4us1;
3609   fWithoutAlpha     := tfBGRX4us1;
3610   fRGBInverted      := tfRGBX4us1;
3611   fPrecision        := glBitmapRec4ub( 4,  4,  4,  0);
3612   fShift            := glBitmapRec4ub( 4,  8, 12,  0);
3613 {$IFNDEF OPENGL_ES}
3614   fOpenGLFormat     := tfBGRX4us1;
3615   fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3616   fglInternalFormat := GL_RGB4;
3617   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
3618 {$ELSE}
3619   fOpenGLFormat     := tfR5G6B5us1;
3620 {$ENDIF}
3621 end;
3622
3623 procedure TfdXBGR4us1.SetValues;
3624 begin
3625   inherited SetValues;
3626   fBitsPerPixel     := 16;
3627   fFormat           := tfXBGR4us1;
3628   fWithAlpha        := tfABGR4us1;
3629   fWithoutAlpha     := tfXBGR4us1;
3630   fRGBInverted      := tfXRGB4us1;
3631   fPrecision        := glBitmapRec4ub( 4,  4,  4,  0);
3632   fShift            := glBitmapRec4ub( 0,  4,  8,  0);
3633 {$IFNDEF OPENGL_ES}
3634   fOpenGLFormat     := tfXBGR4us1;
3635   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3636   fglInternalFormat := GL_RGB4;
3637   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
3638 {$ELSE}
3639   fOpenGLFormat     := tfR5G6B5us1;
3640 {$ENDIF}
3641 end;
3642
3643 procedure TfdB5G6R5us1.SetValues;
3644 begin
3645   inherited SetValues;
3646   fBitsPerPixel     := 16;
3647   fFormat           := tfB5G6R5us1;
3648   fWithAlpha        := tfBGR5A1us1;
3649   fWithoutAlpha     := tfB5G6R5us1;
3650   fRGBInverted      := tfR5G6B5us1;
3651   fPrecision        := glBitmapRec4ub( 5,  6,  5,  0);
3652   fShift            := glBitmapRec4ub( 0,  5, 11,  0);
3653 {$IFNDEF OPENGL_ES}
3654   fOpenGLFormat     := tfB5G6R5us1;
3655   fglFormat         := GL_RGB;
3656   fglInternalFormat := GL_RGB565;
3657   fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
3658 {$ELSE}
3659   fOpenGLFormat     := tfR5G6B5us1;
3660 {$ENDIF}
3661 end;
3662
3663 procedure TfdBGR5X1us1.SetValues;
3664 begin
3665   inherited SetValues;
3666   fBitsPerPixel     := 16;
3667   fFormat           := tfBGR5X1us1;
3668   fWithAlpha        := tfBGR5A1us1;
3669   fWithoutAlpha     := tfBGR5X1us1;
3670   fRGBInverted      := tfRGB5X1us1;
3671   fPrecision        := glBitmapRec4ub( 5,  5,  5,  0);
3672   fShift            := glBitmapRec4ub( 1,  6, 11,  0);
3673 {$IFNDEF OPENGL_ES}
3674   fOpenGLFormat     := tfBGR5X1us1;
3675   fglFormat         := GL_BGRA;
3676   fglInternalFormat := GL_RGB5;
3677   fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
3678 {$ELSE}
3679   fOpenGLFormat     := tfR5G6B5us1;
3680 {$ENDIF}
3681 end;
3682
3683 procedure TfdX1BGR5us1.SetValues;
3684 begin
3685   inherited SetValues;
3686   fBitsPerPixel     := 16;
3687   fFormat           := tfX1BGR5us1;
3688   fWithAlpha        := tfA1BGR5us1;
3689   fWithoutAlpha     := tfX1BGR5us1;
3690   fRGBInverted      := tfX1RGB5us1;
3691   fPrecision        := glBitmapRec4ub( 5,  5,  5,  0);
3692   fShift            := glBitmapRec4ub( 0,  5, 10,  0);
3693 {$IFNDEF OPENGL_ES}
3694   fOpenGLFormat     := tfX1BGR5us1;
3695   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3696   fglInternalFormat := GL_RGB5;
3697   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
3698 {$ELSE}
3699   fOpenGLFormat     := tfR5G6B5us1;
3700 {$ENDIF}
3701 end;
3702
3703 procedure TfdBGR8ub3.SetValues;
3704 begin
3705   inherited SetValues;
3706   fBitsPerPixel     := 24;
3707   fFormat           := tfBGR8ub3;
3708   fWithAlpha        := tfBGRA8ub4;
3709   fWithoutAlpha     := tfBGR8ub3;
3710   fRGBInverted      := tfRGB8ub3;
3711   fPrecision        := glBitmapRec4ub( 8,  8,  8,  0);
3712   fShift            := glBitmapRec4ub(16,  8,  0,  0);
3713 {$IFNDEF OPENGL_ES}
3714   fOpenGLFormat     := tfBGR8ub3;
3715   fglFormat         := GL_BGR;
3716   fglInternalFormat := GL_RGB8;
3717   fglDataFormat     := GL_UNSIGNED_BYTE;
3718 {$ELSE}
3719   fOpenGLFormat     := tfRGB8ub3;
3720 {$ENDIF}
3721 end;
3722
3723 procedure TfdBGRX8ui1.SetValues;
3724 begin
3725   inherited SetValues;
3726   fBitsPerPixel     := 32;
3727   fFormat           := tfBGRX8ui1;
3728   fWithAlpha        := tfBGRA8ui1;
3729   fWithoutAlpha     := tfBGRX8ui1;
3730   fRGBInverted      := tfRGBX8ui1;
3731   fPrecision        := glBitmapRec4ub( 8,  8,  8,  0);
3732   fShift            := glBitmapRec4ub( 8, 16, 24,  0);
3733 {$IFNDEF OPENGL_ES}
3734   fOpenGLFormat     := tfBGRX8ui1;
3735   fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3736   fglInternalFormat := GL_RGB8;
3737   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
3738 {$ELSE}
3739   fOpenGLFormat     := tfRGB8ub3;
3740 {$ENDIF}
3741 end;
3742
3743 procedure TfdXBGR8ui1.SetValues;
3744 begin
3745   inherited SetValues;
3746   fBitsPerPixel     := 32;
3747   fFormat           := tfXBGR8ui1;
3748   fWithAlpha        := tfABGR8ui1;
3749   fWithoutAlpha     := tfXBGR8ui1;
3750   fRGBInverted      := tfXRGB8ui1;
3751   fPrecision        := glBitmapRec4ub( 8,  8,  8,  0);
3752   fShift            := glBitmapRec4ub( 0,  8, 16,  0);
3753 {$IFNDEF OPENGL_ES}
3754   fOpenGLFormat     := tfXBGR8ui1;
3755   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3756   fglInternalFormat := GL_RGB8;
3757   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
3758 {$ELSE}
3759   fOpenGLFormat     := tfRGB8ub3;
3760 {$ENDIF}
3761 end;
3762
3763 procedure TfdBGR10X2ui1.SetValues;
3764 begin
3765   inherited SetValues;
3766   fBitsPerPixel     := 32;
3767   fFormat           := tfBGR10X2ui1;
3768   fWithAlpha        := tfBGR10A2ui1;
3769   fWithoutAlpha     := tfBGR10X2ui1;
3770   fRGBInverted      := tfRGB10X2ui1;
3771   fPrecision        := glBitmapRec4ub(10, 10, 10,  0);
3772   fShift            := glBitmapRec4ub( 2, 12, 22,  0);
3773 {$IFNDEF OPENGL_ES}
3774   fOpenGLFormat     := tfBGR10X2ui1;
3775   fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3776   fglInternalFormat := GL_RGB10;
3777   fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
3778 {$ELSE}
3779   fOpenGLFormat     := tfRGB16us3;
3780 {$ENDIF}
3781 end;
3782
3783 procedure TfdX2BGR10ui1.SetValues;
3784 begin
3785   inherited SetValues;
3786   fBitsPerPixel     := 32;
3787   fFormat           := tfX2BGR10ui1;
3788   fWithAlpha        := tfA2BGR10ui1;
3789   fWithoutAlpha     := tfX2BGR10ui1;
3790   fRGBInverted      := tfX2RGB10ui1;
3791   fPrecision        := glBitmapRec4ub(10, 10, 10,  0);
3792   fShift            := glBitmapRec4ub( 0, 10, 20,  0);
3793 {$IFNDEF OPENGL_ES}
3794   fOpenGLFormat     := tfX2BGR10ui1;
3795   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
3796   fglInternalFormat := GL_RGB10;
3797   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
3798 {$ELSE}
3799   fOpenGLFormat     := tfRGB16us3;
3800 {$ENDIF}
3801 end;
3802
3803 procedure TfdBGR16us3.SetValues;
3804 begin
3805   inherited SetValues;
3806   fBitsPerPixel     := 48;
3807   fFormat           := tfBGR16us3;
3808   fWithAlpha        := tfBGRA16us4;
3809   fWithoutAlpha     := tfBGR16us3;
3810   fRGBInverted      := tfRGB16us3;
3811   fPrecision        := glBitmapRec4ub(16, 16, 16,  0);
3812   fShift            := glBitmapRec4ub(32, 16,  0,  0);
3813 {$IFNDEF OPENGL_ES}
3814   fOpenGLFormat     := tfBGR16us3;
3815   fglFormat         := GL_BGR;
3816   fglInternalFormat := GL_RGB16;
3817   fglDataFormat     := GL_UNSIGNED_SHORT;
3818 {$ELSE}
3819   fOpenGLFormat     := tfRGB16us3;
3820 {$ENDIF}
3821 end;
3822
3823 procedure TfdBGRA4us1.SetValues;
3824 begin
3825   inherited SetValues;
3826   fBitsPerPixel     := 16;
3827   fFormat           := tfBGRA4us1;
3828   fWithAlpha        := tfBGRA4us1;
3829   fWithoutAlpha     := tfBGRX4us1;
3830   fRGBInverted      := tfRGBA4us1;
3831   fPrecision        := glBitmapRec4ub( 4,  4,  4,  4);
3832   fShift            := glBitmapRec4ub( 4,  8, 12,  0);
3833 {$IFNDEF OPENGL_ES}
3834   fOpenGLFormat     := tfBGRA4us1;
3835   fglFormat         := GL_BGRA;
3836   fglInternalFormat := GL_RGBA4;
3837   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
3838 {$ELSE}
3839   fOpenGLFormat     := tfRGBA4us1;
3840 {$ENDIF}
3841 end;
3842
3843 procedure TfdABGR4us1.SetValues;
3844 begin
3845   inherited SetValues;
3846   fBitsPerPixel     := 16;
3847   fFormat           := tfABGR4us1;
3848   fWithAlpha        := tfABGR4us1;
3849   fWithoutAlpha     := tfXBGR4us1;
3850   fRGBInverted      := tfARGB4us1;
3851   fPrecision        := glBitmapRec4ub( 4,  4,  4,  4);
3852   fShift            := glBitmapRec4ub( 0,  4,  8, 12);
3853 {$IFNDEF OPENGL_ES}
3854   fOpenGLFormat     := tfABGR4us1;
3855   fglFormat         := GL_RGBA;
3856   fglInternalFormat := GL_RGBA4;
3857   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
3858 {$ELSE}
3859   fOpenGLFormat     := tfRGBA4us1;
3860 {$ENDIF}
3861 end;
3862
3863 procedure TfdBGR5A1us1.SetValues;
3864 begin
3865   inherited SetValues;
3866   fBitsPerPixel     := 16;
3867   fFormat           := tfBGR5A1us1;
3868   fWithAlpha        := tfBGR5A1us1;
3869   fWithoutAlpha     := tfBGR5X1us1;
3870   fRGBInverted      := tfRGB5A1us1;
3871   fPrecision        := glBitmapRec4ub( 5,  5,  5,  1);
3872   fShift            := glBitmapRec4ub( 1,  6, 11,  0);
3873 {$IFNDEF OPENGL_ES}
3874   fOpenGLFormat     := tfBGR5A1us1;
3875   fglFormat         := GL_BGRA;
3876   fglInternalFormat := GL_RGB5_A1;
3877   fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
3878 {$ELSE}
3879   fOpenGLFormat     := tfRGB5A1us1;
3880 {$ENDIF}
3881 end;
3882
3883 procedure TfdA1BGR5us1.SetValues;
3884 begin
3885   inherited SetValues;
3886   fBitsPerPixel     := 16;
3887   fFormat           := tfA1BGR5us1;
3888   fWithAlpha        := tfA1BGR5us1;
3889   fWithoutAlpha     := tfX1BGR5us1;
3890   fRGBInverted      := tfA1RGB5us1;
3891   fPrecision        := glBitmapRec4ub( 5,  5,  5,  1);
3892   fShift            := glBitmapRec4ub( 0,  5, 10, 15);
3893 {$IFNDEF OPENGL_ES}
3894   fOpenGLFormat     := tfA1BGR5us1;
3895   fglFormat         := GL_RGBA;
3896   fglInternalFormat := GL_RGB5_A1;
3897   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
3898 {$ELSE}
3899   fOpenGLFormat     := tfRGB5A1us1;
3900 {$ENDIF}
3901 end;
3902
3903 procedure TfdBGRA8ui1.SetValues;
3904 begin
3905   inherited SetValues;
3906   fBitsPerPixel     := 32;
3907   fFormat           := tfBGRA8ui1;
3908   fWithAlpha        := tfBGRA8ui1;
3909   fWithoutAlpha     := tfBGRX8ui1;
3910   fRGBInverted      := tfRGBA8ui1;
3911   fPrecision        := glBitmapRec4ub( 8,  8,  8,  8);
3912   fShift            := glBitmapRec4ub( 8, 16, 24,  0);
3913 {$IFNDEF OPENGL_ES}
3914   fOpenGLFormat     := tfBGRA8ui1;
3915   fglFormat         := GL_BGRA;
3916   fglInternalFormat := GL_RGBA8;
3917   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
3918 {$ELSE}
3919   fOpenGLFormat     := tfRGBA8ub4;
3920 {$ENDIF}
3921 end;
3922
3923 procedure TfdABGR8ui1.SetValues;
3924 begin
3925   inherited SetValues;
3926   fBitsPerPixel     := 32;
3927   fFormat           := tfABGR8ui1;
3928   fWithAlpha        := tfABGR8ui1;
3929   fWithoutAlpha     := tfXBGR8ui1;
3930   fRGBInverted      := tfARGB8ui1;
3931   fPrecision        := glBitmapRec4ub( 8,  8,  8,  8);
3932   fShift            := glBitmapRec4ub( 0,  8, 16, 24);
3933 {$IFNDEF OPENGL_ES}
3934   fOpenGLFormat     := tfABGR8ui1;
3935   fglFormat         := GL_RGBA;
3936   fglInternalFormat := GL_RGBA8;
3937   fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;