X-Git-Url: https://git.delphigl.com/?p=glBitmap.git;a=blobdiff_plain;f=glBitmap.pas;h=4ee797b9448ac38bcb674f7cbedbbe61a6c62573;hp=513a9e6a4e6de6b804454f4783057f8b0610e5ef;hb=6c6cf89280ab9c80fc6856c612aaabf137d69d04;hpb=5bce73c91972f2b2974b3cef61b5354f517d6b97 diff --git a/glBitmap.pas b/glBitmap.pas index 513a9e6..4ee797b 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -2,7 +2,7 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) http://www.opengl24.de/index.php?cat=header&file=glbitmap -modified by Delphi OpenGL Community (http://delphigl.com/) +modified by Delphi OpenGL Community (http://delphigl.com/) (2013) ------------------------------------------------------------ The contents of this file are used with permission, subject to @@ -11,9 +11,11 @@ not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/MPL-1.1.html ------------------------------------------------------------ -Version 2.0.3 +Version 3.0.1 ------------------------------------------------------------ History +20-11-2013 +- refactoring of the complete library 21-03-2010 - The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi then it's your problem if that isn't true. This prevents the unit for incompatibility @@ -22,7 +24,7 @@ History - GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson) 10-08-2008 - AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson) -- Additional Datapointer for functioninterface now has the name CustomData +- Additional Datapointer for functioninterface now has the name CustomData 24-07-2008 - AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson) - If you load an texture from an file the property Filename will be set to the name of the file @@ -51,7 +53,7 @@ History - Property DataPtr now has the name Data - Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR - Unused Depth removed -- Function FreeData to freeing image data added +- Function FreeData to freeing image data added 24-10-2007 - ImageID flag of TGAs was ignored. (Thanks Zwoetzen) 15-11-2006 @@ -219,7 +221,7 @@ unit glBitmap; // Please uncomment the defines below to configure the glBitmap to your preferences. // If you have configured the unit you can uncomment the warning above. -{$MESSAGE warn 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} +{$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -236,11 +238,11 @@ unit glBitmap; // activate to enable the support for SDL_surfaces {.$DEFINE GLB_SDL} -// activate to enable the support for TBitmap from Delphi (not lazarus) +// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap) {.$DEFINE GLB_DELPHI} // activate to enable the support for TLazIntfImage from Lazarus -{$DEFINE GLB_LAZARUS} +{.$DEFINE GLB_LAZARUS} @@ -250,6 +252,10 @@ unit glBitmap; +// activate to enable Lazarus TPortableNetworkGraphic support +// if you enable this pngImage and libPNG will be ignored +{.$DEFINE GLB_LAZ_PNG} + // activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/ // if you enable pngimage the libPNG will be ignored {.$DEFINE GLB_PNGIMAGE} @@ -260,6 +266,10 @@ unit glBitmap; +// activate to enable Lazarus TJPEGImage support +// if you enable this delphi jpegs and libJPEG will be ignored +{.$DEFINE GLB_LAZ_JPEG} + // if you enable delphi jpegs the libJPEG will be ignored {.$DEFINE GLB_DELPHI_JPEG} @@ -304,18 +314,32 @@ unit glBitmap; {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'} {$DEFINE GLB_SDL} {$ENDIF} + + {$IFDEF GLB_LAZ_PNG} + {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'} + {$undef GLB_LAZ_PNG} + {$ENDIF} + {$IFDEF GLB_PNGIMAGE} {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'} {$undef GLB_PNGIMAGE} {$ENDIF} + + {$IFDEF GLB_LAZ_JPEG} + {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'} + {$undef GLB_LAZ_JPEG} + {$ENDIF} + {$IFDEF GLB_DELPHI_JPEG} {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'} {$undef GLB_DELPHI_JPEG} {$ENDIF} + {$IFDEF GLB_LIB_PNG} {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'} {$undef GLB_LIB_PNG} {$ENDIF} + {$IFDEF GLB_LIB_JPEG} {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'} {$undef GLB_LIB_JPEG} @@ -325,6 +349,27 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_JPEG_READ} {$ENDIF} +// Lazarus TPortableNetworkGraphic +{$IFDEF GLB_LAZ_PNG} + {$IFNDEF GLB_LAZARUS} + {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'} + {$DEFINE GLB_LAZARUS} + {$ENDIF} + + {$IFDEF GLB_PNGIMAGE} + {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'} + {$undef GLB_PNGIMAGE} + {$ENDIF} + + {$IFDEF GLB_LIB_PNG} + {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'} + {$undef GLB_LIB_PNG} + {$ENDIF} + + {$DEFINE GLB_SUPPORT_PNG_READ} + {$DEFINE GLB_SUPPORT_PNG_WRITE} +{$ENDIF} + // PNG Image {$IFDEF GLB_PNGIMAGE} {$IFDEF GLB_LIB_PNG} @@ -342,6 +387,27 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_PNG_WRITE} {$ENDIF} +// Lazarus TJPEGImage +{$IFDEF GLB_LAZ_JPEG} + {$IFNDEF GLB_LAZARUS} + {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'} + {$DEFINE GLB_LAZARUS} + {$ENDIF} + + {$IFDEF GLB_DELPHI_JPEG} + {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'} + {$undef GLB_DELPHI_JPEG} + {$ENDIF} + + {$IFDEF GLB_LIB_JPEG} + {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'} + {$undef GLB_LIB_JPEG} + {$ENDIF} + + {$DEFINE GLB_SUPPORT_JPEG_READ} + {$DEFINE GLB_SUPPORT_JPEG_WRITE} +{$ENDIF} + // JPEG Image {$IFDEF GLB_DELPHI_JPEG} {$IFDEF GLB_LIB_JPEG} @@ -375,21 +441,20 @@ 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} - - {$IFDEF GLB_SDL} SDL, {$ENDIF} - {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, {$ENDIF} - {$IFDEF GLB_DELPHI} Dialogs, Graphics, {$ENDIF} - - {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + (DEFINED(GLB_NATIVE_OGL) OR + DEFINED(GLB_DELPHI))} windows, {$IFEND} - {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF} - {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF} + {$IFDEF GLB_SDL} SDL, {$ENDIF} + {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, Graphics, {$ENDIF} + {$IFDEF GLB_DELPHI} Dialogs, Graphics, Types, {$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 +463,9 @@ const GL_TRUE = 1; GL_FALSE = 0; + GL_ZERO = 0; + GL_ONE = 1; + GL_VERSION = $1F02; GL_EXTENSIONS = $1F03; @@ -405,9 +473,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 +602,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 +646,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 +677,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 +706,7 @@ var GL_VERSION_1_3, GL_VERSION_1_4, GL_VERSION_2_0, + GL_VERSION_3_3, GL_SGIS_generate_mipmap, @@ -614,6 +714,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 +723,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 +746,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; @@ -672,52 +778,61 @@ type tfAlpha4, tfAlpha8, - tfAlpha12, tfAlpha16, tfLuminance4, tfLuminance8, - tfLuminance12, tfLuminance16, tfLuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, - tfLuminance12Alpha12, tfLuminance16Alpha16, tfR3G3B2, - tfRGB4, + tfRGBX4, + tfXRGB4, tfR5G6B5, - tfRGB5, + tfRGB5X1, + tfX1RGB5, tfRGB8, - tfRGB10, - tfRGB12, + tfRGBX8, + tfXRGB8, + tfRGB10X2, + tfX2RGB10, tfRGB16, - tfRGBA2, tfRGBA4, + tfARGB4, tfRGB5A1, + tfA1RGB5, tfRGBA8, + tfARGB8, tfRGB10A2, - tfRGBA12, + tfA2RGB10, tfRGBA16, - tfBGR4, + tfBGRX4, + tfXBGR4, tfB5G6R5, - tfBGR5, + tfBGR5X1, + tfX1BGR5, tfBGR8, - tfBGR10, - tfBGR12, + tfBGRX8, + tfXBGR8, + tfBGR10X2, + tfX2BGR10, tfBGR16, - tfBGRA2, tfBGRA4, + tfABGR4, tfBGR5A1, + tfA1BGR5, tfBGRA8, + tfABGR8, tfBGR10A2, - tfBGRA12, + tfA2BGR10, tfBGRA16, tfDepth16, @@ -749,10 +864,12 @@ 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) + public constructor Create(const aFormat: TglBitmapFormat); overload; constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload; end; @@ -778,6 +895,43 @@ type Y : Word; end; + TglBitmapFormatDescriptor = class(TObject) + protected + function GetIsCompressed: Boolean; virtual; abstract; + function GetHasRed: Boolean; virtual; abstract; + function GetHasGreen: Boolean; virtual; abstract; + function GetHasBlue: Boolean; virtual; abstract; + function GetHasAlpha: Boolean; virtual; abstract; + + function GetRGBInverted: TglBitmapFormat; virtual; abstract; + function GetWithAlpha: TglBitmapFormat; virtual; abstract; + function GetWithoutAlpha: TglBitmapFormat; virtual; abstract; + function GetOpenGLFormat: TglBitmapFormat; virtual; abstract; + function GetUncompressed: TglBitmapFormat; virtual; abstract; + + function GetglDataFormat: GLenum; virtual; abstract; + function GetglFormat: GLenum; virtual; abstract; + function GetglInternalFormat: GLenum; virtual; abstract; + public + property IsCompressed: Boolean read GetIsCompressed; + property HasRed: Boolean read GetHasRed; + property HasGreen: Boolean read GetHasGreen; + property HasBlue: Boolean read GetHasBlue; + property HasAlpha: Boolean read GetHasAlpha; + + property RGBInverted: TglBitmapFormat read GetRGBInverted; + property WithAlpha: TglBitmapFormat read GetWithAlpha; + property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha; + property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat; + property Uncompressed: TglBitmapFormat read GetUncompressed; + + property glFormat: GLenum read GetglFormat; + property glInternalFormat: GLenum read GetglInternalFormat; + property glDataFormat: GLenum read GetglDataFormat; + public + class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; + end; + //////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class; TglBitmapFunctionRec = record @@ -792,14 +946,17 @@ type ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class + private + function GetFormatDesc: TglBitmapFormatDescriptor; protected fID: GLuint; fTarget: GLuint; fAnisotropic: Integer; fDeleteTextureOnFree: Boolean; + fFreeDataOnDestroy: Boolean; fFreeDataAfterGenTexture: Boolean; fData: PByte; - fIsResident: Boolean; + fIsResident: GLboolean; fBorderColor: array[0..3] of Single; fDimension: TglBitmapPixelPosition; @@ -811,13 +968,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; @@ -836,6 +996,7 @@ type procedure SetCustomData(const aValue: Pointer); procedure SetCustomName(const aValue: String); procedure SetCustomNameW(const aValue: WideString); + procedure SetFreeDataOnDestroy(const aValue: Boolean); procedure SetDeleteTextureOnFree(const aValue: Boolean); procedure SetFormat(const aValue: TglBitmapFormat); procedure SetFreeDataAfterGenTexture(const aValue: Boolean); @@ -866,17 +1027,20 @@ type property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; property Anisotropic: Integer read fAnisotropic write SetAnisotropic; + property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; + property Filename: String read fFilename; property CustomName: String read fCustomName write SetCustomName; property CustomNameW: WideString read fCustomNameW write SetCustomNameW; property CustomData: Pointer read fCustomData write SetCustomData; property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; + property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; property Dimension: TglBitmapPixelPosition read fDimension; property Data: PByte read fData; - property IsResident: Boolean read fIsResident; + property IsResident: GLboolean read fIsResident; procedure AfterConstruction; override; procedure BeforeDestruction; override; @@ -958,11 +1122,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; @@ -971,7 +1136,7 @@ type constructor Create; overload; constructor Create(const aFileName: String); overload; constructor Create(const aStream: TStream); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat); overload; + constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload; constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload; @@ -1084,6 +1249,7 @@ var glBitmapDefaultWrapS: Cardinal; glBitmapDefaultWrapT: Cardinal; glBitmapDefaultWrapR: Cardinal; + glDefaultSwizzle: array[0..3] of GLenum; {$IFDEF GLB_DELPHI} function CreateGrayPalette: HPALETTE; @@ -1092,7 +1258,8 @@ function CreateGrayPalette: HPALETTE; implementation uses - Math, syncobjs, typinfo; + Math, syncobjs, typinfo + {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; type {$IFNDEF fpc} @@ -1110,7 +1277,7 @@ type 1: (arr: array[0..3] of Byte); end; - TFormatDescriptor = class(TObject) + TFormatDescriptor = class(TglBitmapFormatDescriptor) private function GetRedMask: QWord; function GetGreenMask: QWord; @@ -1120,31 +1287,41 @@ type fFormat: TglBitmapFormat; fWithAlpha: TglBitmapFormat; fWithoutAlpha: TglBitmapFormat; + fOpenGLFormat: TglBitmapFormat; fRGBInverted: TglBitmapFormat; fUncompressed: TglBitmapFormat; + fPixelSize: Single; fIsCompressed: Boolean; fRange: TglBitmapColorRec; fShift: TShiftRec; - fglFormat: Cardinal; - fglInternalFormat: Cardinal; - fglDataFormat: Cardinal; + fglFormat: GLenum; + fglInternalFormat: GLenum; + fglDataFormat: GLenum; + + function GetIsCompressed: Boolean; override; + function GetHasRed: Boolean; override; + function GetHasGreen: Boolean; override; + function GetHasBlue: Boolean; override; + function GetHasAlpha: Boolean; override; + + function GetRGBInverted: TglBitmapFormat; override; + function GetWithAlpha: TglBitmapFormat; override; + function GetWithoutAlpha: TglBitmapFormat; override; + function GetOpenGLFormat: TglBitmapFormat; override; + function GetUncompressed: TglBitmapFormat; override; + + function GetglFormat: GLenum; override; + function GetglInternalFormat: GLenum; override; + function GetglDataFormat: GLenum; override; function GetComponents: Integer; virtual; public property Format: TglBitmapFormat read fFormat; - property WithAlpha: TglBitmapFormat read fWithAlpha; - property WithoutAlpha: TglBitmapFormat read fWithoutAlpha; - property RGBInverted: TglBitmapFormat read fRGBInverted; property Components: Integer read GetComponents; property PixelSize: Single read fPixelSize; - property IsCompressed: Boolean read fIsCompressed; - - property glFormat: Cardinal read fglFormat; - property glInternalFormat: Cardinal read fglInternalFormat; - property glDataFormat: Cardinal read fglDataFormat; property Range: TglBitmapColorRec read fRange; property Shift: TShiftRec read fShift; @@ -1158,13 +1335,12 @@ type procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual; - function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; + function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; function CreateMappingData: Pointer; virtual; procedure FreeMappingData(var aMappingData: Pointer); virtual; function IsEmpty: Boolean; virtual; - function HasAlpha: Boolean; virtual; function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual; procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual; @@ -1173,7 +1349,7 @@ type public class procedure Init; class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor; - class function GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; + class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; class procedure Clear; class procedure Finalize; end; @@ -1185,117 +1361,98 @@ type TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //2* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdBGR_UB3 = class(TFormatDescriptor) //3* unsigned byte (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; - end; - - TfdRGBA_UB4 = class(TfdRGB_UB3) //4* unsigned byte - procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; - end; - - TfdBGRA_UB4 = class(TfdBGR_UB3) //4* unsigned byte (inverse) - procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //2* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdBGR_US3 = class(TFormatDescriptor) //3* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdRGBA_US4 = class(TfdRGB_US3) //4* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + end; + + TfdARGB_US4 = class(TfdRGB_US3) //4* unsigned short + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; end; TfdBGRA_US4 = class(TfdBGR_US3) //4* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + end; + + TfdABGR_US4 = class(TfdBGR_US3) //4* unsigned short (inverse) + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1307,10 +1464,6 @@ type constructor Create; override; end; - TfdAlpha12 = class(TfdAlpha_US1) - constructor Create; override; - end; - TfdAlpha16 = class(TfdAlpha_US1) constructor Create; override; end; @@ -1323,10 +1476,6 @@ type constructor Create; override; end; - TfdLuminance12 = class(TfdLuminance_US1) - constructor Create; override; - end; - TfdLuminance16 = class(TfdLuminance_US1) constructor Create; override; end; @@ -1347,19 +1496,20 @@ type constructor Create; override; end; - TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2) + TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) constructor Create; override; end; - TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdR3G3B2 = class(TfdUniversal_UB1) constructor Create; override; end; - TfdR3G3B2 = class(TfdUniversal_UB1) + TfdRGBX4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGB4 = class(TfdUniversal_US1) + TfdXRGB4 = class(TfdUniversal_US1) constructor Create; override; end; @@ -1367,7 +1517,11 @@ type constructor Create; override; end; - TfdRGB5 = class(TfdUniversal_US1) + TfdRGB5X1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdX1RGB5 = class(TfdUniversal_US1) constructor Create; override; end; @@ -1375,19 +1529,23 @@ type constructor Create; override; end; - TfdRGB10 = class(TfdUniversal_UI1) + TfdRGBX8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGB12 = class(TfdRGB_US3) + TfdXRGB8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGB16 = class(TfdRGB_US3) + TfdRGB10X2 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGBA2 = class(TfdRGBA_UB4) + TfdX2RGB10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGB16 = class(TfdRGB_US3) constructor Create; override; end; @@ -1395,11 +1553,23 @@ type constructor Create; override; end; + TfdARGB4 = class(TfdUniversal_US1) + constructor Create; override; + end; + TfdRGB5A1 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGBA8 = class(TfdRGBA_UB4) + TfdA1RGB5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdRGBA8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdARGB8 = class(TfdUniversal_UI1) constructor Create; override; end; @@ -1407,15 +1577,20 @@ type constructor Create; override; end; - TfdRGBA12 = class(TfdRGBA_US4) + TfdA2RGB10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGBA16 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGBA16 = class(TfdRGBA_US4) +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdBGRX4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGR4 = class(TfdUniversal_US1) + TfdXBGR4 = class(TfdUniversal_US1) constructor Create; override; end; @@ -1423,7 +1598,11 @@ type constructor Create; override; end; - TfdBGR5 = class(TfdUniversal_US1) + TfdBGR5X1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdX1BGR5 = class(TfdUniversal_US1) constructor Create; override; end; @@ -1431,19 +1610,23 @@ type constructor Create; override; end; - TfdBGR10 = class(TfdUniversal_UI1) + TfdBGRX8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR12 = class(TfdBGR_US3) + TfdXBGR8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR16 = class(TfdBGR_US3) + TfdBGR10X2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdX2BGR10 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGRA2 = class(TfdBGRA_UB4) + TfdBGR16 = class(TfdBGR_US3) constructor Create; override; end; @@ -1451,11 +1634,23 @@ type constructor Create; override; end; + TfdABGR4 = class(TfdUniversal_US1) + constructor Create; override; + end; + TfdBGR5A1 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGRA8 = class(TfdBGRA_UB4) + TfdA1BGR5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGRA8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdABGR8 = class(TfdUniversal_UI1) constructor Create; override; end; @@ -1463,7 +1658,7 @@ type constructor Create; override; end; - TfdBGRA12 = class(TfdBGRA_US4) + TfdA2BGR10 = class(TfdUniversal_UI1) constructor Create; override; end; @@ -1564,52 +1759,61 @@ const TfdAlpha4, TfdAlpha8, - TfdAlpha12, TfdAlpha16, TfdLuminance4, TfdLuminance8, - TfdLuminance12, TfdLuminance16, TfdLuminance4Alpha4, TfdLuminance6Alpha2, TfdLuminance8Alpha8, TfdLuminance12Alpha4, - TfdLuminance12Alpha12, TfdLuminance16Alpha16, TfdR3G3B2, - TfdRGB4, + TfdRGBX4, + TfdXRGB4, TfdR5G6B5, - TfdRGB5, + TfdRGB5X1, + TfdX1RGB5, TfdRGB8, - TfdRGB10, - TfdRGB12, + TfdRGBX8, + TfdXRGB8, + TfdRGB10X2, + TfdX2RGB10, TfdRGB16, - TfdRGBA2, TfdRGBA4, + TfdARGB4, TfdRGB5A1, + TfdA1RGB5, TfdRGBA8, + TfdARGB8, TfdRGB10A2, - TfdRGBA12, + TfdA2RGB10, TfdRGBA16, - TfdBGR4, + TfdBGRX4, + TfdXBGR4, TfdB5G6R5, - TfdBGR5, + TfdBGR5X1, + TfdX1BGR5, TfdBGR8, - TfdBGR10, - TfdBGR12, + TfdBGRX8, + TfdXBGR8, + TfdBGR10X2, + TfdX2BGR10, TfdBGR16, - TfdBGRA2, TfdBGRA4, + TfdABGR4, TfdBGR5A1, + TfdA1BGR5, TfdBGRA8, + TfdABGR8, TfdBGR10A2, - TfdBGRA12, + TfdA2BGR10, TfdBGRA16, TfdDepth16, @@ -1694,15 +1898,15 @@ begin tfR3G3B2, tfLuminance8, //16bpp - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4, + tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, //24bpp tfBGR8, tfRGB8, //32bpp - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8]) then + tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, + tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then result := result + [ftBMP]; if (aFormat in [ @@ -1711,8 +1915,8 @@ begin //16 bpp tfLuminance16, tfLuminance8Alpha8, - tfRGB5, tfRGB5A1, tfRGBA4, - tfBGR5, tfBGR5A1, tfBGRA4, + tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, //24 bpp tfRGB8, tfBGR8, @@ -1724,12 +1928,12 @@ begin if (aFormat in [ //8 bpp tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, - tfR3G3B2, tfRGBA2, tfBGRA2, + tfR3G3B2, //16 bpp tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, - tfRGB4, tfR5G6B5, tfRGB5, tfRGBA4, tfRGB5A1, - tfBGR4, tfB5G6R5, tfBGR5, tfBGRA4, tfBGR5A1, + tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5, + tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5, //24 bpp tfRGB8, tfBGR8, @@ -1811,7 +2015,7 @@ end; var GL_LibHandle: Pointer = nil; -function glbGetProcAddress(aProcName: PChar; aLibHandle: Pointer = nil): Pointer; +function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer; begin if not Assigned(aLibHandle) then aLibHandle := GL_LibHandle; @@ -1838,8 +2042,8 @@ begin result := dlsym(aLibHandle, aProcName); {$IFEND} - if not Assigned(result) then - raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName); + if not Assigned(result) and aRaiseOnErr then + raise EglBitmap.Create('unable to load procedure form library: ' + aProcName); end; {$IFDEF GLB_NATIVE_OGL_DYNAMIC} @@ -1886,46 +2090,43 @@ 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)} - wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); - {$ELSEIF DEFINED(GLB_LINUX)} - glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); - glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); - {$IFEND} - - glEnable := glbGetProcAddress('glEnable'); - glDisable := glbGetProcAddress('glDisable'); - glGetString := glbGetProcAddress('glGetString'); - glGetIntegerv := glbGetProcAddress('glGetIntegerv'); - glTexParameteri := glbGetProcAddress('glTexParameteri'); - glTexParameterfv := glbGetProcAddress('glTexParameterfv'); - glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv'); - glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv'); - glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv'); - glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv'); - glGenTextures := glbGetProcAddress('glGenTextures'); - glBindTexture := glbGetProcAddress('glBindTexture'); - glDeleteTextures := glbGetProcAddress('glDeleteTextures'); - glAreTexturesResident := glbGetProcAddress('glAreTexturesResident'); - glReadPixels := glbGetProcAddress('glReadPixels'); - glPixelStorei := glbGetProcAddress('glPixelStorei'); - glTexImage1D := glbGetProcAddress('glTexImage1D'); - glTexImage2D := glbGetProcAddress('glTexImage2D'); - glGetTexImage := glbGetProcAddress('glGetTexImage'); - - gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle); - gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle); - finally - glbFreeLibrary(GL_LibHandle); - glbFreeLibrary(GLU_LibHandle); - end; +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); + glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); +{$IFEND} + + glEnable := glbGetProcAddress('glEnable'); + glDisable := glbGetProcAddress('glDisable'); + 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'); + glAreTexturesResident := glbGetProcAddress('glAreTexturesResident'); + glReadPixels := glbGetProcAddress('glReadPixels'); + glPixelStorei := glbGetProcAddress('glPixelStorei'); + glTexImage1D := glbGetProcAddress('glTexImage1D'); + glTexImage2D := glbGetProcAddress('glTexImage2D'); + glGetTexImage := glbGetProcAddress('glGetTexImage'); + + gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle); + gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle); end; {$ENDIF} @@ -1977,6 +2178,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 +2201,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'); @@ -2032,9 +2229,9 @@ begin glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D'); glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage'); end else begin - glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB'); - glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB'); - glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB'); + glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB', nil, false); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB', nil, false); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false); end; end; {$ENDIF} @@ -2118,6 +2315,15 @@ begin 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 result := glBitmapDefaultDeleteTextureOnFree; @@ -2142,14 +2348,14 @@ 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; @@ -2157,7 +2363,16 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); +begin + r := glDefaultSwizzle[0]; + g := glDefaultSwizzle[1]; + b := glDefaultSwizzle[2]; + a := glDefaultSwizzle[3]; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.GetRedMask: QWord; begin @@ -2183,6 +2398,84 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetIsCompressed: Boolean; +begin + result := fIsCompressed; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasRed: Boolean; +begin + result := (fRange.r > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasGreen: Boolean; +begin + result := (fRange.g > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasBlue: Boolean; +begin + result := (fRange.b > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasAlpha: Boolean; +begin + result := (fRange.a > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetRGBInverted: TglBitmapFormat; +begin + result := fRGBInverted; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetWithAlpha: TglBitmapFormat; +begin + result := fWithAlpha; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat; +begin + result := fWithoutAlpha; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat; +begin + result := fOpenGLFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetUncompressed: TglBitmapFormat; +begin + result := fUncompressed; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglFormat: GLenum; +begin + result := fglFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglInternalFormat: GLenum; +begin + result := fglInternalFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglDataFormat: GLenum; +begin + result := fglDataFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.GetComponents: Integer; var i: Integer; @@ -2234,17 +2527,11 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.HasAlpha: Boolean; -begin - result := (fRange.a > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; 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 @@ -2273,8 +2560,10 @@ begin fFormat := tfEmpty; fWithAlpha := tfEmpty; fWithoutAlpha := tfEmpty; + fOpenGLFormat := tfEmpty; fRGBInverted := tfEmpty; fUncompressed := tfEmpty; + fPixelSize := 0.0; fIsCompressed := false; @@ -2304,15 +2593,6 @@ begin inc(aData); end; -constructor TfdAlpha_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; - fRange.a := $FF; - fglFormat := GL_ALPHA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminance_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2331,17 +2611,6 @@ begin inc(aData); end; -constructor TfdLuminance_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fglFormat := GL_LUMINANCE; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2365,12 +2634,6 @@ begin inc(aData); end; -constructor TfdUniversal_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2388,145 +2651,54 @@ begin inc(aData); end; -constructor TfdLuminanceAlpha_UB2.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdRGB_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 2.0; - fRange.a := $FF; - fShift.a := 8; - fglFormat := GL_LUMINANCE_ALPHA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdRGB_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - aData^ := aPixel.Data.r; + aData^ := aPixel.Data.b; inc(aData); aData^ := aPixel.Data.g; inc(aData); - aData^ := aPixel.Data.b; + aData^ := aPixel.Data.r; inc(aData); end; procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - aPixel.Data.r := aData^; + aPixel.Data.b := aData^; inc(aData); aPixel.Data.g := aData^; inc(aData); - aPixel.Data.b := aData^; + aPixel.Data.r := aData^; inc(aData); aPixel.Data.a := 0; end; -constructor TfdRGB_UB3.Create; -begin - inherited Create; - fPixelSize := 3.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 0; - fShift.g := 8; - fShift.b := 16; - fglFormat := GL_RGB; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGR_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdBGR_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - aData^ := aPixel.Data.b; + aData^ := aPixel.Data.r; inc(aData); aData^ := aPixel.Data.g; inc(aData); - aData^ := aPixel.Data.r; + aData^ := aPixel.Data.b; inc(aData); end; procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - aPixel.Data.b := aData^; + aPixel.Data.r := aData^; inc(aData); aPixel.Data.g := aData^; inc(aData); - aPixel.Data.r := aData^; + aPixel.Data.b := aData^; inc(aData); aPixel.Data.a := 0; end; -constructor TfdBGR_UB3.Create; -begin - fPixelSize := 3.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 16; - fShift.g := 8; - fShift.b := 0; - fglFormat := GL_BGR; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TdfRGBA_UB4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - inherited Map(aPixel, aData, aMapData); - aData^ := aPixel.Data.a; - inc(aData); -end; - -procedure TfdRGBA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -begin - inherited Unmap(aData, aPixel, aMapData); - aPixel.Data.a := aData^; - inc(aData); -end; - -constructor TfdRGBA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGRA_UB4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - inherited Map(aPixel, aData, aMapData); - aData^ := aPixel.Data.a; - inc(aData); -end; - -procedure TfdBGRA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -begin - inherited Unmap(aData, aPixel, aMapData); - aPixel.Data.a := aData^; - inc(aData); -end; - -constructor TfdBGRA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdAlpha_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2545,15 +2717,6 @@ begin inc(aData, 2); end; -constructor TfdAlpha_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.a := $FFFF; - fglFormat := GL_ALPHA; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminance_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2572,17 +2735,6 @@ begin inc(aData, 2); end; -constructor TfdLuminance_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fglFormat := GL_LUMINANCE; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2606,12 +2758,6 @@ begin inc(aData, 2); end; -constructor TfdUniversal_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2626,21 +2772,10 @@ begin aPixel.Data.r := PWord(aData)^; aPixel.Data.g := PWord(aData)^; aPixel.Data.b := PWord(aData)^; - aPixel.Data.a := 0; + aPixel.Data.a := PWord(aData)^;; inc(aData, 2); end; -constructor TfdDepth_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_US2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2658,117 +2793,86 @@ begin inc(aData, 2); end; -constructor TfdLuminanceAlpha_US2.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FFFF; - fShift.a := 16; - fglFormat := GL_LUMINANCE_ALPHA; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGB_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - PWord(aData)^ := aPixel.Data.r; + PWord(aData)^ := aPixel.Data.b; inc(aData, 2); PWord(aData)^ := aPixel.Data.g; inc(aData, 2); - PWord(aData)^ := aPixel.Data.b; + PWord(aData)^ := aPixel.Data.r; inc(aData, 2); end; procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - aPixel.Data.r := PWord(aData)^; + aPixel.Data.b := PWord(aData)^; inc(aData, 2); aPixel.Data.g := PWord(aData)^; inc(aData, 2); - aPixel.Data.b := PWord(aData)^; + aPixel.Data.r := PWord(aData)^; inc(aData, 2); aPixel.Data.a := 0; end; -constructor TfdRGB_US3.Create; -begin - inherited Create; - fPixelSize := 6.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 0; - fShift.g := 16; - fShift.b := 32; - fglFormat := GL_RGB; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGR_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdBGR_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - PWord(aData)^ := aPixel.Data.b; + PWord(aData)^ := aPixel.Data.r; inc(aData, 2); PWord(aData)^ := aPixel.Data.g; inc(aData, 2); - PWord(aData)^ := aPixel.Data.r; + PWord(aData)^ := aPixel.Data.b; inc(aData, 2); end; procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - aPixel.Data.b := PWord(aData)^; + aPixel.Data.r := PWord(aData)^; inc(aData, 2); aPixel.Data.g := PWord(aData)^; inc(aData, 2); - aPixel.Data.r := PWord(aData)^; + aPixel.Data.b := PWord(aData)^; inc(aData, 2); aPixel.Data.a := 0; end; -constructor TfdBGR_US3.Create; -begin - inherited Create; - fPixelSize := 6.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 32; - fShift.g := 16; - fShift.b := 0; - fglFormat := GL_BGR; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Map(aPixel, aData, aMapData); PWord(aData)^ := aPixel.Data.a; inc(aData, 2); + inherited Map(aPixel, aData, aMapData); end; procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := PWord(aData)^; inc(aData, 2); + inherited Unmap(aData, aPixel, aMapData); end; -constructor TfdRGBA_US4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdARGB_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_SHORT; + inherited Map(aPixel, aData, aMapData); + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); +end; + +procedure TfdARGB_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +begin + inherited Unmap(aData, aPixel, aMapData); + aPixel.Data.a := PWord(aData)^; + inc(aData, 2); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2776,26 +2880,33 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Map(aPixel, aData, aMapData); PWord(aData)^ := aPixel.Data.a; inc(aData, 2); + inherited Map(aPixel, aData, aMapData); end; procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := PWord(aData)^; inc(aData, 2); + inherited Unmap(aData, aPixel, aMapData); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdABGR_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdABGR_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + inherited Map(aPixel, aData, aMapData); + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); end; -constructor TfdBGRA_US4.Create; +procedure TfdABGR_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_SHORT; + inherited Unmap(aData, aPixel, aMapData); + aPixel.Data.a := PWord(aData)^; + inc(aData, 2); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2821,12 +2932,6 @@ begin inc(aData, 2); end; -constructor TfdUniversal_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2845,287 +2950,482 @@ begin inc(aData, 4); end; -constructor TfdDepth_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.r := $FFFFFFFF; - fRange.g := $FFFFFFFF; - fRange.b := $FFFFFFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglDataFormat := GL_UNSIGNED_INT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TfdAlpha4.Create; begin inherited Create; + fPixelSize := 1.0; fFormat := tfAlpha4; fWithAlpha := tfAlpha4; + fOpenGLFormat := tfAlpha4; + fRange.a := $FF; + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdAlpha8.Create; begin inherited Create; + fPixelSize := 1.0; fFormat := tfAlpha8; fWithAlpha := tfAlpha8; + fOpenGLFormat := tfAlpha8; + fRange.a := $FF; + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA8; -end; - -constructor TfdAlpha12.Create; -begin - inherited Create; - fFormat := tfAlpha12; - fWithAlpha := tfAlpha12; - fglInternalFormat := GL_ALPHA12; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdAlpha16.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfAlpha16; fWithAlpha := tfAlpha16; + fOpenGLFormat := tfAlpha16; + fRange.a := $FFFF; + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdLuminance4.Create; begin inherited Create; + fPixelSize := 1.0; fFormat := tfLuminance4; fWithAlpha := tfLuminance4Alpha4; fWithoutAlpha := tfLuminance4; + fOpenGLFormat := tfLuminance4; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE4; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdLuminance8.Create; begin inherited Create; + fPixelSize := 1.0; fFormat := tfLuminance8; fWithAlpha := tfLuminance8Alpha8; fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE8; -end; - -constructor TfdLuminance12.Create; -begin - inherited Create; - fFormat := tfLuminance12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdLuminance16.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfLuminance16; fWithAlpha := tfLuminance16Alpha16; fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE16; + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdLuminance4Alpha4.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfLuminance4Alpha4; fWithAlpha := tfLuminance4Alpha4; fWithoutAlpha := tfLuminance4; + fOpenGLFormat := tfLuminance4Alpha4; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE4_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdLuminance6Alpha2.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfLuminance6Alpha2; fWithAlpha := tfLuminance6Alpha2; fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance6Alpha2; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE6_ALPHA2; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdLuminance8Alpha8.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfLuminance8Alpha8; fWithAlpha := tfLuminance8Alpha8; fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance8Alpha8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE8_ALPHA8; + fglDataFormat := GL_UNSIGNED_BYTE; end; constructor TfdLuminance12Alpha4.Create; begin inherited Create; + fPixelSize := 4.0; fFormat := tfLuminance12Alpha4; fWithAlpha := tfLuminance12Alpha4; - fWithoutAlpha := tfLuminance12; + fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance12Alpha4; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 16; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE12_ALPHA4; -end; - -constructor TfdLuminance12Alpha12.Create; -begin - inherited Create; - fFormat := tfLuminance12Alpha12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12_ALPHA12; + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdLuminance16Alpha16.Create; begin inherited Create; + fPixelSize := 4.0; fFormat := tfLuminance16Alpha16; fWithAlpha := tfLuminance16Alpha16; fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance16Alpha16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 16; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE16_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdR3G3B2.Create; begin inherited Create; + fPixelSize := 1.0; fFormat := tfR3G3B2; - fWithAlpha := tfRGBA2; + fWithAlpha := tfRGBA4; fWithoutAlpha := tfR3G3B2; - fRange.r := $7; - fRange.g := $7; - fRange.b := $3; - fShift.r := 0; - fShift.g := 3; - fShift.b := 6; + fOpenGLFormat := tfR3G3B2; + fRGBInverted := tfEmpty; + fRange.r := $07; + fRange.g := $07; + fRange.b := $04; + fShift.r := 5; + fShift.g := 2; + fShift.b := 0; fglFormat := GL_RGB; fglInternalFormat := GL_R3_G3_B2; - fglDataFormat := GL_UNSIGNED_BYTE_2_3_3_REV; + fglDataFormat := GL_UNSIGNED_BYTE_3_3_2; end; -constructor TfdRGB4.Create; +constructor TfdRGBX4.Create; begin inherited Create; - fFormat := tfRGB4; + fPixelSize := 2.0; + fFormat := tfRGBX4; fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; - fRGBInverted := tfBGR4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; + fWithoutAlpha := tfRGBX4; + fOpenGLFormat := tfRGBX4; + fRGBInverted := tfBGRX4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $00; + fShift.r := 12; + fShift.g := 8; + fShift.b := 4; fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdXRGB4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfXRGB4; + fWithAlpha := tfARGB4; + fWithoutAlpha := tfXRGB4; + fOpenGLFormat := tfXRGB4; + fRGBInverted := tfXBGR4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fShift.r := 8; + fShift.g := 4; + fShift.b := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; constructor TfdR5G6B5.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfR5G6B5; - fWithAlpha := tfRGBA4; + fWithAlpha := tfRGB5A1; fWithoutAlpha := tfR5G6B5; + fOpenGLFormat := tfR5G6B5; fRGBInverted := tfB5G6R5; fRange.r := $1F; fRange.g := $3F; fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 11; + fShift.r := 11; + fShift.g := 5; + fShift.b := 0; fglFormat := GL_RGB; fglInternalFormat := GL_RGB565; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; end; -constructor TfdRGB5.Create; +constructor TfdRGB5X1.Create; begin inherited Create; - fFormat := tfRGB5; + fPixelSize := 2.0; + fFormat := tfRGB5X1; fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; - fRGBInverted := tfBGR5; + fWithoutAlpha := tfRGB5X1; + fOpenGLFormat := tfRGB5X1; + fRGBInverted := tfBGR5X1; fRange.r := $1F; fRange.g := $1F; fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; + fShift.r := 11; + fShift.g := 6; + fShift.b := 1; fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdX1RGB5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfX1RGB5; + fWithAlpha := tfA1RGB5; + fWithoutAlpha := tfX1RGB5; + fOpenGLFormat := tfX1RGB5; + fRGBInverted := tfX1BGR5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 10; + fShift.g := 5; + fShift.b := 0; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB5; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; constructor TfdRGB8.Create; begin inherited Create; + fPixelSize := 3.0; fFormat := tfRGB8; fWithAlpha := tfRGBA8; fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfRGB8; fRGBInverted := tfBGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + fglFormat := GL_BGR; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdRGBX8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfRGBX8; + fWithAlpha := tfRGBA8; + fWithoutAlpha := tfRGBX8; + fOpenGLFormat := tfRGB8; + fRGBInverted := tfBGRX8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 24; + fShift.g := 16; + fShift.b := 8; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdXRGB8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfXRGB8; + fWithAlpha := tfXRGB8; + fWithoutAlpha := tfXRGB8; + fOpenGLFormat := tfRGB8; + fRGBInverted := tfXBGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; end; -constructor TfdRGB10.Create; +constructor TfdRGB10X2.Create; begin inherited Create; - fFormat := tfRGB10; + fPixelSize := 3.0; + fFormat := tfRGB10X2; fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; - fRGBInverted := tfBGR10; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; + fWithoutAlpha := tfRGB10X2; + fOpenGLFormat := tfRGB10X2; + fRGBInverted := tfBGR10X2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 22; + fShift.g := 12; + fShift.b := 2; fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdRGB12.Create; +constructor TfdX2RGB10.Create; begin inherited Create; - fFormat := tfRGB12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGR12; - fglInternalFormat := GL_RGB12; + fPixelSize := 3.0; + fFormat := tfX2RGB10; + fWithAlpha := tfA2RGB10; + fWithoutAlpha := tfX2RGB10; + fOpenGLFormat := tfX2RGB10; + fRGBInverted := tfX2BGR10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 20; + fShift.g := 10; + fShift.b := 0; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; constructor TfdRGB16.Create; begin inherited Create; + fPixelSize := 6.0; fFormat := tfRGB16; fWithAlpha := tfRGBA16; fWithoutAlpha := tfRGB16; + fOpenGLFormat := tfRGB16; fRGBInverted := tfBGR16; - fglInternalFormat := GL_RGB16; -end; - -constructor TfdRGBA2.Create; -begin - inherited Create; - fFormat := tfRGBA2; - fWithAlpha := tfRGBA2; - fWithoutAlpha := tfR3G3B2; - fRGBInverted := tfBGRA2; - fglInternalFormat := GL_RGBA2; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fShift.r := 32; + fShift.g := 16; + fShift.b := 0; + fglFormat := GL_BGR; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdRGBA4.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfRGBA4; fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; + fWithoutAlpha := tfRGBX4; + fOpenGLFormat := tfRGBA4; fRGBInverted := tfBGRA4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $F; - fShift.r := 0; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 12; + fShift.g := 8; + fShift.b := 4; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdARGB4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfARGB4; + fWithAlpha := tfARGB4; + fWithoutAlpha := tfXRGB4; + fOpenGLFormat := tfARGB4; + fRGBInverted := tfABGR4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 8; fShift.g := 4; - fShift.b := 8; + fShift.b := 0; fShift.a := 12; - fglFormat := GL_RGBA; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; @@ -3133,132 +3433,257 @@ end; constructor TfdRGB5A1.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfRGB5A1; fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; + fWithoutAlpha := tfRGB5X1; + fOpenGLFormat := tfRGB5A1; fRGBInverted := tfBGR5A1; fRange.r := $1F; fRange.g := $1F; fRange.b := $1F; fRange.a := $01; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; - fShift.a := 15; + fShift.r := 11; + fShift.g := 6; + fShift.b := 1; + fShift.a := 0; fglFormat := GL_RGBA; fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdA1RGB5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfA1RGB5; + fWithAlpha := tfA1RGB5; + fWithoutAlpha := tfX1RGB5; + fOpenGLFormat := tfA1RGB5; + fRGBInverted := tfA1BGR5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 10; + fShift.g := 5; + fShift.b := 0; + fShift.a := 15; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; constructor TfdRGBA8.Create; begin inherited Create; + fPixelSize := 4.0; fFormat := tfRGBA8; fWithAlpha := tfRGBA8; fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfRGBA8; fRGBInverted := tfBGRA8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 24; + fShift.g := 16; + fShift.b := 8; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdARGB8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfARGB8; + fWithAlpha := tfARGB8; + fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfARGB8; + fRGBInverted := tfABGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + fShift.a := 24; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; end; constructor TfdRGB10A2.Create; begin inherited Create; + fPixelSize := 3.0; fFormat := tfRGB10A2; fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; + fWithoutAlpha := tfRGB10X2; + fOpenGLFormat := tfRGB10A2; fRGBInverted := tfBGR10A2; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $003; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; - fShift.a := 30; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 22; + fShift.g := 12; + fShift.b := 2; + fShift.a := 0; fglFormat := GL_RGBA; fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdRGBA12.Create; +constructor TfdA2RGB10.Create; begin inherited Create; - fFormat := tfRGBA12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGRA12; - fglInternalFormat := GL_RGBA12; + fPixelSize := 3.0; + fFormat := tfA2RGB10; + fWithAlpha := tfA2RGB10; + fWithoutAlpha := tfX2RGB10; + fOpenGLFormat := tfA2RGB10; + fRGBInverted := tfA2BGR10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 20; + fShift.g := 10; + fShift.b := 0; + fShift.a := 30; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; constructor TfdRGBA16.Create; begin inherited Create; + fPixelSize := 8.0; fFormat := tfRGBA16; fWithAlpha := tfRGBA16; fWithoutAlpha := tfRGB16; + fOpenGLFormat := tfRGBA16; fRGBInverted := tfBGRA16; - fglInternalFormat := GL_RGBA16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 48; + fShift.g := 32; + fShift.b := 16; + fShift.a := 0; + fglFormat := GL_BGRA; // reverse byte order to match little endianess + fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdBGR4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TfdBGRX4.Create; begin inherited Create; fPixelSize := 2.0; - fFormat := tfBGR4; + fFormat := tfBGRX4; fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGB4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $0; - fShift.r := 8; - fShift.g := 4; - fShift.b := 0; - fShift.a := 0; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fWithoutAlpha := tfBGRX4; + fOpenGLFormat := tfBGRX4; + fRGBInverted := tfRGBX4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fShift.r := 4; + fShift.g := 8; + fShift.b := 12; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdXBGR4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfXBGR4; + fWithAlpha := tfABGR4; + fWithoutAlpha := tfXBGR4; + fOpenGLFormat := tfXBGR4; + fRGBInverted := tfXRGB4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 0; + fShift.g := 4; + fShift.b := 8; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TfdB5G6R5.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfB5G6R5; - fWithAlpha := tfBGRA4; + fWithAlpha := tfBGR5A1; fWithoutAlpha := tfB5G6R5; + fOpenGLFormat := tfB5G6R5; fRGBInverted := tfR5G6B5; fRange.r := $1F; fRange.g := $3F; fRange.b := $1F; - fShift.r := 11; - fShift.g := 5; - fShift.b := 0; - fglFormat := GL_RGB; //B5G6R5 is only possible as R5G6B5 -> use reverted dataformat - fglInternalFormat := GL_RGB8; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; + fShift.r := 0; + fShift.g := 5; + fShift.b := 11; + fglFormat := GL_RGB; + fglInternalFormat := GL_RGB565; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; end; -constructor TfdBGR5.Create; +constructor TfdBGR5X1.Create; begin inherited Create; fPixelSize := 2.0; - fFormat := tfBGR5; + fFormat := tfBGR5X1; fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; - fRGBInverted := tfRGB5; + fWithoutAlpha := tfBGR5X1; + fOpenGLFormat := tfBGR5X1; + fRGBInverted := tfRGB5X1; fRange.r := $1F; fRange.g := $1F; fRange.b := $1F; - fRange.a := $00; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - fShift.a := 0; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fShift.r := 1; + fShift.g := 6; + fShift.b := 11; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdX1BGR5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfX1BGR5; + fWithAlpha := tfA1BGR5; + fWithoutAlpha := tfX1BGR5; + fOpenGLFormat := tfX1BGR5; + fRGBInverted := tfX1RGB5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 0; + fShift.g := 5; + fShift.b := 10; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB5; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; @@ -3266,79 +3691,163 @@ end; constructor TfdBGR8.Create; begin inherited Create; + fPixelSize := 3.0; fFormat := tfBGR8; fWithAlpha := tfBGRA8; fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfBGR8; fRGBInverted := tfRGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + fglFormat := GL_RGB; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdBGRX8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfBGRX8; + fWithAlpha := tfBGRA8; + fWithoutAlpha := tfBGRX8; + fOpenGLFormat := tfBGRX8; + fRGBInverted := tfRGBX8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 8; + fShift.g := 16; + fShift.b := 24; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdXBGR8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfXBGR8; + fWithAlpha := tfABGR8; + fWithoutAlpha := tfXBGR8; + fOpenGLFormat := tfXBGR8; + fRGBInverted := tfXRGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; end; -constructor TfdBGR10.Create; +constructor TfdBGR10X2.Create; begin inherited Create; - fFormat := tfBGR10; + fPixelSize := 3.0; + fFormat := tfBGR10X2; fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10; - fRGBInverted := tfRGB10; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $000; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - fShift.a := 0; + fWithoutAlpha := tfBGR10X2; + fOpenGLFormat := tfBGR10X2; + fRGBInverted := tfRGB10X2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 2; + fShift.g := 12; + fShift.b := 22; fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdBGR12.Create; +constructor TfdX2BGR10.Create; begin inherited Create; - fFormat := tfBGR12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGB12; - fglInternalFormat := GL_RGB12; + fPixelSize := 3.0; + fFormat := tfX2BGR10; + fWithAlpha := tfA2BGR10; + fWithoutAlpha := tfX2BGR10; + fOpenGLFormat := tfX2BGR10; + fRGBInverted := tfX2RGB10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 0; + fShift.g := 10; + fShift.b := 20; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; constructor TfdBGR16.Create; begin inherited Create; + fPixelSize := 6.0; fFormat := tfBGR16; fWithAlpha := tfBGRA16; fWithoutAlpha := tfBGR16; + fOpenGLFormat := tfBGR16; fRGBInverted := tfRGB16; - fglInternalFormat := GL_RGB16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fShift.r := 0; + fShift.g := 16; + fShift.b := 32; + fglFormat := GL_RGB; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdBGRA2.Create; +constructor TfdBGRA4.Create; begin inherited Create; - fFormat := tfBGRA2; + fPixelSize := 2.0; + fFormat := tfBGRA4; fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGBA2; - fglInternalFormat := GL_RGBA2; + fWithoutAlpha := tfBGRX4; + fOpenGLFormat := tfBGRA4; + fRGBInverted := tfRGBA4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 4; + fShift.g := 8; + fShift.b := 12; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; end; -constructor TfdBGRA4.Create; +constructor TfdABGR4.Create; begin inherited Create; - fFormat := tfBGRA4; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGBA4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $F; - fShift.r := 8; + fPixelSize := 2.0; + fFormat := tfABGR4; + fWithAlpha := tfABGR4; + fWithoutAlpha := tfXBGR4; + fOpenGLFormat := tfABGR4; + fRGBInverted := tfARGB4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 0; fShift.g := 4; - fShift.b := 0; + fShift.b := 8; fShift.a := 12; - fglFormat := GL_BGRA; + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; @@ -3346,98 +3855,203 @@ end; constructor TfdBGR5A1.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfBGR5A1; fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; + fWithoutAlpha := tfBGR5X1; + fOpenGLFormat := tfBGR5A1; fRGBInverted := tfRGB5A1; fRange.r := $1F; fRange.g := $1F; fRange.b := $1F; fRange.a := $01; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - fShift.a := 15; + fShift.r := 1; + fShift.g := 6; + fShift.b := 11; + fShift.a := 0; fglFormat := GL_BGRA; fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdA1BGR5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfA1BGR5; + fWithAlpha := tfA1BGR5; + fWithoutAlpha := tfX1BGR5; + fOpenGLFormat := tfA1BGR5; + fRGBInverted := tfA1RGB5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 0; + fShift.g := 5; + fShift.b := 10; + fShift.a := 15; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; constructor TfdBGRA8.Create; begin inherited Create; + fPixelSize := 4.0; fFormat := tfBGRA8; fWithAlpha := tfBGRA8; fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfBGRA8; fRGBInverted := tfRGBA8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 8; + fShift.g := 16; + fShift.b := 24; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdABGR8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfABGR8; + fWithAlpha := tfABGR8; + fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfABGR8; + fRGBInverted := tfARGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + fShift.a := 24; + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; end; constructor TfdBGR10A2.Create; begin inherited Create; + fPixelSize := 3.0; fFormat := tfBGR10A2; fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10; + fWithoutAlpha := tfBGR10X2; + fOpenGLFormat := tfBGR10A2; fRGBInverted := tfRGB10A2; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $003; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - fShift.a := 30; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 2; + fShift.g := 12; + fShift.b := 22; + fShift.a := 0; fglFormat := GL_BGRA; fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdBGRA12.Create; +constructor TfdA2BGR10.Create; begin inherited Create; - fFormat := tfBGRA12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGBA12; - fglInternalFormat := GL_RGBA12; + fPixelSize := 3.0; + fFormat := tfA2BGR10; + fWithAlpha := tfA2BGR10; + fWithoutAlpha := tfX2BGR10; + fOpenGLFormat := tfA2BGR10; + fRGBInverted := tfA2RGB10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 0; + fShift.g := 10; + fShift.b := 20; + fShift.a := 30; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; constructor TfdBGRA16.Create; begin inherited Create; + fPixelSize := 8.0; fFormat := tfBGRA16; fWithAlpha := tfBGRA16; fWithoutAlpha := tfBGR16; + fOpenGLFormat := tfBGRA16; fRGBInverted := tfRGBA16; - fglInternalFormat := GL_RGBA16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 16; + fShift.g := 32; + fShift.b := 48; + fShift.a := 0; + fglFormat := GL_RGBA; // reverse byte order to match little endianess + fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdDepth16.Create; begin inherited Create; + fPixelSize := 2.0; fFormat := tfDepth16; - fWithAlpha := tfEmpty; fWithoutAlpha := tfDepth16; + fOpenGLFormat := tfDepth16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT16; + fglDataFormat := GL_UNSIGNED_SHORT; end; constructor TfdDepth24.Create; begin inherited Create; + fPixelSize := 3.0; fFormat := tfDepth24; - fWithAlpha := tfEmpty; fWithoutAlpha := tfDepth24; + fOpenGLFormat := tfDepth24; + fRange.r := $FFFFFF; + fRange.g := $FFFFFF; + fRange.b := $FFFFFF; + fRange.a := $FFFFFF; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT24; + fglDataFormat := GL_UNSIGNED_INT; end; constructor TfdDepth32.Create; begin inherited Create; + fPixelSize := 4.0; fFormat := tfDepth32; - fWithAlpha := tfEmpty; fWithoutAlpha := tfDepth32; + fOpenGLFormat := tfDepth32; + fRange.r := $FFFFFFFF; + fRange.g := $FFFFFFFF; + fRange.b := $FFFFFFFF; + fRange.a := $FFFFFFFF; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT32; + fglDataFormat := GL_UNSIGNED_INT; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3445,12 +4059,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; @@ -3458,6 +4072,7 @@ begin inherited Create; fFormat := tfS3tcDtx1RGBA; fWithAlpha := tfS3tcDtx1RGBA; + fOpenGLFormat := tfS3tcDtx1RGBA; fUncompressed := tfRGB5A1; fPixelSize := 0.5; fIsCompressed := true; @@ -3471,12 +4086,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; @@ -3484,6 +4099,7 @@ begin inherited Create; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; fUncompressed := tfRGBA8; fPixelSize := 1.0; fIsCompressed := true; @@ -3497,12 +4113,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; @@ -3510,6 +4126,7 @@ begin inherited Create; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; fUncompressed := tfRGBA8; fPixelSize := 1.0; fIsCompressed := true; @@ -3519,6 +4136,21 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; +var + f: TglBitmapFormat; +begin + for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin + result := TFormatDescriptor.Get(f); + if (result.glInternalFormat = aInternalFormat) then + exit; + end; + result := TFormatDescriptor.Get(tfEmpty); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class procedure TFormatDescriptor.Init; @@ -3543,7 +4175,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -class function TFormatDescriptor.GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; +class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; begin result := Get(Get(aFormat).WithAlpha); end; @@ -3635,7 +4267,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 +4285,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 +4300,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 +4343,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 +4391,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; @@ -3795,7 +4427,7 @@ begin if (aSourceFD.Range.arr[i] > 0) then aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i]) else - aPixel.Data.arr[i] := aDestFD.Range.arr[i]; + aPixel.Data.arr[i] := 0; end; end; end; @@ -3945,6 +4577,12 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmap - PROTECTED/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor; +begin + result := TFormatDescriptor.Get(Format); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.GetWidth: Integer; begin if (ffX in fDimension.Fields) then @@ -3999,6 +4637,14 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetFreeDataOnDestroy(const aValue: Boolean); +begin + if fFreeDataOnDestroy = aValue then + exit; + fFreeDataOnDestroy := aValue; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean); begin if fDeleteTextureOnFree = aValue then @@ -4087,6 +4733,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 @@ -4110,12 +4759,11 @@ begin fData := aData; end; - FillChar(fDimension, SizeOf(fDimension), 0); if not Assigned(fData) then begin - fFormat := tfEmpty; fPixelSize := 0; fRowSize := 0; end else begin + FillChar(fDimension, SizeOf(fDimension), 0); if aWidth <> -1 then begin fDimension.Fields := fDimension.Fields + [ffX]; fDimension.X := aWidth; @@ -4156,13 +4804,13 @@ begin fTarget := 0; fIsResident := false; - fFormat := glBitmapGetDefaultFormat; fMipMap := glBitmapDefaultMipmap; fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture; fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; glBitmapGetDefaultFilter (fFilterMin, fFilterMag); glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); + glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4170,8 +4818,10 @@ procedure TglBitmap.BeforeDestruction; var NewData: PByte; begin - NewData := nil; - SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method + if fFreeDataOnDestroy then begin + NewData := nil; + SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method + end; if (fID > 0) and fDeleteTextureOnFree then glDeleteTextures(1, @fID); inherited BeforeDestruction; @@ -4195,7 +4845,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 +4868,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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4238,7 +4888,7 @@ begin FreeMem(tmpData); raise; end; - AddFunc(Self, aFunc, false, Format, aArgs); + AddFunc(Self, aFunc, false, aFormat, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4594,7 +5244,7 @@ begin tfRGBA8, tfBGRA8: aBitmap.PixelFormat := pf32bit; else - raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.'); + raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); end; pSource := Data; @@ -4632,7 +5282,7 @@ begin pf32bit: IntFormat := tfBGRA8; else - raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.'); + raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.'); end; TempWidth := aBitmap.Width; @@ -4696,7 +5346,7 @@ begin Inc(pSource); end; end; - end; + end; result := true; end; end; @@ -4734,16 +5384,16 @@ begin FillChar(rid{%H-}, SizeOf(rid), 0); if (Format in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16]) then + tfAlpha4, tfAlpha8, tfAlpha16, + tfLuminance4, tfLuminance8, tfLuminance16, + tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then rid.Format := ricfGray else rid.Format := ricfRGBA; rid.Width := Width; rid.Height := Height; - rid.Depth := CountSetBits(FormatDesc.Range.r or FormatDesc.Range.g or FormatDesc.Range.b or FormatDesc.Range.a); + rid.Depth := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask); rid.BitOrder := riboBitsInOrder; rid.ByteOrder := riboLSBFirst; rid.LineOrder := riloTopToBottom; @@ -4776,6 +5426,42 @@ var FormatDesc: TFormatDescriptor; ImageData: PByte; ImageSize: Integer; + CanCopy: Boolean; + + procedure CopyConvert; + var + bfFormat: TbmpBitfieldFormat; + pSourceLine, pDestLine: PByte; + pSourceMD, pDestMD: Pointer; + x, y: Integer; + pixel: TglBitmapPixelData; + begin + bfFormat := TbmpBitfieldFormat.Create; + with aImage.DataDescription do begin + bfFormat.RedMask := ((1 shl RedPrec) - 1) shl RedShift; + bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift; + bfFormat.BlueMask := ((1 shl BluePrec) - 1) shl BlueShift; + bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift; + bfFormat.PixelSize := BitsPerPixel / 8; + end; + pSourceMD := bfFormat.CreateMappingData; + pDestMD := FormatDesc.CreateMappingData; + try + for y := 0 to aImage.Height-1 do begin + pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine; + pDestLine := ImageData + y * Round(FormatDesc.PixelSize * aImage.Width); + for x := 0 to aImage.Width-1 do begin + bfFormat.Unmap(pSourceLine, pixel, pSourceMD); + FormatDesc.Map(pixel, pDestLine, pDestMD); + end; + end; + finally + FormatDesc.FreeMappingData(pDestMD); + bfFormat.FreeMappingData(pSourceMD); + bfFormat.Free; + end; + end; + begin result := false; if not Assigned(aImage) then @@ -4794,10 +5480,17 @@ begin if (f = tfEmpty) then exit; + CanCopy := + (Round(FormatDesc.PixelSize * 8) = aImage.DataDescription.Depth) and + (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth); + ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height); ImageData := GetMem(ImageSize); try - Move(aImage.PixelData^, ImageData^, (aImage.Width * aImage.Height * aImage.DataDescription.BitsPerPixel) shr 3); + if CanCopy then + Move(aImage.PixelData^, ImageData^, ImageSize) + else + CopyConvert; SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method except if Assigned(ImageData) then @@ -4944,7 +5637,7 @@ function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBit var FS: TFileStream; begin - FS := TFileStream.Create(FileName, fmOpenRead); + FS := TFileStream.Create(aFileName, fmOpenRead); try result := AddAlphaFromStream(FS, aFunc, aArgs); finally @@ -5044,7 +5737,7 @@ function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); result := AddAlphaFromColorKeyFloat( aRed / PixelData.Range.r, aGreen / PixelData.Range.g, @@ -5060,7 +5753,7 @@ var i: Integer; PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); with PixelData do begin values[0] := aRed; values[1] := aGreen; @@ -5088,7 +5781,7 @@ function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); end; @@ -5097,7 +5790,7 @@ function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean; var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); with PixelData do Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha))); result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); @@ -5177,6 +5870,15 @@ var SourcePD, DestPD: TglBitmapPixelData; ShiftData: TShiftData; + function DataIsIdentical: Boolean; + begin + result := + (SourceFD.RedMask = DestFD.RedMask) and + (SourceFD.GreenMask = DestFD.GreenMask) and + (SourceFD.BlueMask = DestFD.BlueMask) and + (SourceFD.AlphaMask = DestFD.AlphaMask); + end; + function CanCopyDirect: Boolean; begin result := @@ -5209,6 +5911,12 @@ begin SourceFD := TFormatDescriptor.Get(Format); DestFD := TFormatDescriptor.Get(aFormat); + if DataIsIdentical then begin + result := true; + Format := aFormat; + exit; + end; + SourceFD.PreparePixel(SourcePD); DestFD.PreparePixel (DestPD); @@ -5231,8 +5939,8 @@ procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); begin if aUseRGB or aUseAlpha then AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( - ((PtrInt(aUseAlpha) and 1) shl 1) or - (PtrInt(aUseRGB) and 1) )); + ((Byte(aUseAlpha) and 1) shl 1) or + (Byte(aUseRGB) and 1) )); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5269,7 +5977,7 @@ procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; cons var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); FillWithColorFloat( aRed / PixelData.Range.r, aGreen / PixelData.Range.g, @@ -5293,7 +6001,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 +6018,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 +6028,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 +6051,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 +6080,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; @@ -5393,6 +6101,32 @@ begin 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, PGLint(@fSwizzle[0])); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); begin if aEnableTextureUnit then @@ -5413,18 +6147,20 @@ 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} inherited Create; + fFormat := glBitmapGetDefaultFormat; + fFreeDataOnDestroy := true; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create(const aFileName: String); begin Create; - LoadFromFile(FileName); + LoadFromFile(aFileName); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5435,27 +6171,30 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat); +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte); var - Image: PByte; ImageSize: Integer; begin Create; - ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(Image, ImageSize); - try - FillChar(Image^, ImageSize, #$FF); - SetDataPointer(Image, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - except - if Assigned(Image) then - FreeMem(Image); - raise; + if not Assigned(aData) then begin + ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); + GetMem(aData, ImageSize); + try + FillChar(aData^, ImageSize, #$FF); + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + except + if Assigned(aData) then + FreeMem(aData); + raise; + end; + end else begin + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + fFreeDataOnDestroy := false; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; - const aFunc: TglBitmapFunction; const aArgs: Pointer); +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); begin Create; LoadFromFunc(aSize, aFunc, aFormat, aArgs); @@ -5476,11 +6215,51 @@ begin end; {$IFDEF GLB_SUPPORT_PNG_READ} -{$IF DEFINED(GLB_SDL_IMAGE)} +{$IF DEFINED(GLB_LAZ_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //PNG///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.LoadPNG(const aStream: TStream): Boolean; +const + MAGIC_LEN = 8; + PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A; +var + reader: TLazReaderPNG; + intf: TLazIntfImage; + StreamPos: Int64; + magic: String[MAGIC_LEN]; +begin + result := true; + StreamPos := aStream.Position; + + SetLength(magic, MAGIC_LEN); + aStream.Read(magic[1], MAGIC_LEN); + aStream.Position := StreamPos; + if (magic <> PNG_MAGIC) then begin + result := false; + exit; + end; + + intf := TLazIntfImage.Create(0, 0); + reader := TLazReaderPNG.Create; + try try + reader.UpdateDescription := true; + reader.ImageRead(aStream, intf); + AssignFromLazIntfImage(intf); + except + result := false; + aStream.Position := StreamPos; + exit; + end; + finally + reader.Free; + intf.Free; + end; +end; + +{$ELSEIF DEFINED(GLB_SDL_IMAGE)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.LoadPNG(const aStream: TStream): Boolean; var Surface: PSDL_Surface; RWops: PSDL_RWops; @@ -5554,7 +6333,7 @@ begin // read informations png_read_info(png, png_info); - // size + // size TempHeight := png_get_image_height(png, png_info); TempWidth := png_get_image_width(png, png_info); @@ -5721,7 +6500,29 @@ begin end; {$ENDIF} -{$IF DEFINED(GLB_LIB_PNG)} +{$IF DEFINED(GLB_LAZ_PNG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SavePNG(const aStream: TStream); +var + png: TPortableNetworkGraphic; + intf: TLazIntfImage; + raw: TRawImage; +begin + png := TPortableNetworkGraphic.Create; + intf := TLazIntfImage.Create(0, 0); + try + if not AssignToLazIntfImage(intf) then + raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); + intf.GetRawImage(raw); + png.LoadFromRawImage(raw, false); + png.SaveToStream(aStream); + finally + png.Free; + intf.Free; + end; +end; + +{$ELSEIF DEFINED(GLB_LIB_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SavePNG(const aStream: TStream); var @@ -6011,7 +6812,47 @@ end; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_READ} -{$IF DEFINED(GLB_SDL_IMAGE)} +{$IF DEFINED(GLB_LAZ_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; +const + MAGIC_LEN = 2; + JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8; +var + intf: TLazIntfImage; + reader: TFPReaderJPEG; + StreamPos: Int64; + magic: String[MAGIC_LEN]; +begin + result := true; + StreamPos := aStream.Position; + + SetLength(magic, MAGIC_LEN); + aStream.Read(magic[1], MAGIC_LEN); + aStream.Position := StreamPos; + if (magic <> JPEG_MAGIC) then begin + result := false; + exit; + end; + + reader := TFPReaderJPEG.Create; + intf := TLazIntfImage.Create(0, 0); + try try + intf.DataDescription := GetDescriptionFromDevice(0, 0, 0); + reader.ImageRead(aStream, intf); + AssignFromLazIntfImage(intf); + except + result := false; + aStream.Position := StreamPos; + exit; + end; + finally + reader.Free; + intf.Free; + end; +end; + +{$ELSEIF DEFINED(GLB_SDL_IMAGE)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; var @@ -6189,7 +7030,29 @@ end; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} -{$IF DEFINED(GLB_LIB_JPEG)} +{$IF DEFINED(GLB_LAZ_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SaveJPEG(const aStream: TStream); +var + jpeg: TJPEGImage; + intf: TLazIntfImage; + raw: TRawImage; +begin + jpeg := TJPEGImage.Create; + intf := TLazIntfImage.Create(0, 0); + try + if not AssignToLazIntfImage(intf) then + raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); + intf.GetRawImage(raw); + jpeg.LoadFromRawImage(raw, false); + jpeg.SaveToStream(aStream); + finally + intf.Free; + jpeg.Free; + end; +end; + +{$ELSEIF DEFINED(GLB_LIB_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SaveJPEG(const aStream: TStream); var @@ -6373,7 +7236,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,16 +7245,16 @@ 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; //get suitable format case aInfo.biBitCount of 8: result := tfLuminance8; - 16: result := tfBGR5; - 24: result := tfBGR8; - 32: result := tfBGRA8; + 16: result := tfX1RGB5; + 24: result := tfRGB8; + 32: result := tfXRGB8; end; end; @@ -6551,7 +7414,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; @@ -6568,7 +7431,7 @@ procedure TglBitmap.SaveBMP(const aStream: TStream); var Header: TBMPHeader; Info: TBMPInfo; - Converter: TbmpColorTableFormat; + Converter: TFormatDescriptor; FormatDesc: TFormatDescriptor; SourceFD, DestFD: Pointer; pData, srcData, dstData, ConvertBuffer: pByte; @@ -6613,40 +7476,46 @@ begin Info.biBitCount := 4; Header.bfSize := Header.bfSize + 16 * SizeOf(Cardinal); Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries - Converter := TbmpColorTableFormat.Create; - Converter.PixelSize := 0.5; - Converter.Format := Format; - Converter.Range := glBitmapColorRec($F, $F, $F, $0); - Converter.CreateColorTable; + Converter := TbmpColorTableFormat.Create; + with (Converter as TbmpColorTableFormat) do begin + PixelSize := 0.5; + Format := Format; + Range := glBitmapColorRec($F, $F, $F, $0); + CreateColorTable; + end; end; tfR3G3B2, tfLuminance8: begin Info.biBitCount := 8; Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal); Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries - Converter := TbmpColorTableFormat.Create; - Converter.PixelSize := 1; - Converter.Format := Format; - if (Format = tfR3G3B2) then begin - Converter.Range := glBitmapColorRec($7, $7, $3, $0); - Converter.Shift := glBitmapShiftRec(0, 3, 6, 0); - end else - Converter.Range := glBitmapColorRec($FF, $FF, $FF, $0); - Converter.CreateColorTable; + Converter := TbmpColorTableFormat.Create; + with (Converter as TbmpColorTableFormat) do begin + PixelSize := 1; + Format := Format; + if (Format = tfR3G3B2) then begin + Range := glBitmapColorRec($7, $7, $3, $0); + Shift := glBitmapShiftRec(0, 3, 6, 0); + end else + Range := glBitmapColorRec($FF, $FF, $FF, $0); + CreateColorTable; + end; end; - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4: begin + tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin Info.biBitCount := 16; Info.biCompression := BMP_COMP_BITFIELDS; end; tfBGR8, tfRGB8: begin Info.biBitCount := 24; + if (Format = tfRGB8) then + Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values end; - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8: begin + tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, + tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: begin Info.biBitCount := 32; Info.biCompression := BMP_COMP_BITFIELDS; end; @@ -6672,9 +7541,10 @@ begin aStream.Write(Info, SizeOf(Info)); // colortable - if Assigned(Converter) then - aStream.Write(Converter.ColorTable[0].b, - SizeOf(TbmpColorTableEnty) * Length(Converter.ColorTable)); + if Assigned(Converter) and (Converter is TbmpColorTableFormat) then + with (Converter as TbmpColorTableFormat) do + aStream.Write(ColorTable[0].b, + SizeOf(TbmpColorTableEnty) * Length(ColorTable)); // bitmasks if Info.biCompression = BMP_COMP_BITFIELDS then begin @@ -6962,7 +7832,7 @@ begin if Header.ImageID <> 0 then // skip image ID aStream.Position := aStream.Position + Header.ImageID; - tgaFormat := tfEmpty; + tgaFormat := tfEmpty; case Header.Bpp of 8: if IsGrayFormat then case (Header.ImageDesc and $F) of 0: tgaFormat := tfLuminance8; @@ -6973,23 +7843,23 @@ begin 0: tgaFormat := tfLuminance16; 8: tgaFormat := tfLuminance8Alpha8; end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR5; - 1: tgaFormat := tfBGR5A1; - 4: tgaFormat := tfBGRA4; + 0: tgaFormat := tfX1RGB5; + 1: tgaFormat := tfA1RGB5; + 4: tgaFormat := tfARGB4; end; 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR8; + 0: tgaFormat := tfRGB8; end; 32: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 2: tgaFormat := tfBGR10A2; - 8: tgaFormat := tfBGRA8; + 2: tgaFormat := tfA2RGB10; + 8: tgaFormat := tfARGB8; end; 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); @@ -7069,7 +7939,7 @@ begin if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then Header.Bpp := 8 else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8, - tfRGB5, tfBGR5, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then + tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then Header.Bpp := 16 else if (Format in [tfBGR8, tfRGB8]) then Header.Bpp := 24 @@ -7097,13 +7967,13 @@ begin Converter := nil; FormatDesc := TFormatDescriptor.Get(Format); Size := FormatDesc.GetSize(Dimension); - if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin + if Format in [tfRGB5X1, 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 @@ -7214,21 +8084,28 @@ var D3DFMT_DXT3: result := tfS3tcDtx3RGBA; D3DFMT_DXT5: result := tfS3tcDtx5RGBA; end; - end else if ((Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin + end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin + // prepare masks + if ((dwFlags and DDPF_LUMINANCE) = 0) then begin + Range.r := dwRBitMask; + Range.g := dwGBitMask; + Range.b := dwBBitMask; + end else begin + Range.r := dwRBitMask; + Range.g := dwRBitMask; + Range.b := dwRBitMask; + end; + Range.a := dwABitMask; //find matching format for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin fd := TFormatDescriptor.Get(result); - if fd.MaskMatch(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask) and + if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and (8 * fd.PixelSize = dwRGBBitCount) then exit; end; //find format with same Range - Range.r := dwRBitMask; - Range.g := dwGBitMask; - Range.b := dwBBitMask; - Range.a := dwABitMask; for i := 0 to 3 do begin while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do Range.arr[i] := Range.arr[i] shr 1; @@ -7248,9 +8125,9 @@ var //no format with same range found -> use default if (result = tfEmpty) then begin if (dwABitMask > 0) then - result := tfBGRA8 + result := tfRGBA8 else - result := tfBGR8; + result := tfRGB8; end; Converter := TbmpBitfieldFormat.Create; @@ -7295,12 +8172,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 +8227,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; @@ -7481,9 +8358,11 @@ var begin // Upload data FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed then + if FormatDesc.IsCompressed then begin + if not Assigned(glCompressedTexImage1D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data) - else if aBuildWithGlu then + end else if aBuildWithGlu then gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) else glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data); @@ -7505,12 +8384,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; @@ -7572,6 +8451,8 @@ begin FormatDesc := TFormatDescriptor.Get(Format); if FormatDesc.IsCompressed then begin + if not Assigned(glCompressedTexImage2D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) end else if aBuildWithGlu then begin gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, @@ -7600,9 +8481,9 @@ var Size, w, h: Integer; FormatDesc: TFormatDescriptor; begin - FormatDesc := TFormatDescriptor.Get(Format); + FormatDesc := TFormatDescriptor.Get(aFormat); if FormatDesc.IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); + raise EglBitmapUnsupportedFormat.Create(aFormat); w := aRight - aLeft; h := aBottom - aTop; @@ -7611,7 +8492,7 @@ begin try glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, Format, w, h); //be careful, Data could be freed by this method + SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method FlipVert; except if Assigned(Temp) then @@ -7625,8 +8506,8 @@ procedure TglBitmap2D.GetDataFromTexture; var Temp: PByte; TempWidth, TempHeight: Integer; - TempIntFormat: Cardinal; - IntFormat, f: TglBitmapFormat; + TempIntFormat: GLint; + IntFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin Bind; @@ -7636,23 +8517,20 @@ begin glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT, @TempHeight); glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat); - IntFormat := tfEmpty; - for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(f); - if (FormatDesc.glInternalFormat = TempIntFormat) then begin - IntFormat := FormatDesc.Format; - break; - end; - end; + IntFormat := tfEmpty; + FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor); + IntFormat := FormatDesc.Format; // Getting data from OpenGL FormatDesc := TFormatDescriptor.Get(IntFormat); GetMem(Temp, FormatDesc.GetSize(TempWidth, TempHeight)); try - if FormatDesc.IsCompressed then + if FormatDesc.IsCompressed then begin + if not Assigned(glGetCompressedTexImage) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); glGetCompressedTexImage(Target, 0, Temp) - else - glGetTexImage(Target, 0, FormatDesc.glInternalFormat, FormatDesc.glDataFormat, Temp); + end else + glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method except if Assigned(Temp) then @@ -7673,12 +8551,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; @@ -7711,7 +8589,7 @@ begin Dec(TempDestData, fPixelSize); end; end; - SetDataPointer(DestData, Format); //be careful, Data could be freed by this method + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except if Assigned(DestData) then @@ -7739,7 +8617,7 @@ begin Dec(TempDestData, fRowSize); Inc(SourceData, fRowSize); end; - SetDataPointer(DestData, Format); //be careful, Data could be freed by this method + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except if Assigned(DestData) then @@ -7986,7 +8864,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 +8881,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 +9063,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); @@ -8203,9 +9082,15 @@ initialization finalization TFormatDescriptor.Finalize; +{$IFDEF GLB_NATIVE_OGL} + if Assigned(GL_LibHandle) then + glbFreeLibrary(GL_LibHandle); + {$IFDEF GLB_NATIVE_OGL_DYNAMIC} + if Assigned(GLU_LibHandle) then + glbFreeLibrary(GLU_LibHandle); FreeAndNil(InitOpenGLCS); {$ENDIF} +{$ENDIF} end. -