* added Swizzle Support

* updated native OpenGL Support

glBitmap.pas

@@ -375,21 +375,19 @@ unit glBitmap;
 interface
 
 uses
-  {$IFNDEF GLB_NATIVE_OGL}      dglOpenGL,          {$ENDIF}
+  {$IFNDEF GLB_NATIVE_OGL}      dglOpenGL,                {$ENDIF}
   {$IF DEFINED(GLB_WIN) AND
-       DEFINED(GLB_NATIVE_OGL)} windows,            {$IFEND}
+       DEFINED(GLB_NATIVE_OGL)} windows,                  {$IFEND}
 
-  {$IFDEF GLB_SDL}              SDL,                {$ENDIF}
-  {$IFDEF GLB_LAZARUS}          IntfGraphics, GraphType,       {$ENDIF}
-  {$IFDEF GLB_DELPHI}           Dialogs, Graphics,  {$ENDIF}
+  {$IFDEF GLB_SDL}              SDL,                      {$ENDIF}
+  {$IFDEF GLB_LAZARUS}          IntfGraphics, GraphType,  {$ENDIF}
+  {$IFDEF GLB_DELPHI}           Dialogs, Graphics,        {$ENDIF}
 
-  {$IFDEF GLB_SDL_IMAGE}        SDL_image,          {$ENDIF}
-
-  {$IFDEF GLB_PNGIMAGE}         pngimage,           {$ENDIF}
-  {$IFDEF GLB_LIB_PNG}          libPNG,             {$ENDIF}
-
-  {$IFDEF GLB_DELPHI_JPEG}      JPEG,               {$ENDIF}
-  {$IFDEF GLB_LIB_JPEG}         libJPEG,            {$ENDIF}
+  {$IFDEF GLB_SDL_IMAGE}        SDL_image,                {$ENDIF}
+  {$IFDEF GLB_PNGIMAGE}         pngimage,                 {$ENDIF}
+  {$IFDEF GLB_LIB_PNG}          libPNG,                   {$ENDIF}
+  {$IFDEF GLB_DELPHI_JPEG}      JPEG,                     {$ENDIF}
+  {$IFDEF GLB_LIB_JPEG}         libJPEG,                  {$ENDIF}
 
   Classes, SysUtils;
 
@@ -398,6 +396,9 @@ const
   GL_TRUE   = 1;
   GL_FALSE  = 0;
 
+  GL_ZERO = 0;
+  GL_ONE  = 1;
+
   GL_VERSION    = $1F02;
   GL_EXTENSIONS = $1F03;
 
@@ -405,9 +406,34 @@ const
   GL_TEXTURE_2D         = $0DE1;
   GL_TEXTURE_RECTANGLE  = $84F5;
 
+  GL_NORMAL_MAP                   = $8511;
+  GL_TEXTURE_CUBE_MAP             = $8513;
+  GL_REFLECTION_MAP               = $8512;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X  = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X  = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y  = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y  = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z  = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z  = $851A;
+
   GL_TEXTURE_WIDTH            = $1000;
   GL_TEXTURE_HEIGHT           = $1001;
   GL_TEXTURE_INTERNAL_FORMAT  = $1003;
+  GL_TEXTURE_SWIZZLE_RGBA     = $8E46;
+
+  GL_S = $2000;
+  GL_T = $2001;
+  GL_R = $2002;
+  GL_Q = $2003;
+
+  GL_TEXTURE_GEN_S = $0C60;
+  GL_TEXTURE_GEN_T = $0C61;
+  GL_TEXTURE_GEN_R = $0C62;
+  GL_TEXTURE_GEN_Q = $0C63;
+
+  GL_RED    = $1903;
+  GL_GREEN  = $1904;
+  GL_BLUE   = $1905;
 
   GL_ALPHA    = $1906;
   GL_ALPHA4   = $803B;
@@ -509,6 +535,8 @@ const
 
   GL_TEXTURE_MAX_ANISOTROPY_EXT     = $84FE;
   GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE      = $851C;
+  GL_TEXTURE_GEN_MODE               = $2500;
 
 {$IF DEFINED(GLB_WIN)}
   libglu    = 'glu32.dll';
@@ -551,12 +579,14 @@ type
   TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
 
   TglTexParameteri          = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameteriv         = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglTexParameterfv         = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglGetTexParameteriv      = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglGetTexParameterfv      = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
 
+  TglTexGeni        = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglGenTextures    = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglBindTexture    = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
   TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
@@ -580,12 +610,14 @@ type
   procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
 
   procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
 
+  procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
   procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
@@ -607,6 +639,7 @@ var
   GL_VERSION_1_3,
   GL_VERSION_1_4,
   GL_VERSION_2_0,
+  GL_VERSION_3_3,
 
   GL_SGIS_generate_mipmap,
 
@@ -614,6 +647,8 @@ var
   GL_ARB_texture_mirrored_repeat,
   GL_ARB_texture_rectangle,
   GL_ARB_texture_non_power_of_two,
+  GL_ARB_texture_swizzle,
+  GL_ARB_texture_cube_map,
 
   GL_IBM_texture_mirrored_repeat,
 
@@ -621,6 +656,8 @@ var
 
   GL_EXT_texture_edge_clamp,
   GL_EXT_texture_rectangle,
+  GL_EXT_texture_swizzle,
+  GL_EXT_texture_cube_map,
   GL_EXT_texture_filter_anisotropic: Boolean;
 
   glCompressedTexImage1D: TglCompressedTexImage1D;
@@ -642,12 +679,14 @@ var
   glGetIntegerv: TglGetIntegerv;
 
   glTexParameteri: TglTexParameteri;
+  glTexParameteriv: TglTexParameteriv;
   glTexParameterfv: TglTexParameterfv;
   glGetTexParameteriv: TglGetTexParameteriv;
   glGetTexParameterfv: TglGetTexParameterfv;
   glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
   glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
 
+  glTexGeni: TglTexGeni;
   glGenTextures: TglGenTextures;
   glBindTexture: TglBindTexture;
   glDeleteTextures: TglDeleteTextures;
@@ -749,10 +788,11 @@ type
      nm5x5);
 
  ////////////////////////////////////////////////////////////////////////////////////////////////////
-   EglBitmapException               = class(Exception);
-   EglBitmapSizeToLargeException    = class(EglBitmapException);
-   EglBitmapNonPowerOfTwoException  = class(EglBitmapException);
-   EglBitmapUnsupportedFormat       = class(EglBitmapException)
+   EglBitmap                  = class(Exception);
+   EglBitmapNotSupported      = class(Exception);
+   EglBitmapSizeToLarge       = class(EglBitmap);
+   EglBitmapNonPowerOfTwo     = class(EglBitmap);
+   EglBitmapUnsupportedFormat = class(EglBitmap)
      constructor Create(const aFormat: TglBitmapFormat); overload;
      constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
    end;
@@ -811,13 +851,16 @@ type
     fRowSize: Integer;
 
     // Filtering
-    fFilterMin: Cardinal;
-    fFilterMag: Cardinal;
+    fFilterMin: GLenum;
+    fFilterMag: GLenum;
 
     // TexturWarp
-    fWrapS: Cardinal;
-    fWrapT: Cardinal;
-    fWrapR: Cardinal;
+    fWrapS: GLenum;
+    fWrapT: GLenum;
+    fWrapR: GLenum;
+
+    //Swizzle
+    fSwizzle: array[0..3] of GLenum;
 
     // CustomData
     fFilename: String;
@@ -958,11 +1001,12 @@ type
     procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1);
 
     //TexParameters
-    procedure SetFilter(const aMin, aMag: Cardinal);
+    procedure SetFilter(const aMin, aMag: GLenum);
     procedure SetWrap(
-      const S: Cardinal = GL_CLAMP_TO_EDGE;
-      const T: Cardinal = GL_CLAMP_TO_EDGE;
-      const R: Cardinal = GL_CLAMP_TO_EDGE);
+      const S: GLenum = GL_CLAMP_TO_EDGE;
+      const T: GLenum = GL_CLAMP_TO_EDGE;
+      const R: GLenum = GL_CLAMP_TO_EDGE);
+    procedure SetSwizzle(const r, g, b, a: GLenum);
 
     procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
     procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
@@ -1084,6 +1128,7 @@ var
   glBitmapDefaultWrapS: Cardinal;
   glBitmapDefaultWrapT: Cardinal;
   glBitmapDefaultWrapR: Cardinal;
+  glDefaultSwizzle: array[0..3] of GLenum;
 
 {$IFDEF GLB_DELPHI}
 function CreateGrayPalette: HPALETTE;
@@ -1839,7 +1884,7 @@ begin
   result := dlsym(aLibHandle, aProcName);
 {$IFEND}
   if not Assigned(result) then
-    raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName);
+    raise EglBitmap.Create('unable to load procedure form library: ' + aProcName);
 end;
 
 {$IFDEF GLB_NATIVE_OGL_DYNAMIC}
@@ -1886,11 +1931,11 @@ begin
 
   GL_LibHandle := glbLoadLibrary(libopengl);
   if not Assigned(GL_LibHandle) then
-    raise EglBitmapException.Create('unable to load library: ' + libopengl);
+    raise EglBitmap.Create('unable to load library: ' + libopengl);
 
   GLU_LibHandle := glbLoadLibrary(libglu);
   if not Assigned(GLU_LibHandle) then
-    raise EglBitmapException.Create('unable to load library: ' + libglu);
+    raise EglBitmap.Create('unable to load library: ' + libglu);
 
   try
   {$IF DEFINED(GLB_WIN)}
@@ -1905,11 +1950,13 @@ begin
     glGetString := glbGetProcAddress('glGetString');
     glGetIntegerv := glbGetProcAddress('glGetIntegerv');
     glTexParameteri := glbGetProcAddress('glTexParameteri');
+    glTexParameteriv := glbGetProcAddress('glTexParameteriv');
     glTexParameterfv := glbGetProcAddress('glTexParameterfv');
     glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv');
     glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv');
     glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv');
     glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv');
+    glTexGeni := glbGetProcAddress('glTexGeni');
     glGenTextures := glbGetProcAddress('glGenTextures');
     glBindTexture := glbGetProcAddress('glBindTexture');
     glDeleteTextures := glbGetProcAddress('glDeleteTextures');
@@ -1977,6 +2024,12 @@ var
       result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
   end;
 
+  ///////////////////////////////////////////////////////////////////////////////////////////
+  function CheckVersion(const aMajor, aMinor: Integer): Boolean;
+  begin
+    result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor));
+  end;
+
 begin
 {$IFDEF GLB_NATIVE_OGL_DYNAMIC}
   InitOpenGLCS.Enter;
@@ -1994,35 +2047,25 @@ begin
   Buffer := glGetString(GL_VERSION);
   TrimVersionString(Buffer, MajorVersion, MinorVersion);
 
-  GL_VERSION_1_2 := false;
-  GL_VERSION_1_3 := false;
-  GL_VERSION_1_4 := false;
-  GL_VERSION_2_0 := false;
-  if MajorVersion = 1 then begin
-    if MinorVersion >= 2 then
-      GL_VERSION_1_2 := true;
-
-    if MinorVersion >= 3 then
-      GL_VERSION_1_3 := true;
-
-    if MinorVersion >= 4 then
-      GL_VERSION_1_4 := true;
-  end else if MajorVersion >= 2 then begin
-    GL_VERSION_1_2 := true;
-    GL_VERSION_1_3 := true;
-    GL_VERSION_1_4 := true;
-    GL_VERSION_2_0 := true;
-  end;
+  GL_VERSION_1_2 := CheckVersion(1, 2);
+  GL_VERSION_1_3 := CheckVersion(1, 3);
+  GL_VERSION_1_4 := CheckVersion(1, 4);
+  GL_VERSION_2_0 := CheckVersion(2, 0);
+  GL_VERSION_3_3 := CheckVersion(3, 3);
 
   // Extensions
   Buffer := glGetString(GL_EXTENSIONS);
   GL_ARB_texture_border_clamp       := CheckExtension('GL_ARB_texture_border_clamp');
   GL_ARB_texture_non_power_of_two   := CheckExtension('GL_ARB_texture_non_power_of_two');
+  GL_ARB_texture_swizzle            := CheckExtension('GL_ARB_texture_swizzle');
+  GL_ARB_texture_cube_map           := CheckExtension('GL_ARB_texture_cube_map');
   GL_ARB_texture_rectangle          := CheckExtension('GL_ARB_texture_rectangle');
   GL_ARB_texture_mirrored_repeat    := CheckExtension('GL_ARB_texture_mirrored_repeat');
   GL_EXT_texture_edge_clamp         := CheckExtension('GL_EXT_texture_edge_clamp');
   GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
   GL_EXT_texture_rectangle          := CheckExtension('GL_EXT_texture_rectangle');
+  GL_EXT_texture_swizzle            := CheckExtension('GL_EXT_texture_swizzle');
+  GL_EXT_texture_cube_map           := CheckExtension('GL_EXT_texture_cube_map');
   GL_NV_texture_rectangle           := CheckExtension('GL_NV_texture_rectangle');
   GL_IBM_texture_mirrored_repeat    := CheckExtension('GL_IBM_texture_mirrored_repeat');
   GL_SGIS_generate_mipmap           := CheckExtension('GL_SGIS_generate_mipmap');
@@ -2117,6 +2160,15 @@ begin
   glBitmapDefaultWrapR := R;
 end;
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
+begin
+  glDefaultSwizzle[0] := r;
+  glDefaultSwizzle[1] := g;
+  glDefaultSwizzle[2] := b;
+  glDefaultSwizzle[3] := a;
+end;
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
 begin
@@ -2142,20 +2194,29 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
+procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum);
 begin
   aMin := glBitmapDefaultFilterMin;
   aMag := glBitmapDefaultFilterMag;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum);
 begin
   S := glBitmapDefaultWrapS;
   T := glBitmapDefaultWrapT;
   R := glBitmapDefaultWrapR;
 end;
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
+begin
+  r := glDefaultSwizzle[0];
+  g := glDefaultSwizzle[1];
+  b := glDefaultSwizzle[2];
+  a := glDefaultSwizzle[3];
+end;
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2244,7 +2305,7 @@ function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlp
 begin
   result := false;
   if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then
-    raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0');
+    raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
   if (aRedMask   <> RedMask) then
     exit;
   if (aGreenMask <> GreenMask) then
@@ -3445,12 +3506,12 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 constructor TfdS3tcDtx1RGBA.Create;
@@ -3471,12 +3532,12 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 constructor TfdS3tcDtx3RGBA.Create;
@@ -3497,12 +3558,12 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
-  raise EglBitmapException.Create('mapping for compressed formats is not supported');
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
 end;
 
 constructor TfdS3tcDtx5RGBA.Create;
@@ -3635,7 +3696,7 @@ begin
     4: PCardinal(aData)^ := data;
     8:    PQWord(aData)^ := data;
   else
-    raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
+    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
   end;
   inc(aData, s);
 end;
@@ -3653,7 +3714,7 @@ begin
     4: data := PCardinal(aData)^;
     8: data :=    PQWord(aData)^;
   else
-    raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
+    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
   end;
   for i := 0 to 3 do
     aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i];
@@ -3668,7 +3729,7 @@ var
   i: Integer;
 begin
   if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
-    raise EglBitmapException.Create(UNSUPPORTED_FORMAT);
+    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
 
   if (Format = tfLuminance4) then
     SetLength(fColorTable, 16)
@@ -3711,7 +3772,7 @@ var
   d: Byte;
 begin
   if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
-    raise EglBitmapException.Create(UNSUPPORTED_FORMAT);
+    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
 
   case Format of
     tfLuminance4: begin
@@ -3759,10 +3820,10 @@ begin
     4: idx := PCardinal(aData)^;
     8: idx :=    PQWord(aData)^;
   else
-    raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
+    raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
   end;
   if (idx >= Length(fColorTable)) then
-    raise EglBitmapException.CreateFmt('invalid color index: %d', [idx]);
+    raise EglBitmap.CreateFmt('invalid color index: %d', [idx]);
   with fColorTable[idx] do begin
     aPixel.Data.r := r;
     aPixel.Data.g := g;
@@ -4087,6 +4148,9 @@ begin
   SetAnisotropic(fAnisotropic);
   SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
 
+  if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+    SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
+
   // Mip Maps Generation Mode
   aBuildWithGlu := false;
   if (MipMap = mmMipmap) then begin
@@ -4163,6 +4227,7 @@ begin
 
   glBitmapGetDefaultFilter     (fFilterMin, fFilterMag);
   glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
+  glBitmapGetDefaultSwizzle    (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4195,7 +4260,7 @@ var
   fs: TFileStream;
 begin
   if not FileExists(aFilename) then
-    raise EglBitmapException.Create('file does not exist: ' + aFilename);
+    raise EglBitmap.Create('file does not exist: ' + aFilename);
   fFilename := aFilename;
   fs := TFileStream.Create(fFilename, fmOpenRead);
   try
@@ -4218,7 +4283,7 @@ begin
   if not LoadDDS(aStream) then
   if not LoadTGA(aStream) then
   if not LoadBMP(aStream) then
-    raise EglBitmapException.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
+    raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -5293,7 +5358,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal);
+procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
 begin
   //check MIN filter
   case aMin of
@@ -5310,7 +5375,7 @@ begin
     GL_LINEAR_MIPMAP_LINEAR:
       fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
     else
-      raise EglBitmapException.Create('SetFilter - Unknow MIN filter.');
+      raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
   end;
 
   //check MAG filter
@@ -5320,7 +5385,7 @@ begin
     GL_LINEAR:
       fFilterMag := GL_LINEAR;
     else
-      raise EglBitmapException.Create('SetFilter - Unknow MAG filter.');
+      raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
   end;
 
   //apply filter
@@ -5343,7 +5408,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardinal);
+procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);
 
   procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
   begin
@@ -5372,10 +5437,10 @@ procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardi
         if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
           aTarget := GL_MIRRORED_REPEAT
         else
-          raise EglBitmapException.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
+          raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
       end;
     else
-      raise EglBitmapException.Create('SetWrap - Unknow Texturewrap (S).');
+      raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
     end;
   end;
 
@@ -5392,6 +5457,32 @@ begin
   end;
 end;
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
+
+  procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
+  begin
+    if (aValue = GL_ZERO) or (aValue =   GL_ONE) or (aValue = GL_ALPHA) or
+       (aValue =  GL_RED) or (aValue = GL_GREEN) or (aValue =  GL_BLUE) then
+      fSwizzle[aIndex] := aValue
+    else
+      raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
+  end;
+
+begin
+  if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+    raise EglBitmapNotSupported.Create('texture swizzle is not supported');
+  CheckAndSetValue(r, 0);
+  CheckAndSetValue(g, 1);
+  CheckAndSetValue(b, 2);
+  CheckAndSetValue(a, 3);
+
+  if (ID > 0) then begin
+    Bind(false);
+    glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, @fSwizzle[0]);
+  end;
+end;
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean);
 begin
@@ -5413,7 +5504,7 @@ end;
 constructor TglBitmap.Create;
 begin
   if (ClassType = TglBitmap) then
-    raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
+    raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
 {$IFDEF GLB_NATIVE_OGL}
   glbReadOpenGLExtensions;
 {$ENDIF}
@@ -6373,7 +6464,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
     case aInfo.biCompression of
       BMP_COMP_RLE4,
       BMP_COMP_RLE8: begin
-        raise EglBitmapException.Create('RLE compression is not supported');
+        raise EglBitmap.Create('RLE compression is not supported');
       end;
       BMP_COMP_BITFIELDS: begin
         if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
@@ -6382,7 +6473,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
           aStream.Read(aMask.b, SizeOf(aMask.b));
           aStream.Read(aMask.a, SizeOf(aMask.a));
         end else
-          raise EglBitmapException.Create('Bitfields are only supported for 16bit and 32bit formats');
+          raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
       end;
     end;
 
@@ -6551,7 +6642,7 @@ begin
           raise;
         end;
       end else
-        raise EglBitmapException.Create('LoadBMP - No suitable format found');
+        raise EglBitmap.Create('LoadBMP - No suitable format found');
     except
       aStream.Position := StartPos;
       raise;
@@ -6989,7 +7080,7 @@ begin
       end;
 
       if (tgaFormat = tfEmpty) then
-        raise EglBitmapException.Create('LoadTga - unsupported format');
+        raise EglBitmap.Create('LoadTga - unsupported format');
 
       FormatDesc := TFormatDescriptor.Get(tgaFormat);
       PixelSize  := FormatDesc.GetSize(1, 1);
@@ -7099,11 +7190,11 @@ begin
   Size       := FormatDesc.GetSize(Dimension);
   if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin
     if (FormatDesc.RGBInverted = tfEmpty) then
-      raise EglBitmapException.Create('inverted RGB format is empty');
+      raise EglBitmap.Create('inverted RGB format is empty');
     Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted);
     if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or
        (Converter.PixelSize <> FormatDesc.PixelSize) then
-      raise EglBitmapException.Create('invalid inverted RGB format');
+      raise EglBitmap.Create('invalid inverted RGB format');
   end;
 
   if Assigned(Converter) then begin
@@ -7295,12 +7386,12 @@ begin
   end;
 
   if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
-    raise EglBitmapException.Create('LoadDDS - CubeMaps are not supported');
+    raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');
 
   ddsFormat := GetDDSFormat;
   try
     if (ddsFormat = tfEmpty) then
-      raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
+      raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
 
     FormatDesc := TFormatDescriptor.Get(ddsFormat);
     LineSize   := Trunc(Header.dwWidth * FormatDesc.PixelSize);
@@ -7350,7 +7441,7 @@ begin
           Inc(TmpData, LineSize);
         end;
       end else
-        raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
+        raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
 
       SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method
       result := true;
@@ -7505,12 +7596,12 @@ begin
       glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
 
       if (Width > TexSize) then
-        raise EglBitmapSizeToLargeException.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+        raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
 
       TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
-                (Target = GL_TEXTURE_RECTANGLE_ARB);
+                (Target = GL_TEXTURE_RECTANGLE);
       if not (IsPowerOfTwo(Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
-        raise EglBitmapNonPowerOfTwoException.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+        raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
     end;
 
     CreateId;
@@ -7673,12 +7764,12 @@ begin
       glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
 
       if ((Height > TexSize) or (Width > TexSize)) then
-        raise EglBitmapSizeToLargeException.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+        raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
 
       PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
       TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
       if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
-        raise EglBitmapNonPowerOfTwoException.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+        raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
     end;
 
     CreateId;
@@ -7986,7 +8077,7 @@ begin
   inherited;
 
   if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
-    raise EglBitmapException.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
+    raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
 
   SetWrap;
   Target   := GL_TEXTURE_CUBE_MAP;
@@ -8003,10 +8094,10 @@ begin
     glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
 
     if (Height > TexSize) or (Width > TexSize) then
-      raise EglBitmapSizeToLargeException.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
+      raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
 
     if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
-      raise EglBitmapNonPowerOfTwoException.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
+      raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
   end;
 
   if (ID = 0) then
@@ -8185,10 +8276,11 @@ end;
 
 
 initialization
-  glBitmapSetDefaultFormat(tfEmpty);
-  glBitmapSetDefaultMipmap(mmMipmap);
-  glBitmapSetDefaultFilter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
-  glBitmapSetDefaultWrap  (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+  glBitmapSetDefaultFormat (tfEmpty);
+  glBitmapSetDefaultMipmap (mmMipmap);
+  glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
+  glBitmapSetDefaultWrap   (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+  glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);
 
   glBitmapSetDefaultFreeDataAfterGenTexture(true);
   glBitmapSetDefaultDeleteTextureOnFree    (true);